Add project files.

SacsCoreUnitTests/SacsCoreUnitTests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+
+    <RootNamespace>Sacs.UnitTests.Net</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.1.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.1.0" />
+    <PackageReference Include="coverlet.collector" Version="1.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SacsStandardBase\SacsStandardBase.csproj" />
+    <ProjectReference Include="..\SacsStandardDbas\SacsStandardDbas.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Core\" />
+    <Folder Include="Standard\Base\Core\" />
+    <Folder Include="Standard\Base\Dbas\" />
+  </ItemGroup>
+
+</Project>

SacsCoreUnitTests/Standard/Base/App/SacsCommandLineInfo_Tester.cs

@@ -0,0 +1,35 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.App;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Sacs.UnitTests.Net.Standard.Base.App
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsCommandLineInfo_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SacsCommandLineInfo_CTR()
+		{
+			SacsCommandLineInfo cmdLineInfo = new SacsCommandLineInfo(new String[]
+			{
+				"-ABC",
+				"/DEF",
+				"Andy",
+				"-SaProcess:ExportData",
+			});
+			Assert.IsNotNull(cmdLineInfo);
+			Assert.AreEqual(4, cmdLineInfo.ParamCount);
+			Assert.AreEqual(1, cmdLineInfo.ProcessDefinitions.Count);
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/App/SacsProcessDefinition_Tester.cs

@@ -0,0 +1,52 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.App;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Sacs.UnitTests.Net.Standard.Base.App
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsProcessDefinition_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SacsProcessDefinition_CTR()
+		{
+			// Valid process definitions.
+			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:ExportData"));
+			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:Proc=ExportData"));
+			Assert.IsNotNull(new SacsProcessDefinition("SaProcess:ExportData;User=System"));
+
+			// Invalid process definition - blank argument.
+			try
+			{
+				SacsProcessDefinition processDfn = new SacsProcessDefinition("");
+			}
+			catch (Exception exc)
+			{
+				Assert.AreEqual(typeof(NotSupportedException), exc.GetType());
+			}
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SacsProcessDefinition_IsValidProcessDefinition()
+		{
+			// Valid process params.
+			Assert.AreEqual(true, SacsProcessDefinition.IsValidProcessDefinition("SaProcess:ExportData"));
+
+			// Invalid process params.
+			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition(""));
+			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("Abc"));
+			Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("SaProcess"));
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Bus/SysId_Tester.cs

