Sarand/Common-VS2019
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Migrate Common tests to NUnit

Browse Source
This commit is contained in:
Andy Howard
2026-09-15 10:26:59 +01:00
parent 7651e8824f
commit 27d2accb32
31 changed files with 1057 additions and 1156 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SacsCoreUnitTests/SacsCoreUnitTests.csproj
+9 -2
View File
@@ -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="MSTest.TestFramework" Version="4.4.0" />
<PackageReference Include="NUnit" Version="4.6.1" />
<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
+8 -12
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsCommandLineInfo_Tester
{
//-------------------------------------------------------------------
// Data members.
// --- Tests ---
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.AreEqual(4, cmdLineInfo.ParamCount);
Assert.AreEqual(1, cmdLineInfo.ProcessDefinitions.Count);
Assert.That(cmdLineInfo, Is.Not.Null);
Assert.That(cmdLineInfo.ParamCount, Is.EqualTo(4));
Assert.That(cmdLineInfo.ProcessDefinitions.Count, Is.EqualTo(1));
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/App/SacsProcessDefinition_Tester.cs
+14 -19
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsProcessDefinition_Tester
{
//-------------------------------------------------------------------
// Data members.
// --- Tests ---
//-------------------------------------------------------------------
[TestMethod]
[Test]
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"));
Assert.That(new SacsProcessDefinition("SaProcess:ExportData"), Is.Not.Null);
Assert.That(new SacsProcessDefinition("SaProcess:Proc=ExportData"), Is.Not.Null);
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)));
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("Abc"));
Assert.AreEqual(false, SacsProcessDefinition.IsValidProcessDefinition("SaProcess"));
Assert.That(SacsProcessDefinition.IsValidProcessDefinition(""), Is.EqualTo(false));
Assert.That(SacsProcessDefinition.IsValidProcessDefinition("Abc"), Is.EqualTo(false));
Assert.That(SacsProcessDefinition.IsValidProcessDefinition("SaProcess"), Is.EqualTo(false));
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/Bus/SysId_Tester.cs
+66 -72
View File
@@ -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);
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
public void SysId_CTR_Void ()
{
Assert.IsNotNull(new SysId());
Assert.AreEqual(0, new SysId().ToInt());
Assert.IsTrue(String.IsNullOrEmpty(new SysId().ToString()));
Assert.IsTrue(StringUtil.IsEmpty(new SysId().ToString()));
Assert.AreEqual("", new SysId().ToString());
Assert.AreEqual(string.Empty, new SysId().ToString());
Assert.That(new SysId(), Is.Not.Null);
Assert.That(new SysId().ToInt(), Is.EqualTo(0));
Assert.That(String.IsNullOrEmpty(new SysId().ToString()), Is.True);
Assert.That(StringUtil.IsEmpty(new SysId().ToString()), Is.True);
Assert.That(new SysId().ToString(), Is.Empty);
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.IsNotNull(new SysId(-1));
Assert.That(new SysId(1), Is.Not.Null);
Assert.That(new SysId(-1), Is.Not.Null);
}
//-------------------------------------------------------------------
// Is Valid.
[TestMethod]
[Test]
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)));
Assert.That(SysId.IsValid(null), Is.False);
Assert.That(SysId.IsValid(new SysId()), Is.False);
Assert.That(SysId.IsValid(new SysId(0)), Is.False);
Assert.That(SysId.IsValid(new SysId(1)), Is.True);
Assert.That(SysId.IsValid(new SysId(-1)), Is.True);
}
//-------------------------------------------------------------------
// Invalid on null.
[TestMethod]
[Test]
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))));
Assert.That(SysId.InvalidOnNull(null), Is.Not.Null);
Assert.That(SysId.IsValid(SysId.InvalidOnNull(null)), Is.False);
Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId())), Is.False);
Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(0))), Is.False);
Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(1))), Is.True);
Assert.That(SysId.IsValid(SysId.InvalidOnNull(new SysId(-1))), Is.True);
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
Assert.That(id_.Equals(null), Is.False);
Assert.That(id0.Equals(null), Is.False);
Assert.That(id1.Equals(null), Is.False);
Assert.That(id_.Equals((Object)id_), Is.False);
Assert.That(id_.Equals((Object)id0), Is.False);
Assert.That(id_.Equals((Object)id1), Is.False);
Assert.That(id0.Equals((Object)id_), Is.False);
Assert.That(id0.Equals((Object)id0), Is.False);
Assert.That(id0.Equals((Object)id1), Is.False);
Assert.That(id1.Equals((Object)id_), Is.False);
Assert.That(id1.Equals((Object)id0), Is.False);
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.IsFalse(id_.Equals(idNull));
Assert.IsFalse(id_.Equals(id_));
Assert.IsFalse(id_.Equals(id0));
Assert.IsFalse(id_.Equals(new SysId()));
Assert.That(id_.Equals(null), Is.False);
Assert.That(id_.Equals(idNull), Is.False);
Assert.That(id_.Equals(id_), Is.False);
Assert.That(id_.Equals(id0), Is.False);
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));
else Assert.IsFalse(idI.Equals(idJ));
if (i == j) Assert.That(idI.Equals(idJ), Is.True);
else Assert.That(idI.Equals(idJ), Is.False);
}
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
// S y s I d L i s t
//-------------------------------------------------------------------
[TestMethod]
// --- Lists ---
[Test]
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.AreEqual(3, ids.GetIdCount(true,true));
Assert.That(ids.GetIdCount(), Is.EqualTo(3));
Assert.That(ids.GetIdCount(true, true), Is.EqualTo(3));
// Unique including invalid.
Assert.AreEqual(4, ids.GetIdCount(false));
Assert.AreEqual(4, ids.GetIdCount(false,true));
Assert.That(ids.GetIdCount(false), Is.EqualTo(4));
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));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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
+11 -47
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsAesIvCrypter_Tester
{
//-------------------------------------------------------------------
// Data members.
// --- Data Members ---
private static Random random = new Random();
//-------------------------------------------------------------------
// Construction.
public SacsAesIvCrypter_Tester ()
{
}
// --- Tests ---
//-------------------------------------------------------------------
/// <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]
[Test]
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
+34 -39
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsCsvHandler_Tester
{
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
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);
Assert.That(SacsCsvHandler.ParseCsvRecord(null).Count, Is.EqualTo(0));
Assert.That(SacsCsvHandler.ParseCsvRecord("").Count, Is.EqualTo(1));
Assert.That(SacsCsvHandler.ParseCsvRecord(",").Count, Is.EqualTo(2));
Assert.That(SacsCsvHandler.ParseCsvRecord("A,B,C").Count, Is.EqualTo(3));
Assert.That(SacsCsvHandler.ParseCsvRecord("A,B,C,D,E").Count, Is.EqualTo(5));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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]);
Assert.That(fields.Count, Is.EqualTo(3));
Assert.That(fields[1], Is.EqualTo("B"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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]);
Assert.That(fields.Count, Is.EqualTo(3));
Assert.That(fields[0], Is.EqualTo("A"));
Assert.That(fields[1], Is.EqualTo("B"));
Assert.That(fields[2], Is.EqualTo("C"));
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]);
Assert.That(fields.Count, Is.EqualTo(3));
Assert.That(fields[0], Is.EqualTo("A"));
Assert.That(fields[1], Is.EqualTo("B"));
Assert.That(fields[2], Is.EqualTo("C"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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]);
Assert.That(fields.Count, Is.EqualTo(3));
Assert.That(fields[0], Is.EqualTo("A"));
Assert.That(fields[1], Is.EqualTo(","));
Assert.That(fields[2], Is.EqualTo("C"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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]);
Assert.That(fields.Count, Is.EqualTo(3));
Assert.That(fields[0], Is.EqualTo("A"));
Assert.That(fields[1], Is.EqualTo("\""));
Assert.That(fields[2], Is.EqualTo("C"));
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/Data/SacsDataFn_Tester.cs
+21 -24
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsDataFn_Tester
{
//-------------------------------------------------------------------
// Data memebrs.
// --- Data Members ---
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());
}
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[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"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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
+17 -18
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsData_Tester
{
//-------------------------------------------------------------------
// Data memebrs.
// --- Data Members ---
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());
}
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[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));
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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
+30 -28
View File
@@ -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));
StringAssert.Contains(sqlConnection.ConnectionString, "Server=localhost");
StringAssert.Contains(sqlConnection.ConnectionString, "Database=TestDb");
Assert.IsInstanceOfType(odbcConnection, typeof(OdbcConnection));
Assert.AreEqual(config.ConnectionString, odbcConnection.ConnectionString);
Assert.That(sqlConnection, Is.TypeOf<SqlConnection>());
Assert.That(sqlConnection.ConnectionString, Does.Contain("Server=localhost"));
Assert.That(sqlConnection.ConnectionString, Does.Contain("Database=TestDb"));
Assert.That(odbcConnection, Is.TypeOf<OdbcConnection>());
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.AreEqual(12, command.Parameters[0].Value);
Assert.AreEqual(DbType.Int32, command.Parameters[0].DbType);
Assert.AreEqual(DBNull.Value, command.Parameters[1].Value);
Assert.AreEqual(DbType.Int32, command.Parameters[1].DbType);
Assert.AreEqual(DBNull.Value, command.Parameters[2].Value);
Assert.AreEqual(DbType.Binary, command.Parameters[2].DbType);
Assert.That(command.Parameters[0].ParameterName, Is.EqualTo("@Count"));
Assert.That(command.Parameters[0].Value, Is.EqualTo(12));
Assert.That(command.Parameters[0].DbType, Is.EqualTo(DbType.Int32));
Assert.That(command.Parameters[1].Value, Is.EqualTo(DBNull.Value));
Assert.That(command.Parameters[1].DbType, Is.EqualTo(DbType.Int32));
Assert.That(command.Parameters[2].Value, Is.EqualTo(DBNull.Value));
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.AreEqual(DbType.DateTime, odbcCommand.Parameters[0].DbType);
Assert.AreEqual(value.AddMilliseconds(-456), sqlCommand.Parameters[0].Value);
Assert.AreEqual(value.AddMilliseconds(-456), odbcCommand.Parameters[0].Value);
Assert.That(sqlCommand.Parameters[0].DbType, Is.EqualTo(DbType.DateTime2));
Assert.That(odbcCommand.Parameters[0].DbType, Is.EqualTo(DbType.DateTime));
Assert.That(sqlCommand.Parameters[0].Value, Is.EqualTo(value.AddMilliseconds(-456)));
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.AreEqual(DBNull.Value, command.Parameters[1].Value);
Assert.AreEqual(DBNull.Value, command.Parameters[2].Value);
Assert.AreEqual(DbType.DateTime2, command.Parameters[0].DbType);
Assert.AreEqual(DbType.DateTime2, command.Parameters[1].DbType);
Assert.AreEqual(DbType.DateTime2, command.Parameters[2].DbType);
Assert.That(command.Parameters[0].Value, Is.EqualTo(DBNull.Value));
Assert.That(command.Parameters[1].Value, Is.EqualTo(DBNull.Value));
Assert.That(command.Parameters[2].Value, Is.EqualTo(DBNull.Value));
Assert.That(command.Parameters[0].DbType, Is.EqualTo(DbType.DateTime2));
Assert.That(command.Parameters[1].DbType, Is.EqualTo(DbType.DateTime2));
Assert.That(command.Parameters[2].DbType, Is.EqualTo(DbType.DateTime2));
}
// --- The End ---
SacsCoreUnitTests/Standard/Base/Email/SaEmailConsole_Tester.cs
+32 -32
View File
@@ -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.AreEqual("to@example.com", ((MailboxAddress)message.To.Single()).Address);
Assert.AreEqual("cc@example.com", ((MailboxAddress)message.Cc.Single()).Address);
CollectionAssert.AreEquivalent(
new[] { "bcc@example.com", "configured-bcc@example.com" },
message.Bcc.Mailboxes.Select(address => address.Address).ToArray());
Assert.AreEqual("Test subject", message.Subject);
Assert.AreEqual("Test body", message.TextBody);
Assert.IsNull(message.HtmlBody);
Assert.That(((MailboxAddress)message.From.Single()).Address, Is.EqualTo("sender@example.com"));
Assert.That(((MailboxAddress)message.To.Single()).Address, Is.EqualTo("to@example.com"));
Assert.That(((MailboxAddress)message.Cc.Single()).Address, Is.EqualTo("cc@example.com"));
Assert.That(
message.Bcc.Mailboxes.Select(address => address.Address).ToArray(),
Is.EquivalentTo(new[] { "bcc@example.com", "configured-bcc@example.com" }));
Assert.That(message.Subject, Is.EqualTo("Test subject"));
Assert.That(message.TextBody, Is.EqualTo("Test body"));
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.IsNull(message.TextBody);
Assert.That(message.HtmlBody, Is.EqualTo("<p>Test body</p>"));
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.AreEqual("text/plain", attachment.ContentType.MimeType);
Assert.AreEqual(ContentDisposition.Attachment, attachment.ContentDisposition.Disposition);
Assert.AreEqual(ContentEncoding.Base64, attachment.ContentTransferEncoding);
Assert.That(attachment.FileName, Is.EqualTo("test.txt"));
Assert.That(attachment.ContentType.MimeType, Is.EqualTo("text/plain"));
Assert.That(attachment.ContentDisposition.Disposition, Is.EqualTo(ContentDisposition.Attachment));
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.AreEqual(ContentDisposition.Inline, attachment.ContentDisposition.Disposition);
Assert.AreEqual("<img src=\"cid:test-image@example.com\">", message.HtmlBody);
Assert.That(attachment.FileName, Is.EqualTo("test.png"));
Assert.That(attachment.ContentDisposition.Disposition, Is.EqualTo(ContentDisposition.Inline));
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
+43 -42
View File
@@ -1,47 +1,47 @@
using System.Drawing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Drawing;
using NUnit.Framework;
namespace Sacs.UnitTests.Net.Standard.Base.Generic
{
[TestClass]
[TestFixture]
public class ObjectReferences_Tester
{
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[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.AreEqual(size1, size3);
Assert.AreEqual(size2, size3);
Assert.That(size2, Is.EqualTo(size1));
Assert.That(size3, Is.EqualTo(size1));
Assert.That(size3, Is.EqualTo(size2));
// 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);
Assert.That(size2, Is.Not.EqualTo(size1));
Assert.That(size3, Is.Not.EqualTo(size1));
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.AreEqual(size1, size3);
Assert.AreEqual(size2, size3);
Assert.That(size2, Is.EqualTo(size1));
Assert.That(size3, Is.EqualTo(size1));
Assert.That(size3, Is.EqualTo(size2));
// 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);
Assert.That(size2, Is.Not.EqualTo(size1));
Assert.That(size3, Is.EqualTo(size1));
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.AreEqual(td1.a, td2.a);
Assert.AreEqual(td1.B, td2.B);
Assert.AreEqual(td1.size1, td2.size1);
Assert.AreEqual(td1.Size2, td2.Size2);
Assert.That(td2, Is.EqualTo(td1));
Assert.That(td2.a, Is.EqualTo(td1.a));
Assert.That(td2.B, Is.EqualTo(td1.B));
Assert.That(td2.size1, Is.EqualTo(td1.size1));
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.AreEqual(td1.a, td2.a);
Assert.AreEqual(td1.B, td2.B);
Assert.AreEqual(td1.size1, td2.size1);
Assert.AreEqual(td1.Size2, td2.Size2);
Assert.That(td2, Is.EqualTo(td1));
Assert.That(td2.a, Is.EqualTo(td1.a));
Assert.That(td2.B, Is.EqualTo(td1.B));
Assert.That(td2.size1, Is.EqualTo(td1.size1));
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.AreEqual(td1.a, td2.a);
Assert.AreEqual(td1.B, td2.B);
Assert.AreEqual(td1.size1, td2.size1);
Assert.AreEqual(td1.Size2, td2.Size2);
Assert.That(td2, Is.EqualTo(td1));
Assert.That(td2.a, Is.EqualTo(td1.a));
Assert.That(td2.B, Is.EqualTo(td1.B));
Assert.That(td2.size1, Is.EqualTo(td1.size1));
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.AreEqual(td1.a, td2.a);
Assert.AreEqual(td1.B, td2.B);
Assert.AreEqual(td1.size1, td2.size1);
Assert.AreEqual(td1.Size2, td2.Size2);
Assert.That(td2, Is.EqualTo(td1));
Assert.That(td2.a, Is.EqualTo(td1.a));
Assert.That(td2.B, Is.EqualTo(td1.B));
Assert.That(td2.size1, Is.EqualTo(td1.size1));
Assert.That(td2.Size2, Is.EqualTo(td1.Size2));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Generic/Regex_Tester.cs
+25 -28
View File
@@ -1,58 +1,55 @@
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Text.RegularExpressions;
using NUnit.Framework;
namespace Sacs.UnitTests.Net.Standard.Base.Generic
{
[TestClass]
[TestFixture]
public class Regex_Tester
{
//-------------------------------------------------------------------
// Data members.
// --- Tests ---
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.AreEqual(true, Regex.IsMatch("/home/data/logs/app", "[\\\\/]app$", RegexOptions.IgnoreCase));
Assert.That(Regex.IsMatch("D:\\Home\\Data\\Logs\\App", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(true));
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.AreEqual(false, Regex.IsMatch("/home/data/logs", "[\\\\/]app$", RegexOptions.IgnoreCase));
Assert.That(Regex.IsMatch("D:\\Home\\Data\\Logs", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(false));
Assert.That(Regex.IsMatch("/home/data/logs", "[\\\\/]app$", RegexOptions.IgnoreCase), Is.EqualTo(false));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void Regex_IsMatch()
{
string input = "abcdefghi";
Assert.AreEqual(true, Regex.IsMatch(input, "a"));
Assert.AreEqual(true, Regex.IsMatch(input, "^a"));
Assert.AreEqual(true, Regex.IsMatch(input, "d"));
Assert.AreEqual(true, Regex.IsMatch(input, "i$"));
Assert.That(Regex.IsMatch(input, "a"), Is.EqualTo(true));
Assert.That(Regex.IsMatch(input, "^a"), Is.EqualTo(true));
Assert.That(Regex.IsMatch(input, "d"), Is.EqualTo(true));
Assert.That(Regex.IsMatch(input, "i$"), Is.EqualTo(true));
// Combination characters.
Assert.AreEqual(true, Regex.IsMatch(input, "[adg]"));
Assert.AreEqual(true, Regex.IsMatch(input, "[cba]"));
Assert.That(Regex.IsMatch(input, "[adg]"), Is.EqualTo(true));
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.AreEqual(false, Regex.IsMatch(input, "^d"));
Assert.AreEqual(false, Regex.IsMatch(input, "d$"));
Assert.AreEqual(false, Regex.IsMatch(input, "^i"));
Assert.That(Regex.IsMatch(input, "a$"), Is.EqualTo(false));
Assert.That(Regex.IsMatch(input, "^d"), Is.EqualTo(false));
Assert.That(Regex.IsMatch(input, "d$"), Is.EqualTo(false));
Assert.That(Regex.IsMatch(input, "^i"), Is.EqualTo(false));
// Incorrect characters.
Assert.AreEqual(false, Regex.IsMatch(input, "j"));
Assert.AreEqual(false, Regex.IsMatch(input, " "));
Assert.That(Regex.IsMatch(input, "j"), Is.EqualTo(false));
Assert.That(Regex.IsMatch(input, " "), Is.EqualTo(false));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Helpers/SacsCsvHelper_Tester.cs
+36 -41
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsCsvHelper_Tester
{
//-------------------------------------------------------------------
// C o n v e r t F r o m C S V
//-------------------------------------------------------------------
[TestMethod]
// --- CSV Parsing ---
// --- Tests ---
[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.AreEqual(6, records[1].Length);
Assert.AreEqual(4, records[2].Length);
Assert.That(records[0].Length, Is.EqualTo(3));
Assert.That(records[1].Length, Is.EqualTo(6));
Assert.That(records[2].Length, Is.EqualTo(4));
// 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]);
Assert.That(records[0][1], Is.EqualTo("B"));
Assert.That(records[1][1], Is.EqualTo("E"));
Assert.That(records[1][3], Is.EqualTo("\"G\""));
Assert.That(records[1][5], Is.EqualTo("I,"));
Assert.That(records[2][1], Is.EqualTo("X"));
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
}
//-------------------------------------------------------------------
// C o n v e r t T o C S V
//-------------------------------------------------------------------
[TestMethod]
// --- CSV Formatting ---
[Test]
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" }));
Assert.That(SacsCsvHelper.ToCsv(new String[] { "A", "B", "C" }), Is.EqualTo("A,B,C"));
Assert.That(SacsCsvHelper.ToCsv(new Collection<String>() { "A", "B", "C" }), Is.EqualTo("A,B,C"));
Assert.That(SacsCsvHelper.ToCsv(new List<String>() { "A", "B", "C" }), Is.EqualTo("A,B,C"));
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.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.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"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.AreEqual("A,B,C", records[0]);
Assert.AreEqual("D,E,F,G,H,I", records[1]);
Assert.AreEqual("W,X,Y,Z", records[2]);
Assert.That(records.Count, Is.EqualTo(3));
Assert.That(records[0], Is.EqualTo("A,B,C"));
Assert.That(records[1], Is.EqualTo("D,E,F,G,H,I"));
Assert.That(records[2], Is.EqualTo("W,X,Y,Z"));
}
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/Helpers/SacsDataValidationHelper_Tester.cs
+64 -69
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class SacsDataValidationHelper_Tester
{
//-------------------------------------------------------------------
// Email addresses.
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
public void IsValidEmailAddress()
{
// Valid addresses.
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.com"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.xx"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.co.uk"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("jb@bloggs.co.uk"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs@bloggs.co.uk"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe-bloggs@bloggs.co.uk"));
Assert.IsTrue(SacsDataValidationHelper.IsValidEmailAddress("joe_bloggs@bloggs.co.uk"));
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.com"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.xx"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs.co.uk"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("jb@bloggs.co.uk"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs@bloggs.co.uk"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe-bloggs@bloggs.co.uk"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe_bloggs@bloggs.co.uk"), Is.True);
// Invalid addresses.
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(null));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(""));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress(" "));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe"));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs.com"));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs"));
Assert.IsFalse(SacsDataValidationHelper.IsValidEmailAddress("joe@blo ggs.com"));
Assert.That(SacsDataValidationHelper.IsValidEmailAddress(null), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress(""), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress(" "), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe.bloggs.com"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@bloggs"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidEmailAddress("joe@blo ggs.com"), Is.False);
}
//-------------------------------------------------------------------
// URLs.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void IsValidUrl()
{
// Valid addresses.
Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("http://joe.bloggs"));
Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("https://joe.bloggs"));
Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("//joe.bloggs"));
Assert.IsTrue(SacsDataValidationHelper.IsValidUrl("joe.bloggs"));
Assert.That(SacsDataValidationHelper.IsValidUrl("http://joe.bloggs"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidUrl("https://joe.bloggs"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidUrl("//joe.bloggs"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidUrl("joe.bloggs"), Is.True);
// Invalid addresses.
Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(null));
Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(""));
Assert.IsFalse(SacsDataValidationHelper.IsValidUrl(" "));
Assert.IsFalse(SacsDataValidationHelper.IsValidUrl("joe"));
Assert.IsFalse(SacsDataValidationHelper.IsValidUrl("joe@bloggs.com"));
Assert.That(SacsDataValidationHelper.IsValidUrl(null), Is.False);
Assert.That(SacsDataValidationHelper.IsValidUrl(""), Is.False);
Assert.That(SacsDataValidationHelper.IsValidUrl(" "), Is.False);
Assert.That(SacsDataValidationHelper.IsValidUrl("joe"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidUrl("joe@bloggs.com"), Is.False);
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void IsValidWikipediaUrl()
{
// Valid addresses.
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/wiki/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/wiki/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/wiki/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/w/index.php?etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/w/index.php?etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/w/index.php?etc"));
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/wiki/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/wiki/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/wiki/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("en.wikipedia.org/w/index.php?etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("//en.wikipedia.org/w/index.php?etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("https://en.wikipedia.org/w/index.php?etc"), Is.True);
// Invalid addresses.
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(null));
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(""));
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl(" "));
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/wiki/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/w/index.php"));
Assert.IsFalse(SacsDataValidationHelper.IsValidWikipediaUrl("htps://www.bbc.co.uk"));
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(null), Is.False);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(""), Is.False);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl(" "), Is.False);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/wiki/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("http://en.wikipedia.org/w/index.php"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidWikipediaUrl("htps://www.bbc.co.uk"), Is.False);
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void IsValidLinkedInUrl()
{
// Valid addresses.
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("www.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//www.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://www.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("en.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//en.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://en.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("xx.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("//xx.linkedin.com/in/etc"));
Assert.IsTrue(SacsDataValidationHelper.IsValidLinkedInUrl("https://xx.linkedin.com/in/etc"));
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("www.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//www.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://www.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("en.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//en.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://en.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("xx.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("//xx.linkedin.com/in/etc"), Is.True);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("https://xx.linkedin.com/in/etc"), Is.True);
// Invalid addresses.
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(null));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(""));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl(" "));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://www.linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("x.linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("xxx.linkedin.com/in/"));
Assert.IsFalse(SacsDataValidationHelper.IsValidLinkedInUrl("htps://www.bbc.co.uk"));
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(null), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(""), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl(" "), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://www.linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("http://xx.linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("x.linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("xxx.linkedin.com/in/"), Is.False);
Assert.That(SacsDataValidationHelper.IsValidLinkedInUrl("htps://www.bbc.co.uk"), Is.False);
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/Helpers/SacsRandomHelper_Tester.cs
+19 -23
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
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));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void GetInt32_ToExclusive()
{
for (int i = 1; i < 1000; i++)
{
int value = SacsRandomHelper.GetInt32(i);
Assert.IsTrue(value >= 0);
Assert.IsTrue(value < i);
Assert.That(value >= 0, Is.True);
Assert.That(value < i, Is.True);
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.IsTrue(value < j);
Assert.That(value >= i, Is.True);
Assert.That(value < j, Is.True);
}
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.IsTrue(value.Length < i + 1);
Assert.That(value.Length > 0, Is.True);
Assert.That(value.Length < i + 1, Is.True);
}
}
}
//-------------------------------------------------------------------
// --- The End ---
}
//=======================================================================
}
SacsCoreUnitTests/Standard/Base/Procs/SaProcess_Base_Tester.cs
+41 -43
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
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
}
}
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[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.IsTrue(process.IsAsync);
Assert.That(process.Started.Wait(1000), Is.True, "Process did not start.");
Assert.That(process.IsAsync, Is.True);
process.Release.Set();
await runTask;
Assert.IsFalse(process.IsAsync);
Assert.IsFalse(process.Processing);
Assert.IsTrue(process.ProcessEnded);
Assert.That(process.IsAsync, Is.False);
Assert.That(process.Processing, Is.False);
Assert.That(process.ProcessEnded, Is.True);
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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;
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.IsTrue(process.IsAsync, "A timed-out stop must retain the active process state.");
await Assert.ThrowsExactlyAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
Assert.That(await process.StopProcessAsync(40), Is.False);
Assert.That(process.IsAsync, Is.True, "A timed-out stop must retain the active process state.");
Assert.ThrowsAsync<SaProcess_Base.InProgressException>(() => process.RunAsync());
process.Release.Set();
await runTask;
Assert.IsFalse(process.IsAsync);
Assert.That(process.IsAsync, Is.False);
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.IsFalse(process.IsAsync);
Assert.IsTrue(await process.StopProcessAsync(20), "Stopping an idle process should succeed.");
Assert.That(process.CancellationObserved, Is.True);
Assert.That(process.IsAsync, Is.False);
Assert.That(await process.StopProcessAsync(20), Is.True, "Stopping an idle process should succeed.");
}
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.IsTrue(await stopTask);
Assert.That(completedTask, Is.SameAs(stopTask), "Cancellation callback deadlocked on the lifecycle lock.");
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
+69 -83
View File
@@ -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
{
//=======================================================================
[TestClass]
[TestFixture]
public class DateUtil_Tester
{
//-------------------------------------------------------------------
// Data members.
// --- Data Members ---
private Random random = new Random();
private DateTime today = DateTime.Today;
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
public void DateTime_CTR_Void ()
{
Assert.IsNotNull(new DateTime());
Assert.AreEqual(new DateTime(), DateTime.MinValue);
Assert.That(DateTime.MinValue, Is.EqualTo(new DateTime()));
}
//-------------------------------------------------------------------
// S e t T i m e
//-------------------------------------------------------------------
[TestMethod]
// --- Time Assignment ---
[Test]
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)));
Assert.That(DateUtil.FormatXmlDate(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlDate(date)));
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.AreEqual(DateUtil.FormatXmlTime(today + time), DateUtil.FormatXmlTime(date.SetTime(time)));
Assert.That(DateUtil.FormatXmlDate(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlDate(date)));
Assert.That(DateUtil.FormatXmlTime(date.SetTime(time)), Is.EqualTo(DateUtil.FormatXmlTime(today + time)));
}
}
//-------------------------------------------------------------------
// R o u n d T i m e
//-------------------------------------------------------------------
[TestMethod]
// --- Time Rounding ---
[Test]
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)));
}
}
}
//-------------------------------------------------------------------
// C o n v e r t F r o m S t r i n g
//-------------------------------------------------------------------
[TestMethod]
// --- Parsing ---
[Test]
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)));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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)));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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)));
}
//-------------------------------------------------------------------------
// V a l i d a t i o n
//-------------------------------------------------------------------------
[TestMethod]
// --- Validation ---
[Test]
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)));
Assert.That(DateUtil.IsValid(DateTime.Now), Is.EqualTo(true));
Assert.That(DateUtil.IsValid(DateTime.Today), Is.EqualTo(true));
Assert.That(DateUtil.IsValid(new DateTime(2018, 2, 12, 10, 32, 56)), Is.EqualTo(true));
// 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)));
Assert.That(DateUtil.IsValid(DateTime.MinValue), Is.EqualTo(false));
Assert.That(DateUtil.IsValid(DateTime.MaxValue), Is.EqualTo(false));
Assert.That(DateUtil.IsValid(new DateTime(0)), Is.EqualTo(false));
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()));
}
//-------------------------------------------------------------------
// F o r m a t t i n g
//-------------------------------------------------------------------
[TestMethod]
// --- Formatting ---
[Test]
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.AreEqual("23/07/2016 00:00:00", dt20160723.Format("dd/MM/yyyy HH:mm:ss"));
Assert.That(dt20160723.Format("dd/MM/yyyy"), Is.EqualTo("23/07/2016"));
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.AreEqual("23/07/2016 17:28:39", dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"));
Assert.That(dt20160723172829.Format("dd/MM/yyyy"), Is.EqualTo("23/07/2016"));
Assert.That(dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"), Is.EqualTo("23/07/2016 17:28:39"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
Assert.That(DateUtil.FormatXmlDate(dt20160723), Is.EqualTo("2016-07-23"));
Assert.That(DateUtil.FormatXmlDate(dt20160723172829), Is.EqualTo("2016-07-23"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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
+37 -41
View File
@@ -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
{
//-------------------------------------------------------------------
// Data members.
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
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));
Assert.That(EnumUtil.IsValid<SaMessageLevel>(0), Is.True);
Assert.That(EnumUtil.IsValid<SaMessageLevel>(1), Is.True);
Assert.That(EnumUtil.IsValid<SaMessageLevel>(2), Is.True);
Assert.That(EnumUtil.IsValid<SaMessageLevel>(3), Is.True);
Assert.That(EnumUtil.IsValid<SaMessageLevel>(4), Is.True);
Assert.That(EnumUtil.IsValid<SaMessageLevel>(5), Is.True);
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void EnumUtil_GetName ()
{
Assert.AreEqual("Info", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Info));
Assert.AreEqual("Debug", EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Debug));
Assert.That(EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Info), Is.EqualTo("Info"));
Assert.That(EnumUtil.GetName<SaMessageLevel>(SaMessageLevel.Debug), Is.EqualTo("Debug"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void EnumUtil_GetValues ()
{
Assert.AreEqual(9,EnumUtil.GetValues<SaMessageLevel>().ToList().Count);
Assert.AreEqual(SaMessageLevel.Info,EnumUtil.GetValues<SaMessageLevel>().ToArray()[6]);
Assert.That(EnumUtil.GetValues<SaMessageLevel>().ToList().Count, Is.EqualTo(9));
Assert.That(EnumUtil.GetValues<SaMessageLevel>().ToArray()[6], Is.EqualTo(SaMessageLevel.Info));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void EnumUtil_ParseEnum ()
{
Assert.AreEqual(SaMessageLevel.Info, EnumUtil.ParseEnum<SaMessageLevel>("Info"));
Assert.AreEqual(SaMessageLevel.Debug, EnumUtil.ParseEnum<SaMessageLevel>("Debug"));
Assert.That(EnumUtil.ParseEnum<SaMessageLevel>("Info"), Is.EqualTo(SaMessageLevel.Info));
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"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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(SaMessageLevel.Error, EnumUtil.StartsWith<SaMessageLevel>("Err", SaMessageLevel.Error));
Assert.AreEqual(SaMessageLevel.None, EnumUtil.StartsWith<SaMessageLevel>("", SaMessageLevel.Error));
Assert.AreEqual(SaMessageLevel.Error, EnumUtil.StartsWith<SaMessageLevel>("ABC", SaMessageLevel.Error));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("I", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("i", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("inf", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Info));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("D", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("d", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DE", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEB", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEBU", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("DEBUG", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Debug));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("Err", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Error));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.None));
Assert.That(EnumUtil.StartsWith<SaMessageLevel>("ABC", SaMessageLevel.Error), Is.EqualTo(SaMessageLevel.Error));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Utils/FtpUtil_Tester.cs
+43 -43
View File
@@ -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();
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
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"));
Assert.That(FtpUtil.CleansePath("abc"), Is.EqualTo("abc"));
Assert.That(FtpUtil.CleansePath("/abc"), Is.EqualTo("abc"));
Assert.That(FtpUtil.CleansePath("\\abc"), Is.EqualTo("abc"));
Assert.That(FtpUtil.CleansePath("/abc/"), Is.EqualTo("abc"));
Assert.That(FtpUtil.CleansePath("\\abc\\"), Is.EqualTo("abc"));
Assert.That(FtpUtil.CleansePath("abc/def"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("abc\\def"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("/abc/def"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("\\abc\\def"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("abc/def/"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("abc\\def\\"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("/abc/def/"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("\\abc\\def\\"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("/abc//def/"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("\\abc\\\\def\\"), Is.EqualTo("abc/def"));
Assert.That(FtpUtil.CleansePath("abc-def"), Is.EqualTo("abc-def"));
Assert.That(FtpUtil.CleansePath("abc.def"), Is.EqualTo("abc.def"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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"));
Assert.That(FtpUtil.GetParentFolder("abc"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("/abc"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("\\abc"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("/abc/"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("\\abc\\"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("abc/def"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("abc\\def"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("/abc/def"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("\\abc\\def"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("abc/def/"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("abc\\def\\"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("/abc/def/"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("\\abc\\def\\"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("/abc//def/"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("\\abc\\\\def\\"), Is.EqualTo("abc"));
Assert.That(FtpUtil.GetParentFolder("abc-def"), Is.Empty);
Assert.That(FtpUtil.GetParentFolder("abc.def"), Is.Empty);
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Utils/ImageUtils_Tester.cs
+38 -38
View File
@@ -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.AreEqual("PNG", pngConfig.ImageFormatName);
Assert.AreEqual("image/png", pngConfig.DefaultMimeType);
Assert.AreEqual(7, pngConfig.Width);
Assert.AreEqual(5, pngConfig.Height);
Assert.IsTrue(jpegConfig.ValidImage);
Assert.AreEqual("JPEG", jpegConfig.ImageFormatName);
Assert.AreEqual("image/jpeg", jpegConfig.DefaultMimeType);
Assert.AreEqual(9, jpegConfig.Width);
Assert.AreEqual(4, jpegConfig.Height);
Assert.That(pngConfig.ValidImage, Is.True);
Assert.That(pngConfig.ImageFormatName, Is.EqualTo("PNG"));
Assert.That(pngConfig.DefaultMimeType, Is.EqualTo("image/png"));
Assert.That(pngConfig.Width, Is.EqualTo(7));
Assert.That(pngConfig.Height, Is.EqualTo(5));
Assert.That(jpegConfig.ValidImage, Is.True);
Assert.That(jpegConfig.ImageFormatName, Is.EqualTo("JPEG"));
Assert.That(jpegConfig.DefaultMimeType, Is.EqualTo("image/jpeg"));
Assert.That(jpegConfig.Width, Is.EqualTo(9));
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.IsFalse(ImageUtils.VerifyImageData(Encoding.UTF8.GetBytes("not an image")).ValidImage);
Assert.IsFalse(ImageUtils.VerifyImageData(truncatedData).ValidImage);
Assert.That(ImageUtils.VerifyImageData(Array.Empty<byte>()).ValidImage, Is.False);
Assert.That(ImageUtils.VerifyImageData(Encoding.UTF8.GetBytes("not an image")).ValidImage, Is.False);
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.IsFalse(ImageUtils.IsSvg(missingNamespace));
Assert.IsFalse(ImageUtils.IsSvg(Encoding.UTF8.GetBytes("svg xmlns=\"http://www.w3.org/2000/svg\"")));
Assert.IsFalse(ImageUtils.IsSvg(null));
Assert.That(ImageUtils.IsSvg(svgData), Is.True);
Assert.That(ImageUtils.IsSvg(missingNamespace), Is.False);
Assert.That(ImageUtils.IsSvg(Encoding.UTF8.GetBytes("svg xmlns=\"http://www.w3.org/2000/svg\"")), Is.False);
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.IsTrue(encodedConfig.ValidImage);
Assert.AreEqual(8, encodedConfig.Width);
Assert.AreEqual(6, encodedConfig.Height);
Assert.That(format.Name, Is.EqualTo("PNG"));
Assert.That(encodedConfig.ValidImage, Is.True);
Assert.That(encodedConfig.Width, Is.EqualTo(8));
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.AreEqual(8, landscape.Width);
Assert.AreEqual(4, landscape.Height);
Assert.IsTrue(ImageUtils.ConstrainImage(portrait, 8, 8));
Assert.AreEqual(4, portrait.Width);
Assert.AreEqual(8, portrait.Height);
Assert.IsTrue(ImageUtils.ConstrainImage(withinLimits, 8, 8));
Assert.AreSame(originalData, withinLimits.ImageData);
Assert.IsFalse(ImageUtils.ConstrainImage(landscape, 0, 8));
Assert.IsFalse(ImageUtils.ConstrainImage(portrait, 8, 0));
Assert.That(ImageUtils.ConstrainImage(landscape, 8, 8), Is.True);
Assert.That(landscape.Width, Is.EqualTo(8));
Assert.That(landscape.Height, Is.EqualTo(4));
Assert.That(ImageUtils.ConstrainImage(portrait, 8, 8), Is.True);
Assert.That(portrait.Width, Is.EqualTo(4));
Assert.That(portrait.Height, Is.EqualTo(8));
Assert.That(ImageUtils.ConstrainImage(withinLimits, 8, 8), Is.True);
Assert.That(withinLimits.ImageData, Is.SameAs(originalData));
Assert.That(ImageUtils.ConstrainImage(landscape, 0, 8), Is.False);
Assert.That(ImageUtils.ConstrainImage(portrait, 8, 0), Is.False);
}
// --- Utilities ---
SacsCoreUnitTests/Standard/Base/Utils/ListUtil_Tester.cs
+17 -20
View File
@@ -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.AreEqual(true, values.IsEmpty());
Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(true));
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.AreEqual(false, values.IsEmpty());
Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(false));
Assert.That(values.IsEmpty(), Is.EqualTo(false));
values.Clear();
Assert.AreEqual(true, ListUtil.IsEmpty(values));
Assert.AreEqual(true, values.IsEmpty());
Assert.That(ListUtil.IsEmpty(values), Is.EqualTo(true));
Assert.That(values.IsEmpty(), Is.EqualTo(true));
}
//-------------------------------------------------------------------
// Randomise.
//-------------------------------------------------------------------
[TestMethod]
[Test]
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
+40 -38
View File
@@ -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.IsFalse(objectJson.Contains("Optional"));
Assert.AreEqual("[1,2,3]", arrayJson);
Assert.AreEqual("null", NewtonsoftJsonUtil.SerializeObject(null));
Assert.That(objectJson, Does.Contain("\"Name\":\"alpha\""));
Assert.That(objectJson.Contains("Optional"), Is.False);
Assert.That(arrayJson, Is.EqualTo("[1,2,3]"));
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.AreEqual("0", invalidJson);
Assert.AreEqual(42, validId.ToInt());
Assert.IsFalse(SysId.IsValid(invalidId));
Assert.IsFalse(SysId.IsValid(JsonConvert.DeserializeObject<SysId>("null")));
Assert.That(validJson, Is.EqualTo("42"));
Assert.That(invalidJson, Is.EqualTo("0"));
Assert.That(validId.ToInt(), Is.EqualTo(42));
Assert.That(SysId.IsValid(invalidId), Is.False);
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.AreEqual("alpha", jsonObject["name"].Value<string>());
Assert.IsTrue(jsonObject["nested"]["enabled"].Value<bool>());
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, jsonArray.ToObject<int[]>());
Assert.That(token.Value<int>(), Is.EqualTo(123));
Assert.That(jsonObject["name"].Value<string>(), Is.EqualTo("alpha"));
Assert.That(jsonObject["nested"]["enabled"].Value<bool>(), Is.True);
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.IsNotNull(tokenException);
Assert.IsNull(NewtonsoftJsonUtil.ParseJsonObject("[]", out Exception objectException));
Assert.IsNotNull(objectException);
Assert.IsNull(NewtonsoftJsonUtil.ParseJsonArray("{}", out Exception arrayException));
Assert.IsNotNull(arrayException);
Assert.ThrowsExactly<JsonReaderException>(() => NewtonsoftJsonUtil.ParseJsonToken("{"));
Assert.That(NewtonsoftJsonUtil.ParseJsonToken("{", out Exception tokenException), Is.Null);
Assert.That(tokenException, Is.Not.Null);
Assert.That(NewtonsoftJsonUtil.ParseJsonObject("[]", out Exception objectException), Is.Null);
Assert.That(objectException, Is.Not.Null);
Assert.That(NewtonsoftJsonUtil.ParseJsonArray("{}", out Exception arrayException), Is.Null);
Assert.That(arrayException, Is.Not.Null);
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.AreEqual(3, (int)data.count);
Assert.AreEqual("b", (string)data.items[1]);
Assert.IsNull(SacsJsonHelper.DeserializeJsonObject("null"));
Assert.That((string)data.name, Is.EqualTo("alpha"));
Assert.That((int)data.count, Is.EqualTo(3));
Assert.That((string)data.items[1], Is.EqualTo("b"));
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.AreNotSame(source.Values, copy.Values);
CollectionAssert.AreEqual(new[] { "one", "two" }, source.Values);
CollectionAssert.AreEqual(new[] { "one", "two", "copy only" }, copy.Values);
Assert.IsNull(SerializableUtil.DeepCopy<JsonData>(null));
Assert.AreEqual(String.Empty, SerializableUtil.ToJson<JsonData>(null));
Assert.That(copy, Is.Not.SameAs(source));
Assert.That(copy.Values, Is.Not.SameAs(source.Values));
Assert.That(source.Values, Is.EqualTo(new[] { "one", "two" }));
Assert.That(copy.Values, Is.EqualTo(new[] { "one", "two", "copy only" }));
Assert.That(SerializableUtil.DeepCopy<JsonData>(null), Is.Null);
Assert.That(SerializableUtil.ToJson<JsonData>(null), Is.Empty);
}
// --- The End ---
SacsCoreUnitTests/Standard/Base/Utils/SerializableUtil_Tester.cs
+19 -20
View File
@@ -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();
//-------------------------------------------------------------------
// Deep Copy.
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
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.AreEqual(data.stringValue, data_DeepCopy.stringValue);
Assert.AreEqual(data.longValue, data_DeepCopy.longValue);
Assert.That(data_DeepCopy is TestData, Is.EqualTo(true));
Assert.That(data_DeepCopy.stringValue, Is.EqualTo(data.stringValue));
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.AreEqual(true, dataA_DeepCopy is TestDataA);
Assert.AreEqual(dataA.stringValue, dataA_DeepCopy.stringValue);
Assert.AreEqual(dataA.longValue, dataA_DeepCopy.longValue);
Assert.AreNotEqual(data.stringValue, dataA_DeepCopy.stringValue);
Assert.AreNotEqual(data.longValue, dataA_DeepCopy.longValue);
Assert.That(dataA_DeepCopy is TestData, Is.EqualTo(true));
Assert.That(dataA_DeepCopy is TestDataA, Is.EqualTo(true));
Assert.That(dataA_DeepCopy.stringValue, Is.EqualTo(dataA.stringValue));
Assert.That(dataA_DeepCopy.longValue, Is.EqualTo(dataA.longValue));
Assert.That(dataA_DeepCopy.stringValue, Is.Not.EqualTo(data.stringValue));
Assert.That(dataA_DeepCopy.longValue, Is.Not.EqualTo(data.longValue));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Utils/StringListUtil_Tester.cs
+43 -44
View File
@@ -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.AreEqual("ABC,ABC,ABC", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(3));
Assert.That(values.Concat(","), Is.EqualTo("ABC,ABC,ABC"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.AreEqual("C,A,C,B,B,C", values.Concat(",").ToUpper());
Assert.That(values.Count, Is.EqualTo(6));
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.AreEqual("C,A,B", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(3));
Assert.That(values.Concat(","), Is.EqualTo("C,A,B"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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(","));
Assert.That(values.Count, Is.EqualTo(3));
Assert.That(values.Concat(","), Is.EqualTo("A,B,C"));
// Simple delimiter, null value.
values = StringListUtil.Split(null, ":");
Assert.AreEqual(0, values.Count);
Assert.AreEqual("", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(0));
Assert.That(values.Concat(","), Is.Empty);
// Simple delimiter, empty value.
values = StringListUtil.Split("", ":");
Assert.AreEqual(1, values.Count);
Assert.AreEqual("", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(1));
Assert.That(values.Concat(","), Is.Empty);
// Null delimiter.
values = StringListUtil.Split("A:B:C", null);
Assert.AreEqual(1, values.Count);
Assert.AreEqual("A:B:C", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(1));
Assert.That(values.Concat(","), Is.EqualTo("A:B:C"));
// Blank delimiter.
values = StringListUtil.Split("A:B:C", "");
Assert.AreEqual(1, values.Count);
Assert.AreEqual("A:B:C", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(1));
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.AreEqual("A,B,C", values.Concat(","));
Assert.That(values.Count, Is.EqualTo(3));
Assert.That(values.Concat(","), Is.EqualTo("A,B,C"));
}
//-------------------------------------------------------------------
[TestMethod]
[Test]
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.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));
Assert.That(values.Count, Is.EqualTo(7));
Assert.That(values.Concat(","), Is.EqualTo(",A,,B,,C,"));
Assert.That(values.Concat(",", "", "", false, false), Is.EqualTo(",A, ,B,,C, "));
Assert.That(values.Concat(",", "", "", true, false), Is.EqualTo(",A,,B,,C,"));
Assert.That(values.Concat(",", "", "", true, true), Is.EqualTo("A,B,C"));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Base/Utils/StringUtil_Tester.cs
+129 -129
View File
@@ -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.AreEqual(true, StringUtil.IsEmpty(""));
Assert.AreEqual(false, StringUtil.IsEmpty(" "));
Assert.AreEqual(false, StringUtil.IsEmpty("A"));
Assert.AreEqual(false, StringUtil.IsEmpty("Abc"));
Assert.AreEqual(true, "".IsEmpty());
Assert.AreEqual(false, "Abc".IsEmpty());
Assert.That(StringUtil.IsEmpty(null), Is.EqualTo(true));
Assert.That(StringUtil.IsEmpty(""), Is.EqualTo(true));
Assert.That(StringUtil.IsEmpty(" "), Is.EqualTo(false));
Assert.That(StringUtil.IsEmpty("A"), Is.EqualTo(false));
Assert.That(StringUtil.IsEmpty("Abc"), Is.EqualTo(false));
Assert.That("".IsEmpty(), Is.EqualTo(true));
Assert.That("Abc".IsEmpty(), Is.EqualTo(false));
}
[TestMethod]
[Test]
public void StringUtil_IsBlank()
{
// Leading spaces.
Assert.AreEqual(true, StringUtil.IsBlank(null));
Assert.AreEqual(true, StringUtil.IsBlank(""));
Assert.AreEqual(true, StringUtil.IsBlank(" "));
Assert.AreEqual(true, StringUtil.IsBlank(" "));
Assert.AreEqual(true, StringUtil.IsBlank(" \n\t "));
Assert.AreEqual(false, StringUtil.IsBlank("A"));
Assert.AreEqual(false, StringUtil.IsBlank("Abc"));
Assert.AreEqual(true, "".IsBlank());
Assert.AreEqual(true, " ".IsBlank());
Assert.AreEqual(false, "Abc".IsBlank());
Assert.That(StringUtil.IsBlank(null), Is.EqualTo(true));
Assert.That(StringUtil.IsBlank(""), Is.EqualTo(true));
Assert.That(StringUtil.IsBlank(" "), Is.EqualTo(true));
Assert.That(StringUtil.IsBlank(" "), Is.EqualTo(true));
Assert.That(StringUtil.IsBlank(" \n\t "), Is.EqualTo(true));
Assert.That(StringUtil.IsBlank("A"), Is.EqualTo(false));
Assert.That(StringUtil.IsBlank("Abc"), Is.EqualTo(false));
Assert.That("".IsBlank(), Is.EqualTo(true));
Assert.That(" ".IsBlank(), Is.EqualTo(true));
Assert.That("Abc".IsBlank(), Is.EqualTo(false));
}
// --- Regular Expression Matching ---
[TestMethod]
[Test]
public void StringUtil_IsMatch()
{
// IsMatch.
Assert.AreEqual(true, "ABCDEF".IsMatch("ABCDEF"));
Assert.AreEqual(true, "ABCDEF".IsMatch("^ABCDEF$"));
Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbCdEf"));
Assert.AreEqual(true, "ABCDEF".IsMatchCI("^AbCdEf$"));
Assert.AreEqual(true, "ABCDEF".IsMatch("^ABC"));
Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbC"));
Assert.AreEqual(true, "ABCDEF".IsMatch("CDE"));
Assert.AreEqual(true, "ABCDEF".IsMatchCI("cDe"));
Assert.AreEqual(true, "ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None));
Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)));
Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)));
Assert.That("ABCDEF".IsMatch("ABCDEF"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatch("^ABCDEF$"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatchCI("AbCdEf"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatchCI("^AbCdEf$"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatch("^ABC"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatchCI("AbC"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatch("CDE"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatchCI("cDe"), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None), Is.EqualTo(true));
Assert.That("ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)), Is.EqualTo(true));
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.AreEqual(true, "AB(CD)EF".IsMatch("(..)"));
Assert.AreEqual(true, "AB(CD)EF".IsMatch("\\(CD\\)"));
Assert.That("ABC\\sDEF".IsMatch("\\\\s"), Is.EqualTo(true));
Assert.That("AB(CD)EF".IsMatch("(..)"), Is.EqualTo(true));
Assert.That("AB(CD)EF".IsMatch("\\(CD\\)"), Is.EqualTo(true));
// Not match.
Assert.AreEqual(false, "ABCDEF".IsMatch("cDe"));
Assert.AreEqual(false, "ABCDEF".IsMatchCI("eFg"));
Assert.AreEqual(false, "ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None));
Assert.AreEqual(false, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)));
Assert.That("ABCDEF".IsMatch("cDe"), Is.EqualTo(false));
Assert.That("ABCDEF".IsMatchCI("eFg"), Is.EqualTo(false));
Assert.That("ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None), Is.EqualTo(false));
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.AreEqual("CDE", "ABCDEF".GetMatchCI("cDe"));
Assert.AreEqual("CDE", "ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value);
Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value);
Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Value);
Assert.That("ABCDEF".GetMatch("CDE"), Is.EqualTo("CDE"));
Assert.That("ABCDEF".GetMatchCI("cDe"), Is.EqualTo("CDE"));
Assert.That("ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value, Is.EqualTo("CDE"));
Assert.That("ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value, Is.EqualTo("CDE"));
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.AreEqual("\\s", "ABC\\sDEF".GetMatch("\\\\s"));
Assert.AreEqual("AB", "AB(CD)EF".GetMatch("(..)"));
Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(..\\)"));
Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(CD\\)"));
Assert.That("ABC DEF".GetMatch("\\s"), Is.EqualTo(" "));
Assert.That("ABC\\sDEF".GetMatch("\\\\s"), Is.EqualTo("\\s"));
Assert.That("AB(CD)EF".GetMatch("(..)"), Is.EqualTo("AB"));
Assert.That("AB(CD)EF".GetMatch("\\(..\\)"), Is.EqualTo("(CD)"));
Assert.That("AB(CD)EF".GetMatch("\\(CD\\)"), Is.EqualTo("(CD)"));
// Not match.
Assert.AreEqual(null, "ABCDEF".GetMatch("cDe"));
Assert.AreEqual(null, "ABCDEF".GetMatch("eFg"));
Assert.AreEqual("", "ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value);
Assert.AreEqual("", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Value);
Assert.That("ABCDEF".GetMatch("cDe"), Is.EqualTo(null));
Assert.That("ABCDEF".GetMatch("eFg"), Is.EqualTo(null));
Assert.That("ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value, Is.Empty);
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.AreEqual(1, "ABCDEF".GetMatchesCI("cDe").Count);
Assert.AreEqual(1, "ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count);
Assert.AreEqual(1, "ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count);
Assert.AreEqual(1, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Count);
Assert.That("ABCDEF".GetMatches("CDE").Count, Is.EqualTo(1));
Assert.That("ABCDEF".GetMatchesCI("cDe").Count, Is.EqualTo(1));
Assert.That("ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count, Is.EqualTo(1));
Assert.That("ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count, Is.EqualTo(1));
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.AreEqual(1, "ABC\\sDEF".GetMatchesCI("\\\\s").Count);
Assert.AreEqual(4, "AB(CD)EF".GetMatchesCI("(..)").Count);
Assert.AreEqual("D)", "AB(CD)EF".GetMatchesCI("(..)")[2]);
Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(..\\)").Count);
Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(CD\\)").Count);
Assert.That("ABC DEF".GetMatchesCI("\\s").Count, Is.EqualTo(1));
Assert.That("ABC\\sDEF".GetMatchesCI("\\\\s").Count, Is.EqualTo(1));
Assert.That("AB(CD)EF".GetMatchesCI("(..)").Count, Is.EqualTo(4));
Assert.That("AB(CD)EF".GetMatchesCI("(..)")[2], Is.EqualTo("D)"));
Assert.That("AB(CD)EF".GetMatchesCI("\\(..\\)").Count, Is.EqualTo(1));
Assert.That("AB(CD)EF".GetMatchesCI("\\(CD\\)").Count, Is.EqualTo(1));
// Not match.
Assert.AreEqual(0, "ABCDEF".GetMatches("cDe").Count);
Assert.AreEqual(0, "ABCDEF".GetMatches("eFg").Count);
Assert.AreEqual(0, "ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count);
Assert.AreEqual(0, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Count);
Assert.That("ABCDEF".GetMatches("cDe").Count, Is.EqualTo(0));
Assert.That("ABCDEF".GetMatches("eFg").Count, Is.EqualTo(0));
Assert.That("ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count, Is.EqualTo(0));
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.AreEqual(1, "ABCDEF".MatchesCount(new Regex("CDE")));
Assert.AreEqual(2, "ABCDEFGHICDEJKL".GetMatchCount("CDE"));
Assert.AreEqual(2, "ABCDEFGHICDEJKL".MatchesCount(new Regex("CDE")));
Assert.That("ABCDEF".GetMatchCount("CDE"), Is.EqualTo(1));
Assert.That("ABCDEF".MatchesCount(new Regex("CDE")), Is.EqualTo(1));
Assert.That("ABCDEFGHICDEJKL".GetMatchCount("CDE"), Is.EqualTo(2));
Assert.That("ABCDEFGHICDEJKL".MatchesCount(new Regex("CDE")), Is.EqualTo(2));
}
// --- Padding ---
[TestMethod]
[Test]
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, ' '));
Assert.That("".PadLeft(3, ' '), Is.EqualTo(" "));
Assert.That("A".PadLeft(3, ' '), Is.EqualTo(" A"));
Assert.That("AB".PadLeft(3, ' '), Is.EqualTo(" AB"));
Assert.That("ABC".PadLeft(3, ' '), Is.EqualTo("ABC"));
Assert.That("ABCD".PadLeft(3, ' '), Is.EqualTo("ABCD"));
// 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'));
Assert.That("".PadLeft(2, '0'), Is.EqualTo("00"));
Assert.That("1".PadLeft(2, '0'), Is.EqualTo("01"));
Assert.That("123".PadLeft(3, '0'), Is.EqualTo("123"));
Assert.That("123".PadLeft(4, '0'), Is.EqualTo("0123"));
Assert.That("123".PadLeft(5, '0'), Is.EqualTo("00123"));
}
[TestMethod]
[Test]
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, ' '));
Assert.That("".PadRight(3, ' '), Is.EqualTo(" "));
Assert.That("A".PadRight(3, ' '), Is.EqualTo("A "));
Assert.That("AB".PadRight(3, ' '), Is.EqualTo("AB "));
Assert.That("ABC".PadRight(3, ' '), Is.EqualTo("ABC"));
Assert.That("ABCD".PadRight(3, ' '), Is.EqualTo("ABCD"));
// 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'));
Assert.That("".PadRight(2, '0'), Is.EqualTo("00"));
Assert.That("1".PadRight(2, '0'), Is.EqualTo("10"));
Assert.That("12".PadRight(2, '0'), Is.EqualTo("12"));
Assert.That("123".PadRight(3, '0'), Is.EqualTo("123"));
Assert.That("123".PadRight(4, '0'), Is.EqualTo("1230"));
Assert.That("123".PadRight(5, '0'), Is.EqualTo("12300"));
}
// --- Safe Substrings ---
[TestMethod]
[Test]
public void StringUtil_SubstringSafe()
{
Assert.AreEqual("", StringUtil.SubstringSafe(null, 0));
Assert.AreEqual("", StringUtil.SubstringSafe("", 0));
Assert.AreEqual("", "".SubstringSafe(0));
Assert.That(StringUtil.SubstringSafe(null, 0), Is.Empty);
Assert.That(StringUtil.SubstringSafe("", 0), Is.Empty);
Assert.That("".SubstringSafe(0), Is.Empty);
// Right portion from start position.
Assert.AreEqual("abc", "abc".SubstringSafe(-3));
Assert.AreEqual("abc", "abc".SubstringSafe(-2));
Assert.AreEqual("abc", "abc".SubstringSafe(-1));
Assert.AreEqual("abc", "abc".SubstringSafe(0));
Assert.AreEqual("bc", "abc".SubstringSafe(1));
Assert.AreEqual("c", "abc".SubstringSafe(2));
Assert.AreEqual("", "abc".SubstringSafe(3));
Assert.That("abc".SubstringSafe(-3), Is.EqualTo("abc"));
Assert.That("abc".SubstringSafe(-2), Is.EqualTo("abc"));
Assert.That("abc".SubstringSafe(-1), Is.EqualTo("abc"));
Assert.That("abc".SubstringSafe(0), Is.EqualTo("abc"));
Assert.That("abc".SubstringSafe(1), Is.EqualTo("bc"));
Assert.That("abc".SubstringSafe(2), Is.EqualTo("c"));
Assert.That("abc".SubstringSafe(3), Is.Empty);
// 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));
Assert.That(StringUtil.SubstringSafe(null, 0, 0), Is.Empty);
Assert.That(StringUtil.SubstringSafe("", 0, 0), Is.Empty);
Assert.That("".SubstringSafe(0, 0), Is.Empty);
Assert.That("abc".SubstringSafe(-1, 0), Is.Empty);
Assert.That("abc".SubstringSafe(0, 0), Is.Empty);
Assert.That("abc".SubstringSafe(1, 0), Is.Empty);
Assert.That("abc".SubstringSafe(2, 0), Is.Empty);
Assert.That("abc".SubstringSafe(3, 0), Is.Empty);
Assert.That("abc".SubstringSafe(4, 0), Is.Empty);
// Mid portion.
Assert.AreEqual("abc", "abcde".SubstringSafe(0, 3));
Assert.AreEqual("bcd", "abcde".SubstringSafe(1, 3));
Assert.AreEqual("cde", "abcde".SubstringSafe(2, 3));
Assert.That("abcde".SubstringSafe(0, 3), Is.EqualTo("abc"));
Assert.That("abcde".SubstringSafe(1, 3), Is.EqualTo("bcd"));
Assert.That("abcde".SubstringSafe(2, 3), Is.EqualTo("cde"));
// Excessive length.
Assert.AreEqual("abcde", "abcde".SubstringSafe(-1, 12));
Assert.AreEqual("abcde", "abcde".SubstringSafe(0, 12));
Assert.AreEqual("bcde", "abcde".SubstringSafe(1, 12));
Assert.AreEqual("cde", "abcde".SubstringSafe(2, 12));
Assert.AreEqual("de", "abcde".SubstringSafe(3, 12));
Assert.AreEqual("e", "abcde".SubstringSafe(4, 12));
Assert.AreEqual("", "abcde".SubstringSafe(5, 12));
Assert.That("abcde".SubstringSafe(-1, 12), Is.EqualTo("abcde"));
Assert.That("abcde".SubstringSafe(0, 12), Is.EqualTo("abcde"));
Assert.That("abcde".SubstringSafe(1, 12), Is.EqualTo("bcde"));
Assert.That("abcde".SubstringSafe(2, 12), Is.EqualTo("cde"));
Assert.That("abcde".SubstringSafe(3, 12), Is.EqualTo("de"));
Assert.That("abcde".SubstringSafe(4, 12), Is.EqualTo("e"));
Assert.That("abcde".SubstringSafe(5, 12), Is.Empty);
}
// --- The End ---
}
SacsCoreUnitTests/Standard/Base/Utils/SysUtil_Tester.cs
+43 -52
View File
@@ -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.AreNotEqual("", SysUtil.GetCallerClassName());
Assert.AreEqual("SysUtil_Tester", SysUtil.GetCallerClassName());
Assert.That(SysUtil.GetCallerClassName(), Is.Not.EqualTo(null));
Assert.That(SysUtil.GetCallerClassName(), Is.Not.Empty);
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.AreEqual(ClassName_CompilerGeneratedClass, new Func<string>(() => SysUtil.GetCallerClassName())());
Assert.That(((Func<string>)(() => SysUtil.GetCallerClassName()))(), Is.EqualTo(ClassName_CompilerGeneratedClass));
Assert.That(new Func<string>(() => SysUtil.GetCallerClassName())(), Is.EqualTo(ClassName_CompilerGeneratedClass));
}
//-------------------------------------------------------------------
// Calling code function name.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void SysUtil_GetCallerMemberName_Test()
{
// Leading spaces.
Assert.AreNotEqual(null, SysUtil.GetCallerMemberName());
Assert.AreNotEqual("", SysUtil.GetCallerMemberName());
Assert.AreEqual("SysUtil_GetCallerMemberName_Test", SysUtil.GetCallerMemberName());
Assert.AreEqual(nameof(SysUtil_GetCallerMemberName_Test), SysUtil.GetCallerMemberName());
Assert.AreEqual(MethodBase.GetCurrentMethod().Name, SysUtil.GetCallerMemberName());
Assert.That(SysUtil.GetCallerMemberName(), Is.Not.EqualTo(null));
Assert.That(SysUtil.GetCallerMemberName(), Is.Not.Empty);
Assert.That(SysUtil.GetCallerMemberName(), Is.EqualTo("SysUtil_GetCallerMemberName_Test"));
Assert.That(SysUtil.GetCallerMemberName(), Is.EqualTo(nameof(SysUtil_GetCallerMemberName_Test)));
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.AreEqual(MethodBase.GetCurrentMethod().Name, new Func<string>(() => SysUtil.GetCallerMemberName())());
Assert.That(((Func<string>)(() => SysUtil.GetCallerMemberName()))(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
Assert.That(new Func<string>(() => SysUtil.GetCallerMemberName())(), Is.EqualTo(MethodBase.GetCurrentMethod().Name));
}
//-------------------------------------------------------------------
// Calling code file path.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void SysUtil_GetCallerFilePath_Test()
{
// Leading spaces.
Assert.AreNotEqual(null, SysUtil.GetCallerFilePath());
Assert.AreNotEqual("", SysUtil.GetCallerFilePath());
Assert.AreEqual(@"D:\Sarand\Projects\Users\AHoward\VS2022\Common-VS\Workspace\SacsCoreUnitTests\Standard\Base\Utils\SysUtil_Tester.cs", SysUtil.GetCallerFilePath());
Assert.AreEqual(true, SysUtil.GetCallerFilePath().EndsWith("SysUtil_Tester.cs"));
Assert.That(SysUtil.GetCallerFilePath(), Is.Not.EqualTo(null));
Assert.That(SysUtil.GetCallerFilePath(), Is.Not.Empty);
Assert.That(SysUtil.GetCallerFilePath(), Is.EqualTo(@"D:\Sarand\Projects\Users\AHoward\VS2022\Common-VS\Workspace\SacsCoreUnitTests\Standard\Base\Utils\SysUtil_Tester.cs"));
Assert.That(SysUtil.GetCallerFilePath().EndsWith("SysUtil_Tester.cs"), Is.EqualTo(true));
}
//-------------------------------------------------------------------
// Calling code line number.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void SysUtil_GetCallerLineNumber_Test()
{
// Leading spaces.
Assert.AreNotEqual(0, SysUtil.GetCallerLineNumber());
Assert.AreEqual((new StackFrame(0, true)).GetFileLineNumber(), SysUtil.GetCallerLineNumber());
Assert.That(SysUtil.GetCallerLineNumber(), Is.Not.EqualTo(0));
Assert.That(SysUtil.GetCallerLineNumber(), Is.EqualTo((new StackFrame(0, true)).GetFileLineNumber()));
}
//-------------------------------------------------------------------
// Calling code file path.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void SysUtil_GetCallerClassMethod_Test()
{
// Leading spaces.
Assert.AreNotEqual(null, SysUtil.GetCallerClassMethod());
Assert.AreNotEqual("", SysUtil.GetCallerClassMethod());
Assert.AreEqual(GetType().Name + "." + MethodBase.GetCurrentMethod().Name, SysUtil.GetCallerClassMethod());
Assert.AreEqual(nameof(SysUtil_Tester) + "." + nameof(SysUtil_GetCallerClassMethod_Test), SysUtil.GetCallerClassMethod());
Assert.That(SysUtil.GetCallerClassMethod(), Is.Not.EqualTo(null));
Assert.That(SysUtil.GetCallerClassMethod(), Is.Not.Empty);
Assert.That(SysUtil.GetCallerClassMethod(), Is.EqualTo(GetType().Name + "." + MethodBase.GetCurrentMethod().Name));
Assert.That(SysUtil.GetCallerClassMethod(), Is.EqualTo(nameof(SysUtil_Tester) + "." + nameof(SysUtil_GetCallerClassMethod_Test)));
}
//-------------------------------------------------------------------
// Calling code file path.
//-------------------------------------------------------------------
[TestMethod]
[Test]
public void SysUtil_Fn_Test()
{
// Leading spaces.
Assert.AreNotEqual(null, SysUtil.Fn);
Assert.AreNotEqual("", SysUtil.Fn);
Assert.AreEqual(GetType().Name + "." + MethodBase.GetCurrentMethod().Name, SysUtil.Fn);
Assert.AreEqual(nameof(SysUtil_Tester) + "." + nameof(SysUtil_Fn_Test), SysUtil.Fn);
Assert.That(SysUtil.Fn, Is.Not.EqualTo(null));
Assert.That(SysUtil.Fn, Is.Not.Empty);
Assert.That(SysUtil.Fn, Is.EqualTo(GetType().Name + "." + MethodBase.GetCurrentMethod().Name));
Assert.That(SysUtil.Fn, Is.EqualTo(nameof(SysUtil_Tester) + "." + nameof(SysUtil_Fn_Test)));
}
//-------------------------------------------------------------------
// --- The End ---
}
}
SacsCoreUnitTests/Standard/Proc/Excel/SaMsSpreadsheet_POI_Tester.cs
+81 -81
View File
@@ -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.IsTrue(spreadsheet.IsWorkbookValid());
Assert.IsTrue(spreadsheet.IsWorksheetValid());
Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
Assert.AreEqual("Sheet1", spreadsheet.WorksheetName);
Assert.That(spreadsheet.CreateWorkbook(), Is.True);
Assert.That(spreadsheet.IsWorkbookValid(), Is.True);
Assert.That(spreadsheet.IsWorksheetValid(), Is.True);
Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)1));
Assert.That(spreadsheet.WorksheetPos, Is.EqualTo((uint)1));
Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Sheet1"));
}
}
[TestMethod]
[Test]
public void CloseWorkbook_InvalidatesWorkbookAndWorksheet()
{
using (SaMsSpreadsheet_POI spreadsheet = CreateSpreadsheet())
{
Assert.IsTrue(spreadsheet.CloseWorkbook());
Assert.IsFalse(spreadsheet.IsWorkbookValid());
Assert.IsFalse(spreadsheet.IsWorksheetValid());
Assert.That(spreadsheet.CloseWorkbook(), Is.True);
Assert.That(spreadsheet.IsWorkbookValid(), Is.False);
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.AreEqual((uint)2, spreadsheet.WorksheetCount);
Assert.AreEqual("Secondary", spreadsheet.WorksheetName);
Assert.That(spreadsheet.AddWorksheet("Secondary"), Is.True);
Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)2));
Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Secondary"));
Assert.IsTrue(spreadsheet.OpenWorksheet(" primary "));
Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
Assert.AreEqual("Primary", spreadsheet.WorksheetName);
Assert.That(spreadsheet.OpenWorksheet(" primary "), Is.True);
Assert.That(spreadsheet.WorksheetPos, Is.EqualTo((uint)1));
Assert.That(spreadsheet.WorksheetName, Is.EqualTo("Primary"));
Assert.IsTrue(spreadsheet.RemoveWorksheet(2));
Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
Assert.That(spreadsheet.RemoveWorksheet(2), Is.True);
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.AreEqual((uint)3, spreadsheet.WorksheetCount);
Assert.That(spreadsheet.SetWorksheetCount(3), Is.True);
Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)3));
Assert.IsTrue(spreadsheet.SetWorksheetCount(1));
Assert.AreEqual((uint)1, spreadsheet.WorksheetCount);
Assert.AreEqual((uint)1, spreadsheet.WorksheetPos);
Assert.That(spreadsheet.SetWorksheetCount(1), Is.True);
Assert.That(spreadsheet.WorksheetCount, Is.EqualTo((uint)1));
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.IsTrue(spreadsheet.SetCellValue(1, 2, new DataValue("Text value"), null));
Assert.IsTrue(spreadsheet.SetCellValue(2, 2, new DataValue(42L), null));
Assert.IsTrue(spreadsheet.SetCellValue(3, 2, new DataValue(12.5), null));
Assert.IsTrue(spreadsheet.SetCellValue(4, 2, new DataValue(true), null));
Assert.IsTrue(spreadsheet.SetCellValue(5, 2, new DataValue(expectedDate), dateStyle));
Assert.IsTrue(spreadsheet.SetCellFormula(6, 2, "B2+C2", null));
Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Heading"), null), Is.True);
Assert.That(spreadsheet.SetCellValue(1, 2, new DataValue("Text value"), null), Is.True);
Assert.That(spreadsheet.SetCellValue(2, 2, new DataValue(42L), null), Is.True);
Assert.That(spreadsheet.SetCellValue(3, 2, new DataValue(12.5), null), Is.True);
Assert.That(spreadsheet.SetCellValue(4, 2, new DataValue(true), null), Is.True);
Assert.That(spreadsheet.SetCellValue(5, 2, new DataValue(expectedDate), dateStyle), Is.True);
Assert.That(spreadsheet.SetCellFormula(6, 2, "B2+C2", null), Is.True);
workbookData = spreadsheet.GetDocumentData();
}
Assert.IsNotNull(workbookData);
Assert.IsTrue(workbookData.Length > 0);
Assert.That(workbookData, Is.Not.Null);
Assert.That(workbookData.Length > 0, Is.True);
using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
{
Assert.IsTrue(spreadsheet.OpenWorkbook(workbookData));
Assert.IsTrue(spreadsheet.OpenWorksheet(1));
Assert.AreEqual("Text value", spreadsheet.GetCellText(1, 2));
Assert.AreEqual(42L, spreadsheet.GetCellValue(2, 2).AsLong());
Assert.AreEqual(12.5, spreadsheet.GetCellValue(3, 2).AsDouble(), 0.000001);
Assert.AreEqual("TRUE", spreadsheet.GetCellText(4, 2).ToUpperInvariant());
Assert.AreEqual(expectedDate, spreadsheet.GetCellValue(5, 2).AsDateTime());
Assert.AreEqual("B2+C2", spreadsheet.GetCellFormula(6, 2));
Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
Assert.That(spreadsheet.GetCellText(1, 2), Is.EqualTo("Text value"));
Assert.That(spreadsheet.GetCellValue(2, 2).AsLong(), Is.EqualTo(42L));
Assert.That(spreadsheet.GetCellValue(3, 2).AsDouble(), Is.EqualTo(12.5).Within(0.000001));
Assert.That(spreadsheet.GetCellText(4, 2).ToUpperInvariant(), Is.EqualTo("TRUE"));
Assert.That(spreadsheet.GetCellValue(5, 2).AsDateTime(), Is.EqualTo(expectedDate));
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.AreEqual("Text value", spreadsheet.GetCellValue(1, 1).AsString());
Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Text value"), null), Is.True);
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.IsTrue(spreadsheet.OpenWorksheet(1));
Assert.AreEqual("Stream value", spreadsheet.GetCellText(1, 1));
Assert.That(spreadsheet.OpenWorkbook(stream), Is.True);
Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
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.IsTrue(spreadsheet.OpenWorksheet("Legacy"));
Assert.AreEqual("Legacy value", spreadsheet.GetCellValue(1, 1).AsString());
Assert.AreEqual(17L, spreadsheet.GetCellValue(2, 1).AsLong());
Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
Assert.That(spreadsheet.OpenWorksheet("Legacy"), Is.True);
Assert.That(spreadsheet.GetCellValue(1, 1).AsString(), Is.EqualTo("Legacy value"));
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.IsTrue(reopened.OpenWorksheet("Legacy"));
Assert.AreEqual("Legacy value", reopened.GetCellValue(1, 1).AsString());
Assert.That(reopened.OpenWorkbook(roundTripData), Is.True);
Assert.That(reopened.OpenWorksheet("Legacy"), Is.True);
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.IsTrue(spreadsheet.SetRowHeight(3, 24, SaExcelLogicalUnit.Point));
Assert.That(spreadsheet.SetColWidth(2, 120, SaExcelLogicalUnit.Pixel), Is.True);
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.IsTrue(spreadsheet.OpenWorksheet(1));
Assert.AreEqual(expectedColWidth, spreadsheet.GetColWidth(2, SaExcelLogicalUnit.Pixel), 0.1);
Assert.AreEqual(expectedRowHeight, spreadsheet.GetRowHeight(3, SaExcelLogicalUnit.Point), 0.1);
Assert.AreEqual((uint)2, spreadsheet.ActiveColPos);
Assert.AreEqual((uint)3, spreadsheet.ActiveRowPos);
Assert.That(spreadsheet.OpenWorkbook(workbookData), Is.True);
Assert.That(spreadsheet.OpenWorksheet(1), Is.True);
Assert.That(spreadsheet.GetColWidth(2, SaExcelLogicalUnit.Pixel), Is.EqualTo(expectedColWidth).Within(0.1));
Assert.That(spreadsheet.GetRowHeight(3, SaExcelLogicalUnit.Point), Is.EqualTo(expectedRowHeight).Within(0.1));
Assert.That(spreadsheet.ActiveColPos, Is.EqualTo((uint)2));
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.IsTrue(spreadsheet.SaveDocument(workbookPath, (int)SaXlFileFormat.OpenXMLWorkbook, true));
Assert.That(spreadsheet.SetCellValue(1, 1, new DataValue("Saved value"), null), Is.True);
Assert.That(spreadsheet.SaveDocument(workbookPath, (int)SaXlFileFormat.OpenXMLWorkbook, true), Is.True);
}
Assert.IsTrue(File.Exists(workbookPath));
Assert.IsTrue(new FileInfo(workbookPath).Length > 0);
Assert.That(File.Exists(workbookPath), Is.True);
Assert.That(new FileInfo(workbookPath).Length > 0, Is.True);
using (SaMsSpreadsheet_POI spreadsheet = new SaMsSpreadsheet_POI())
{
Assert.IsTrue(spreadsheet.OpenWorkbook(workbookPath));
Assert.IsTrue(spreadsheet.OpenWorksheet("Saved"));
Assert.AreEqual("Saved value", spreadsheet.GetCellText(1, 1));
Assert.That(spreadsheet.OpenWorkbook(workbookPath), Is.True);
Assert.That(spreadsheet.OpenWorksheet("Saved"), Is.True);
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
+24 -25
View File
@@ -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();
//-------------------------------------------------------------------
// GetPosForColId.
//-------------------------------------------------------------------
[TestMethod]
// --- Tests ---
[Test]
public void GetPosForColId_IsEmpty()
{
Assert.AreEqual(1, SaMsSpreadsheet.GetPosForColId("A"));
Assert.AreEqual(1, SaMsSpreadsheet.GetPosForColId("a"));
Assert.AreEqual(2, SaMsSpreadsheet.GetPosForColId("B"));
Assert.AreEqual(3, SaMsSpreadsheet.GetPosForColId("C"));
Assert.AreEqual(24, SaMsSpreadsheet.GetPosForColId("X"));
Assert.AreEqual(25, SaMsSpreadsheet.GetPosForColId("Y"));
Assert.AreEqual(26, SaMsSpreadsheet.GetPosForColId("Z"));
Assert.AreEqual(27, SaMsSpreadsheet.GetPosForColId("AA"));
Assert.AreEqual(28, SaMsSpreadsheet.GetPosForColId("AB"));
Assert.AreEqual(29, SaMsSpreadsheet.GetPosForColId("AC"));
Assert.AreEqual(128, SaMsSpreadsheet.GetPosForColId("DX"));
Assert.AreEqual(155, SaMsSpreadsheet.GetPosForColId("EY"));
Assert.AreEqual(182, SaMsSpreadsheet.GetPosForColId("FZ"));
Assert.That(SaMsSpreadsheet.GetPosForColId("A"), Is.EqualTo(1));
Assert.That(SaMsSpreadsheet.GetPosForColId("a"), Is.EqualTo(1));
Assert.That(SaMsSpreadsheet.GetPosForColId("B"), Is.EqualTo(2));
Assert.That(SaMsSpreadsheet.GetPosForColId("C"), Is.EqualTo(3));
Assert.That(SaMsSpreadsheet.GetPosForColId("X"), Is.EqualTo(24));
Assert.That(SaMsSpreadsheet.GetPosForColId("Y"), Is.EqualTo(25));
Assert.That(SaMsSpreadsheet.GetPosForColId("Z"), Is.EqualTo(26));
Assert.That(SaMsSpreadsheet.GetPosForColId("AA"), Is.EqualTo(27));
Assert.That(SaMsSpreadsheet.GetPosForColId("AB"), Is.EqualTo(28));
Assert.That(SaMsSpreadsheet.GetPosForColId("AC"), Is.EqualTo(29));
Assert.That(SaMsSpreadsheet.GetPosForColId("DX"), Is.EqualTo(128));
Assert.That(SaMsSpreadsheet.GetPosForColId("EY"), Is.EqualTo(155));
Assert.That(SaMsSpreadsheet.GetPosForColId("FZ"), Is.EqualTo(182));
// Invalid.
Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId(""));
Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId("1"));
Assert.AreEqual(0, SaMsSpreadsheet.GetPosForColId("A1"));
Assert.That(SaMsSpreadsheet.GetPosForColId(""), Is.EqualTo(0));
Assert.That(SaMsSpreadsheet.GetPosForColId("1"), Is.EqualTo(0));
Assert.That(SaMsSpreadsheet.GetPosForColId("A1"), Is.EqualTo(0));
}
//-------------------------------------------------------------------
// --- The End ---
}
}