@@ -0,0 +1,179 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Bus;
+using Sarand.Net.Standard.Base.Utils;
+using System;
+using System.Collections.Generic;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Bus
+{
+	[TestClass]
+	public class SysId_Tester
+	{
+		//-------------------------------------------------------------------
+		// 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);
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SysId_CTR_Void ()
+		{
+			Assert.IsNotNull(new SysId());
+			Assert.AreEqual(new SysId().ToInt(), 0);
+			Assert.IsTrue(String.IsNullOrEmpty(new SysId().ToString()));
+			Assert.IsTrue(StringUtil.IsEmpty(new SysId().ToString()));
+			Assert.AreEqual(new SysId().ToString(), "");
+			Assert.AreEqual(new SysId().ToString(), string.Empty);
+		}
+
+		[TestMethod]
+		public void SysId_CTR_Long ()
+		{
+			// Zero - invalid.
+			Assert.IsNotNull(new SysId(0));
+
+			// 1 - Valid.
+			Assert.IsNotNull(new SysId(1));
+			Assert.IsNotNull(new SysId(-1));
+		}
+
+		//-------------------------------------------------------------------
+		// Is Valid.
+		[TestMethod]
+		public void SysId_IsValid ()
+		{
+			Assert.IsFalse(SysId.IsValid(null));
+			Assert.IsFalse(SysId.IsValid(new SysId()));
+			Assert.IsFalse(SysId.IsValid(new SysId(0)));
+			Assert.IsTrue(SysId.IsValid(new SysId(1)));
+			Assert.IsTrue(SysId.IsValid(new SysId(-1)));
+		}
+
+		//-------------------------------------------------------------------
+		// Invalid on null.
+		[TestMethod]
+		public void SysId_InvalidOnNull ()
+		{
+			Assert.IsNotNull(SysId.InvalidOnNull(null));
+			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(null)));
+			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId())));
+			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId(0))));
+			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(1))));
+			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(-1))));
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SysId_Equals_Object ()
+		{
+			Assert.IsFalse(id_.Equals(null));
+			Assert.IsFalse(id0.Equals(null));
+			Assert.IsFalse(id1.Equals(null));
+			Assert.IsFalse(id_.Equals((Object)id_));
+			Assert.IsFalse(id_.Equals((Object)id0));
+			Assert.IsFalse(id_.Equals((Object)id1));
+			Assert.IsFalse(id0.Equals((Object)id_));
+			Assert.IsFalse(id0.Equals((Object)id0));
+			Assert.IsFalse(id0.Equals((Object)id1));
+			Assert.IsFalse(id1.Equals((Object)id_));
+			Assert.IsFalse(id1.Equals((Object)id0));
+			Assert.IsTrue(id1.Equals((Object)id1));
+		}
+		[TestMethod]
+		public void SysId_Equals_SysId ()
+		{
+			// Invalid values always unequal.
+			Assert.IsFalse(id_.Equals(null));
+			Assert.IsFalse(id_.Equals(idNull));
+			Assert.IsFalse(id_.Equals(id_));
+			Assert.IsFalse(id_.Equals(id0));
+			Assert.IsFalse(id_.Equals(new SysId()));
+
+			// Valid values.
+			Assert.IsTrue(id1.Equals(new SysId(1)));
+
+			for (int i = 1; i <= 1000; i++)
+			{
+				SysId idI = new SysId(i);
+				for (int j = 1; j <= 1000; j++)
+				{
+					SysId idJ = new SysId(j);
+					if (i == j) Assert.IsTrue(idI.Equals(idJ));
+					else Assert.IsFalse(idI.Equals(idJ));
+
+				}
+			}
+		}
+		//-------------------------------------------------------------------
+
+		//-------------------------------------------------------------------
+		//                        S y s I d   L i s t
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SysId_List_GetIdCount ()
+		{
+			List<SysId> ids = new List<SysId>()
+			{
+				new SysId(),
+				new SysId(1),
+				new SysId(2),
+				new SysId(3),
+				new SysId(),
+				new SysId(3),
+				new SysId(2),
+				new SysId(1),
+				new SysId(),
+			};
+			// Unique, valid only.
+			Assert.AreEqual(3, ids.GetIdCount());
+			Assert.AreEqual(3, ids.GetIdCount(true,true));
+			// Unique including invalid.
+			Assert.AreEqual(4, ids.GetIdCount(false));
+			Assert.AreEqual(4, ids.GetIdCount(false,true));
+			// Duplicate, valid only.
+			Assert.AreEqual(6, ids.GetIdCount(true, false));
+			// Duplicate including invalid.
+			Assert.AreEqual(9, ids.GetIdCount(false,false));
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void SysId_List_HasValidIds ()
+		{
+			List<SysId> ids = new List<SysId>();
+
+			// Single valid Id.
+			ids.Clear();
+			ids.Add(new SysId(123));
+			Assert.AreEqual(true, ids.HasValidIds());
+
+			// Several valid ids.
+			ids.Clear();
+			ids.AddRange(new List<SysId>()
+			{
+				new SysId(1),
+				new SysId(2),
+				new SysId(3),
+			});
+			Assert.AreEqual(true, ids.HasValidIds());
+
+			// Invalid only.
+			ids.Clear();
+			ids.AddRange(new List<SysId>()
+			{
+				new SysId(),
+				new SysId(),
+				new SysId(),
+			});
+			Assert.AreEqual(false, ids.HasValidIds());
+
+			// Add valid Id.
+			ids.Add(new SysId(123));
+			Assert.AreEqual(true, ids.HasValidIds());
+		}
+
+		//-------------------------------------------------------------------
+	}
+}

SacsCoreUnitTests/Standard/Base/Data/SacsAesIvCrypter_Tester.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+using Sarand.Net.Standard.Base.Data;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Data
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsAesIvCrypter_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		private static Random random = new Random();
+		private TestContext testContextInstance;
+
+		//-------------------------------------------------------------------
+		// Construction.
+		public SacsAesIvCrypter_Tester ()
+		{
+		}
+
+		//-------------------------------------------------------------------
+		/// <summary>
+		///Gets or sets the test context which provides
+		///information about and functionality for the current test run.
+		///</summary>
+		public TestContext TestContext
+		{
+			get
+			{
+				return testContextInstance;
+			}
+			set
+			{
+				testContextInstance = value;
+			}
+		}
+
+		//-------------------------------------------------------------------
+		#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++)
+			{
+				String data = RandomString(random.Next(10, 2048), true);
+				int dataLength = data.Length;
+				String key = RandomString(random.Next(10, 128), true);
+				int keyLength = key.Length;
+				String encrypted = SacsAesIvCrypter.Encrypt(data, key);
+				int encryptedLength = encrypted.Length;
+				Assert.AreEqual(data, SacsAesIvCrypter.Decrypt(encrypted, key));
+			}
+		}
+
+		//-------------------------------------------------------------------
+		/// <summary>Generate random alphanumeric string</summary>
+		public static String RandomString (int length, bool includeLowerCase = true, bool includeSymbols = true)
+		{
+			String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+			if (includeLowerCase) chars += "abcdefghijklmnopqrstuvwxyz";
+			if (includeSymbols) chars += "`¬!\"£$%^&*()-=_+{}[];:'@#~<>?/.,\\| ";
+			return new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray());
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Data/SacsCsvHandler_Tester.cs

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

SacsCoreUnitTests/Standard/Base/Data/SacsDataFn_Tester.cs

@@ -0,0 +1,85 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Data
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsDataFn_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data memebrs.
+		private static Random random = new Random();
+
+		//-------------------------------------------------------------------
+		/// <summary>Create random alphanumeric string of specified length.</summary>
+		public static string RandomString (int length)
+		{
+			const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+			return new string(Enumerable.Repeat(chars, length)
+			  .Select(s => s[random.Next(s.Length)]).ToArray());
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void Sapphire ()
+		{
+			String encodedEncrypted = "6NP   R78:P.8$2Q";
+			String raw = SacsDataFn._sadcs (encodedEncrypted, new SacsData("SaItemOptionMgr_Odbc"));
+			Assert.AreEqual("sarand", raw);
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void Encode ()
+		{
+			// Test the Encoding algorythm.
+			for (int i = 0; i < 1000; i++)
+			{
+				String rawData = RandomString(random.Next(10,21));
+				SacsData dataEnc = SacsDataFn._saecd (new SacsData(rawData).DataBuffer);
+				Assert.AreNotEqual(rawData, dataEnc.NullTerminatedString);
+				SacsData dataDec = SacsDataFn._sadcd (dataEnc.DataBuffer);
+				Assert.AreEqual(rawData, dataDec.NullTerminatedString);
+			}
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void Encrypt_String ()
+		{
+			// Test the Encryption algorythm.
+			for (int i = 0; i < 1000; i++)
+			{
+				String rawData = RandomString(random.Next(10,21));
+				String dataEnc = SacsDataFn._saecs (rawData);
+				Assert.AreNotEqual(rawData, dataEnc);
+				String dataDec = SacsDataFn._sadcs (dataEnc);
+				Assert.AreEqual(rawData, dataDec);
+			}
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void RC4Encrypt_String ()
+		{
+			// Test the RC4 algorythm:
+			for (int i = 0; i < 1000; i++)
+			{
+				String rawData = RandomString(random.Next(10,21));
+				SacsData dataEnc = SacsDataFn.RC4 (new SacsData(rawData).DataBuffer);
+				Assert.AreNotEqual(rawData, dataEnc.NullTerminatedString);
+				SacsData dataDec = SacsDataFn.RC4 (dataEnc.DataBuffer);
+				Assert.AreEqual(rawData, dataDec.NullTerminatedString);
+			}
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Data/SacsData_Tester.cs

@@ -0,0 +1,61 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Data
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsData_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data memebrs.
+		private static Random random = new Random();
+
+		//-------------------------------------------------------------------
+		/// <summary>Create random alphanumeric string of specified length.</summary>
+		public static string RandomString (int length)
+		{
+			const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+			return new string(Enumerable.Repeat(chars, length)
+			  .Select(s => s[random.Next(s.Length)]).ToArray());
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		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));
+				// UniCode encoding.
+				Assert.AreEqual(rawValue, (String)new SacsData(rawValue, Encoding.Unicode));
+			}
+		}
+
+		//-------------------------------------------------------------------
+		[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)));
+				// UTF-8 encoding.
+				Assert.AreEqual(rawValue, (String)new SacsData(new SacsData(rawValue, Encoding.UTF8)));
+				// UniCode encoding.
+				Assert.AreEqual(rawValue, (String)new SacsData(new SacsData(rawValue, Encoding.Unicode)));
+			}
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Generic/ObjectReferences_Tester.cs

@@ -0,0 +1,86 @@
+using System.Drawing;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Generic
+{
+	[TestClass]
+	public class ObjectReferences_Tester
+	{
+		//-------------------------------------------------------------------
+		[TestMethod]
+		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.AreEqual(size1, size3);
+			Assert.AreEqual(size2, size3);
+			// Change size1 values - doesn't change size2.
+			size1.Width = 100;
+			size1.Height = 200;
+			Assert.AreNotEqual(size1, size2);
+			Assert.AreNotEqual(size1, size3);
+			Assert.AreEqual(size2, size3);
+		}
+		[TestMethod]
+		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.AreEqual(size1, size3);
+			Assert.AreEqual(size2, size3);
+			// Change size2 values - doesn't change size1.
+			size2.Width = 100;
+			size2.Height = 200;
+			Assert.AreNotEqual(size1, size2);
+			Assert.AreEqual(size1, size3);
+			Assert.AreNotEqual(size2, size3);
+		}
+		//-------------------------------------------------------------------
+		// Modify class value.
+		class TestData
+		{
+			public int a = 0;
+			public int B { get; set; }
+			public Size size1 = new Size(10,20);
+			public Size Size2 { get; set; } = new Size(30, 40);
+		}
+		[TestMethod]
+		public void ObjectReferences_ChangeClassValues ()
+		{
+			TestData td1 = new TestData();
+			TestData td2 = td1;
+			Assert.AreEqual(td1, td2);
+			td1.a++;  // td2 is still a reference to td1 with the same values.
+			Assert.AreEqual(td1, td2);
+			Assert.AreEqual(td1.a, td2.a);
+			Assert.AreEqual(td1.B, td2.B);
+			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.AreEqual(td1.Size2, td2.Size2);
+			td1.B++;  // td2 is still a reference to td1 with the same values.
+			Assert.AreEqual(td1, td2);
+			Assert.AreEqual(td1.a, td2.a);
+			Assert.AreEqual(td1.B, td2.B);
+			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.AreEqual(td1.Size2, td2.Size2);
+			td1.size1.Width += 10;  // td2 is still a reference to td1 with the same values.
+			Assert.AreEqual(td1, td2);
+			Assert.AreEqual(td1.a, td2.a);
+			Assert.AreEqual(td1.B, td2.B);
+			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.AreEqual(td1.Size2, td2.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.AreEqual(td1.a, td2.a);
+			Assert.AreEqual(td1.B, td2.B);
+			Assert.AreEqual(td1.size1, td2.size1);
+			Assert.AreEqual(td1.Size2, td2.Size2);
+		}
+		//-------------------------------------------------------------------
+	}
+}

SacsCoreUnitTests/Standard/Base/Generic/Regex_Tester.cs

@@ -0,0 +1,19 @@
+using System.Text.RegularExpressions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Generic
+{
+	[TestClass]
+	public class Regex_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void Regex_FolderPaths ()
+		{
+			Assert.AreEqual(true, Regex.IsMatch("abcabcabc\\.metadata\\.plugins\\abcabcabc", ".*?\\\\\\.metadata\\\\\\.plugins\\\\.*?"));
+		}
+		//-------------------------------------------------------------------
+	}
+}

SacsCoreUnitTests/Standard/Base/Helpers/SacsCsvHelper_Tester.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Helpers;
+using Sarand.Net.Standard.Base.Utils;
+
+namespace Sacs.UnitTests.Net.Standard.Base.Helpers
+{
+	//=======================================================================
+	[TestClass]
+	public class SacsCsvHelper_Tester
+	{
+		//-------------------------------------------------------------------
+		//                  C o n v e r t   F r o m   C S V
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void ParseCsv_Data ()
+		{
+			List<String> data = new List<string>()
+			{
+				"A,B,C",
+				"D,\"E\",F,\"\"\"G\"\"\",H,\"I,\"",
+				"W,X,Y,Z"
+			};
+
+			// Parser configurations - all for 'standard' conversion.
+			List<SacsCsvHelper.ParserConfig> parserConfigs = new List<SacsCsvHelper.ParserConfig>()
+			{
+				null,
+				new SacsCsvHelper.ParserConfig() { BufferSize = 1024 },
+				new SacsCsvHelper.ParserConfig() { CountBytes = true },
+				new SacsCsvHelper.ParserConfig() { Encoding = Encoding.ASCII },
+				new SacsCsvHelper.ParserConfig() { LineBreakInQuotedFieldIsBadData = true },
+				new SacsCsvHelper.ParserConfig() { Comment = '\'' },
+				new SacsCsvHelper.ParserConfig() { AllowComments = true },
+				new SacsCsvHelper.ParserConfig() { IgnoreBlankLines = false },
+				new SacsCsvHelper.ParserConfig() { IgnoreQuotes = false },
+				new SacsCsvHelper.ParserConfig() { Quote = '"' },
+				new SacsCsvHelper.ParserConfig() { Delimiter = "," },
+				new SacsCsvHelper.ParserConfig() { Escape = '"' },
+				//new SacsCsvHelper.ParserConfig() { TrimOptions = TrimOptions.Trim },
+			};
+
+			foreach (SacsCsvHelper.ParserConfig parserConfig in parserConfigs)
+			{
+				List<String[]> records = SacsCsvHelper.ParseCsv(data.Concat(Environment.NewLine), parserConfig);
+
+				Assert.IsNotNull(records);
+				// Record count.
+				Assert.AreEqual(data.Count, records.Count);
+				// Field counts.
+				Assert.AreEqual(3, records[0].Length);
+				Assert.AreEqual(6, records[1].Length);
+				Assert.AreEqual(4, records[2].Length);
+				// Field values.
+				Assert.AreEqual("B", records[0][1]);
+				Assert.AreEqual("E", records[1][1]);
+				Assert.AreEqual("\"G\"", records[1][3]);
+				Assert.AreEqual("I,", records[1][5]);
+				Assert.AreEqual("X", records[2][1]);
+			}
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void ParseCsv_Data_InvalidQuotes ()
+		{
+			List<String> data = new List<string>()
+			{
+				"A,B,C",
+				"D,\"E,G,F,G,H,I",
+				"W,X,Y,Z"
+			};
+			SacsCsvHelper.ParserConfig config = new SacsCsvHelper.ParserConfig();
+			List<String[]> records = SacsCsvHelper.ParseCsv(data.Concat(Environment.NewLine));
+
+			Assert.IsNotNull(records);
+			// 1 invalid record ignored.
+			Assert.AreEqual(data.Count - 1, records.Count);
+		}
+
+		//-------------------------------------------------------------------
+		//                    C o n v e r t   T o   C S V
+		//-------------------------------------------------------------------
+		[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.AreEqual("A,B,C", SacsCsvHelper.ToCsv(new Collection<String>() { "A", "B", "C" }));
+			Assert.AreEqual("A,B,C", SacsCsvHelper.ToCsv(new List<String>() { "A", "B", "C" }));
+			Assert.AreEqual("D,E,F", SacsCsvHelper.ToCsv(new String[] { "D", "E", "F" }));
+
+			// Embedded delimiter.
+			Assert.AreEqual("\"A,\",B,C", SacsCsvHelper.ToCsv(new String[] { "A,", "B", "C" }));
+			Assert.AreEqual("A,\",B\",C", SacsCsvHelper.ToCsv(new String[] { "A", ",B", "C" }));
+
+			// Embedded quotes.
+			Assert.AreEqual("\"\"\"A\"\"\",B,C", SacsCsvHelper.ToCsv(new String[] { "\"A\"", "B", "C" }));
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void ToCsv_Records ()
+		{
+			//SaCsvHelper csvHelper = new SaCsvHelper();
+
+			List<String[]> dataRecords = new List<String[]>
+			{
+				new String[]{ "A", "B", "C" },
+				new String[]{ "D", "E", "F", "G", "H", "I" },
+				new String[]{ "W", "X", "Y", "Z" }
+			};
+			List<String> records = SacsCsvHelper.ToCsv(dataRecords);
+
+			// Multiple records, multiple times to verify clearing of data each time.
+			for (int i = 0; i < 10; i++)
+			{
+				Assert.AreEqual(3, records.Count);
+				Assert.AreEqual("A,B,C", records[0]);
+				Assert.AreEqual("D,E,F,G,H,I", records[1]);
+				Assert.AreEqual("W,X,Y,Z", records[2]);
+			}
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Utils/DateUtil_Tester.cs

@@ -0,0 +1,259 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Utils;
+
+namespace Sarand.UnitTests.Core.Base.Utils
+{
+	//=======================================================================
+	[TestClass]
+	public class DateUtil_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		private Random random = new Random();
+		private DateTime today = DateTime.Today;
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void DateTime_CTR_Void ()
+		{
+			Assert.IsNotNull(new DateTime());
+			Assert.AreEqual(new DateTime(), DateTime.MinValue);
+		}
+
+		//-------------------------------------------------------------------
+		//                          S e t   T i m e
+		//-------------------------------------------------------------------
+		[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.AreEqual(DateUtil.FormatXmlTime(time), DateUtil.FormatXmlTime(date.SetTime(time)));
+			}
+		}
+		[TestMethod]
+		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.AreEqual(DateUtil.FormatXmlTime(today + time), DateUtil.FormatXmlTime(date.SetTime(time)));
+			}
+		}
+
+		//-------------------------------------------------------------------
+		//                        R o u n d   T i m e
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void RoundTime ()
+		{
+			for (int i = 0; i < 2000; i++)
+			{
+				DateTime datetime = 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));
+				ushort intervalMins = (ushort)random.Next(1,61);
+				{
+					// Round up without seconds.
+					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));
+				}
+				{
+					// 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));
+				}
+				{
+					// 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));
+				}
+				{
+					// 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));
+				}
+				{
+					// Nearest without seconds.
+					int expectedMins = ((datetime.Minute / intervalMins) + (datetime.Minute % intervalMins > (intervalMins/2) ? 1 : 0)) * intervalMins;
+					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
+					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Nearest,true);
+					if (!DateUtil.FormatXmlDateTime(expected).Equals(DateUtil.FormatXmlDateTime(rounded)))
+					{
+						//String s = "";
+					}
+					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+				}
+				{
+					// Nearest with seconds.
+					int expectedMins = ((datetime.Minute / intervalMins) + ((datetime.Minute * 60 + datetime.Second) % (intervalMins * 60) > (intervalMins*60/2) ? 1 : 0)) * intervalMins;
+					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
+					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Nearest,false);
+					if (!DateUtil.FormatXmlDateTime(expected).Equals(DateUtil.FormatXmlDateTime(rounded)))
+					{
+						//String s = "";
+					}
+					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
+				}
+			}
+		}
+
+		//-------------------------------------------------------------------
+		//               C o n v e r t   F r o m   S t r i n g
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void DateTime_ParseXmlDate ()
+		{
+			String xmlDate = "2015-05-28";
+			Assert.AreEqual(new DateTime(2015, 5, 28), DateUtil.ParseXmlDate(xmlDate));
+		}
+
+		//-------------------------------------------------------------------
+		[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));
+		}
+
+		//-------------------------------------------------------------------
+		[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));
+		}
+
+		//-------------------------------------------------------------------------
+		//                           V a l i d a t i o n
+		//-------------------------------------------------------------------------
+		[TestMethod]
+		public void DateTime_IsValid ()
+		{
+			// Valid.
+			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Now));
+			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Today));
+			Assert.AreEqual(true, DateUtil.IsValid(new DateTime(2018, 2, 12, 10, 32, 56)));
+
+			// Invalid.
+			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MinValue));
+			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MaxValue));
+			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(0)));
+			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(1, 1, 1)));
+
+			// Nullable.
+			Assert.AreEqual(false, DateUtil.IsValid(null));
+		}
+
+		//-------------------------------------------------------------------
+		// Relative dates - Week.
+		// DateUtil.StartOfWeek
+		[TestMethod]
+		public void DateTime_StartOfWeek ()
+		{
+			for (int i = 0; i < 1000; i++)
+			{
+				// 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(date.StartOfWeek().Format("ddd"), "Sun");
+			}
+		}
+		// DateUtil.StartOfWeek
+		[TestMethod]
+		public void DateTime_StartOfWorkingWeek ()
+		{
+			for (int i = 0; i < 1000; i++)
+			{
+				// 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(date.StartOfWorkingWeek().Format("ddd"), "Mon");
+			}
+		}
+
+		//-------------------------------------------------------------------
+		// Relative dates - Month.
+		// DateUtil.StartOfMonth
+		[TestMethod]
+		public void DateTime_StartOfMonth ()
+		{
+			DateTime dt20160723 = new DateTime(2016, 7, 23);
+			Assert.AreEqual(dt20160723.StartOfMonth(), new DateTime(2016, 7, 1));
+		}
+		// DateUtil.EndOfMonth
+		[TestMethod]
+		public void DateTime_DaysInMonth ()
+		{
+			DateTime dt20160723 = new DateTime(2016, 7, 23);
+			Assert.AreEqual(dt20160723.DaysInMonth(), 31);
+		}
+		// DateUtil.EndOfMonth
+		[TestMethod]
+		public void DateTime_EndOfMonth ()
+		{
+			DateTime dt20160723 = new DateTime(2016, 7, 23);
+			Assert.AreEqual(dt20160723.EndOfMonth(), new DateTime(2016, 7, 31));
+		}
+
+		//-------------------------------------------------------------------
+		//                        F o r m a t t i n g
+		//-------------------------------------------------------------------
+		[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(dt20160723.Format("dd/MM/yyyy"), "23/07/2016");
+			Assert.AreEqual(dt20160723.Format("dd/MM/yyyy HH:mm:ss"), "23/07/2016 00:00:00");
+
+			Assert.AreEqual(dt20160723172829.Format("dd/MM/yyyy"), "23/07/2016");
+			Assert.AreEqual(dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"), "23/07/2016 17:28:39");
+		}
+
+		//-------------------------------------------------------------------
+		[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.AreEqual("2016-07-23", DateUtil.FormatXmlDate(dt20160723172829));
+		}
+
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void DateTime_FormatXmlTime ()
+		{
+			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);
+
+			Assert.AreEqual("17:28:39", DateUtil.FormatXmlTime(dt20160723172829));
+		}
+
+		//-------------------------------------------------------------------
+		[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));
+		}
+
+		//-------------------------------------------------------------------
+	}
+	//=======================================================================
+}

SacsCoreUnitTests/Standard/Base/Utils/EnumUtil_Tester.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Core;
+using Sarand.Net.Standard.Base.Utils;
+
+namespace Sarand.UnitTests.Core.Base.Utils
+{
+	[TestClass]
+	public class EnumUtil_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void EnumUtil_IsValid ()
+		{
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(0));
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(1));
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(2));
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(3));
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(4));
+			Assert.IsTrue(EnumUtil.IsValid<SaMessageLevel>(5));
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void EnumUtil_GetName ()
+		{
+			Assert.AreEqual("Info", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Info));
+			Assert.AreEqual("Debug", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Debug));
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void EnumUtil_GetValues ()
+		{
+			Assert.AreEqual(9,EnumUtil.GetValues<SaMessageLevel>().ToList().Count);
+			Assert.AreEqual(SaMessageLevel.Info,EnumUtil.GetValues<SaMessageLevel>().ToArray()[6]);
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void EnumUtil_ParseEnum ()
+		{
+			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.ParseEnum<SaMessageLevel>("Info"));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.ParseEnum<SaMessageLevel>("Debug"));
+		}
+		[TestMethod]
+		[ExpectedException(typeof(ArgumentException), "Requested value 'ABC' was not found.")]
+		public void EnumUtil_ParseEnum_Exception ()
+		{
+			SaMessageLevel messageLevel = EnumUtil.ParseEnum<SaMessageLevel>("ABC");
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void EnumUtil_StartsWith ()
+		{
+			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("I", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("i", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Info, EnumUtil.StartsWith<SaMessageLevel>("inf", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("D", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("d", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DE", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEB", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEBU", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.StartsWith<SaMessageLevel>("DEBUG", SaMessageLevel.Error));
+			Assert.AreEqual(EnumUtil.StartsWith<SaMessageLevel>("Err", SaMessageLevel.Error), SaMessageLevel.Error);
+			Assert.AreEqual(SaMessageLevel.None, EnumUtil.StartsWith<SaMessageLevel>("", SaMessageLevel.Error));
+			Assert.AreEqual(SaMessageLevel.Error, EnumUtil.StartsWith<SaMessageLevel>("ABC", SaMessageLevel.Error));
+		}
+		//-------------------------------------------------------------------
+	}
+}

SacsCoreUnitTests/Standard/Base/Utils/FtpUtil_Tester.cs

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

SacsCoreUnitTests/Standard/Base/Utils/StringListUtil_Tester.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Utils;
+
+namespace Sarand.UnitTests.Core.Base.Utils
+{
+	[TestClass]
+	public class StringListUtil_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		private Random random = new Random();
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringList_CreateList ()
+		{
+			List<String> values = StringListUtil.CreateList("ABC",3);
+			Assert.AreEqual(3, values.Count);
+			Assert.AreEqual("ABC,ABC,ABC", values.Concat(","));
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringList_RemoveBlanks ()
+		{
+			List<String> values = new List<string>();
+			values.Add("");
+			values.Add("A");
+			values.Add(" ");
+			values.Add("B");
+			values.Add("");
+			values.Add("C");
+			Assert.AreEqual(6, values.Count);
+
+			// Remove blanks without trimming.
+			values.RemoveBlanks(false);
+			Assert.AreEqual(4, values.Count);
+
+			// Remove blanks with trimming.
+			values.RemoveBlanks(true);
+			Assert.AreEqual(3, values.Count);
+
+			// Only blanks in list.
+			values.Clear();
+			values.Add("");
+			values.Add(" ");
+			values.Add("");
+			values.Add(" ");
+			values.Add("");
+			Assert.AreEqual(5, values.Count);
+			values.RemoveBlanks();
+			Assert.AreEqual(0, values.Count);
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringList_RemoveDuplicatesCI ()
+		{
+			List<String> values = new List<string>();
+			values.Add("C");
+			values.Add("A");
+			values.Add("c");
+			values.Add("B");
+			values.Add("b");
+			values.Add("C");
+			Assert.AreEqual(6, values.Count);
+			Assert.AreEqual("C,A,C,B,B,C", values.Concat(",").ToUpper());
+
+			// Remove blanks without trimming.
+			values.RemoveDuplicatesCI();
+			Assert.AreEqual(3, values.Count);
+			Assert.AreEqual("C,A,B", values.Concat(","));
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringList_Split ()
+		{
+			// Simple delimiter.
+			List<String> values = StringListUtil.Split("A:B:C",":");
+			Assert.AreEqual(3, values.Count);
+			Assert.AreEqual("A,B,C", values.Concat(","));
+
+			// Simple delimiter, null value.
+			values = StringListUtil.Split(null, ":");
+			Assert.AreEqual(0, values.Count);
+			Assert.AreEqual("", values.Concat(","));
+
+			// Simple delimiter, empty value.
+			values = StringListUtil.Split("", ":");
+			Assert.AreEqual(1, values.Count);
+			Assert.AreEqual("", values.Concat(","));
+
+			// Null delimiter.
+			values = StringListUtil.Split("A:B:C", null);
+			Assert.AreEqual(1, values.Count);
+			Assert.AreEqual("A:B:C", values.Concat(","));
+
+			// Blank delimiter.
+			values = StringListUtil.Split("A:B:C", "");
+			Assert.AreEqual(1, values.Count);
+			Assert.AreEqual("A:B:C", values.Concat(","));
+
+			// Blank values.
+			values = StringListUtil.Split("A::B: :C:::", ":", true, true);
+			Assert.AreEqual(3, values.Count);
+			Assert.AreEqual("A,B,C", values.Concat(","));
+		}
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringList_Concat ()
+		{
+			List<String> values = new List<string>();
+			values.Add("");
+			values.Add("A");
+			values.Add(" ");
+			values.Add("B");
+			values.Add("");
+			values.Add("C");
+			values.Add(" ");
+			Assert.AreEqual(7, values.Count);
+			Assert.AreEqual(",A,,B,,C,", values.Concat(","));
+			Assert.AreEqual(",A, ,B,,C, ", values.Concat(",", "", "", false, false));
+			Assert.AreEqual(",A,,B,,C,", values.Concat(",", "", "", true, false));
+			Assert.AreEqual("A,B,C", values.Concat(",", "", "", true, true));
+		}
+		//-------------------------------------------------------------------
+	}
+}

SacsCoreUnitTests/Standard/Base/Utils/StringUtil_Tester.cs

@@ -0,0 +1,99 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Sarand.Net.Standard.Base.Utils;
+
+namespace Sarand.UnitTests.Core.Base.Utils
+{
+	[TestClass]
+	public class StringUtil_Tester
+	{
+		//-------------------------------------------------------------------
+		// Data members.
+		private Random random = new Random();
+
+		//-------------------------------------------------------------------
+		//                           P a d d i n g
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringUtil_PadLeft ()
+		{
+			// Leading spaces.
+			Assert.AreEqual("   ", "".PadLeft(3, ' '));
+			Assert.AreEqual("  A", "A".PadLeft(3, ' '));
+			Assert.AreEqual(" AB", "AB".PadLeft(3, ' '));
+			Assert.AreEqual("ABC", "ABC".PadLeft(3, ' '));
+			Assert.AreEqual("ABCD", "ABCD".PadLeft(3, ' '));
+
+			// Leading zeroes.
+			Assert.AreEqual("00", "".PadLeft(2, '0'));
+			Assert.AreEqual("01", "1".PadLeft(2, '0'));
+			Assert.AreEqual("123", "123".PadLeft(3, '0'));
+			Assert.AreEqual("0123", "123".PadLeft(4, '0'));
+			Assert.AreEqual("00123", "123".PadLeft(5, '0'));
+		}
+		[TestMethod]
+		public void StringUtil_PadRight ()
+		{
+			// Leading spaces.
+			Assert.AreEqual("   ", "".PadRight(3, ' '));
+			Assert.AreEqual("A  ", "A".PadRight(3, ' '));
+			Assert.AreEqual("AB ", "AB".PadRight(3, ' '));
+			Assert.AreEqual("ABC", "ABC".PadRight(3, ' '));
+			Assert.AreEqual("ABCD", "ABCD".PadRight(3, ' '));
+
+			// Trailing zeroes.
+			Assert.AreEqual("00", "".PadRight(2, '0'));
+			Assert.AreEqual("10", "1".PadRight(2, '0'));
+			Assert.AreEqual("12", "12".PadRight(2, '0'));
+			Assert.AreEqual("123", "123".PadRight(3, '0'));
+			Assert.AreEqual("1230", "123".PadRight(4, '0'));
+			Assert.AreEqual("12300", "123".PadRight(5, '0'));
+		}
+
+		//-------------------------------------------------------------------
+		//                        S u b   S t r i n g
+		//-------------------------------------------------------------------
+		[TestMethod]
+		public void StringUtil_SubstringSafe ()
+		{
+			Assert.AreEqual(StringUtil.SubstringSafe(null, 0), "");
+			Assert.AreEqual(StringUtil.SubstringSafe("", 0), "");
+			Assert.AreEqual("".SubstringSafe(0), "");
+
+			// Right portion from start position.
+			Assert.AreEqual("abc".SubstringSafe(-3), "abc");
+			Assert.AreEqual("abc".SubstringSafe(-2), "abc");
+			Assert.AreEqual("abc".SubstringSafe(-1), "abc");
+			Assert.AreEqual("abc".SubstringSafe(0), "abc");
+			Assert.AreEqual("abc".SubstringSafe(1), "bc");
+			Assert.AreEqual("abc".SubstringSafe(2), "c");
+			Assert.AreEqual("abc".SubstringSafe(3), "");
+
+			// Zero length.
+			Assert.AreEqual(StringUtil.SubstringSafe(null, 0, 0), "");
+			Assert.AreEqual(StringUtil.SubstringSafe("", 0, 0), "");
+			Assert.AreEqual("".SubstringSafe(0, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(-1, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(0, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(1, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(2, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(3, 0), "");
+			Assert.AreEqual("abc".SubstringSafe(4, 0), "");
+
+			// Mid portion.
+			Assert.AreEqual("abcde".SubstringSafe(0, 3), "abc");
+			Assert.AreEqual("abcde".SubstringSafe(1, 3), "bcd");
+			Assert.AreEqual("abcde".SubstringSafe(2, 3), "cde");
+
+			// Excessive length.
+			Assert.AreEqual("abcde".SubstringSafe(-1, 12), "abcde");
+			Assert.AreEqual("abcde".SubstringSafe(0, 12), "abcde");
+			Assert.AreEqual("abcde".SubstringSafe(1, 12), "bcde");
+			Assert.AreEqual("abcde".SubstringSafe(2, 12), "cde");
+			Assert.AreEqual("abcde".SubstringSafe(3, 12), "de");
+			Assert.AreEqual("abcde".SubstringSafe(4, 12), "e");
+			Assert.AreEqual("abcde".SubstringSafe(5, 12), "");
+		}
+		//-------------------------------------------------------------------
+	}
+}