v19.1.0 ⬩ Make more explicit null-safety in some Array[byte] extensions (Possibly breaking ABI) ⬩ Add some new unit tests ⬩ Upgrade nugets for testing dependencies

Author: monoman

Directory.Build.props

@@ -1,7 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Project>
     <PropertyGroup>
-        <Version>19.0.2</Version>
-        <PackageReleaseNotes>Renamed version.props to Directory.Build.props</PackageReleaseNotes>
+        <Version>19.1.0</Version>
+        <PackageReleaseNotes>
+            - Make more explicit null-safety in some Array[byte] extensions (Possibly breaking ABI)
+            - Add some new unit tests
+            - Upgrade nugets for testing dependencies
+        </PackageReleaseNotes>
     </PropertyGroup>
 </Project>

InterlockLedger.Commons.NUnit.Tests/InterlockLedger.Commons.NUnit.Tests.csproj

@@ -9,13 +9,13 @@
   <Target Name="TagSources" />
   <Target Name="NugetOrg" />
   <ItemGroup>
-    <PackageReference Include="NUnit" Version="4.3.2" />
-    <PackageReference Include="NUnit.Analyzers" Version="4.6.0">
+    <PackageReference Include="NUnit" Version="4.4.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.10.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="5.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\InterlockLedger.Commons\InterlockLedger.Commons.csproj" />

InterlockLedger.Commons.NUnit.Tests/System/ArrayOfByteExtensionsTests.cs

@@ -0,0 +1,139 @@
+// ******************************************************************************************************************************
+//
+// Copyright (c) 2018-2023 InterlockLedger Network
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES, LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ******************************************************************************************************************************
+
+namespace System;
+
+[TestFixture]
+public class ArrayOfByteExtensionsTests
+{
+    [Test]
+    public void Append() {
+        byte[] bytes = [1, 2, 3];
+        byte[] newBytes = [4, 5, 6];
+        byte[]? nullBytes = null;
+        byte[]? nullNewBytes = null;
+        byte[]? appended = bytes.Append(newBytes);
+        Assert.That(appended, Is.EqualTo(new byte[] { 1, 2, 3, 4, 5, 6 }));
+        appended = bytes.Append(nullNewBytes!);
+        Assert.That(appended, Is.EqualTo(bytes));
+        appended = nullBytes.Append(newBytes);
+        Assert.That(appended, Is.EqualTo(newBytes));
+        appended = nullBytes.Append(nullNewBytes);
+        Assert.That(appended, Is.Null);
+    }
+
+    [Test]
+    public void AsLiteral() {
+        byte[] bytes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        using (Assert.EnterMultipleScope()) {
+            Assert.That(bytes.AsLiteral(5), Is.EqualTo("new byte[] { 1, 2, 3, 4, 5 ...}"));
+            Assert.That(bytes.AsLiteral(), Is.EqualTo("new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }"));
+        }
+
+    }
+
+    [Test]
+    public void AsLong() {
+        byte[] bytes = [0, 0, 0, 0, 0, 0, 0, 1];
+        Assert.That(bytes.AsLong(), Is.EqualTo(1L));
+    }
+
+    [Test]
+    public void AsULong() {
+        byte[] bytes = [0, 0, 0, 0, 0, 0, 0, 1];
+        Assert.That(bytes.AsULong(), Is.EqualTo(1UL));
+    }
+
+    [Test]
+    public void AsUTF8String() {
+        byte[] bytes = "Test"u8.ToArray();
+        Assert.That(bytes.AsUTF8String(), Is.EqualTo("Test"));
+    }
+
+    [Test]
+    public void CompareTo() {
+        byte[] bytes1 = [1, 2, 3];
+        byte[] bytes2 = [1, 2, 4];
+        byte[] bytes3 = [1, 2, 3, 4];
+        using (Assert.EnterMultipleScope()) {
+            Assert.That(bytes1.CompareTo(bytes2), Is.EqualTo(-1));
+            Assert.That(bytes2.CompareTo(bytes1), Is.EqualTo(1));
+            Assert.That(bytes1.CompareTo(bytes1), Is.Zero);
+            Assert.That(bytes1.CompareTo(bytes3), Is.EqualTo(-1));
+            Assert.That(bytes3.CompareTo(bytes1), Is.EqualTo(1));
+        }
+
+    }
+
+    [Test]
+    public void FromSafeBase64() {
+        string base64 = "AQID";
+        byte[] bytes = base64.FromSafeBase64();
+        Assert.That(bytes, Is.EqualTo(new byte[] { 1, 2, 3 }));
+    }
+
+    [Test]
+    public void HasSameBytesAs() {
+        byte[] bytes1 = [1, 2, 3];
+        byte[] bytes2 = [1, 2, 3];
+        byte[] bytes3 = [1, 2, 4];
+        using (Assert.EnterMultipleScope()) {
+            Assert.That(bytes1.HasSameBytesAs(bytes2), Is.True);
+            Assert.That(bytes1.HasSameBytesAs(bytes3), Is.False);
+        }
+
+    }
+
+    [Test]
+    public void PartOf() {
+        byte[] bytes = [1, 2, 3, 4, 5];
+        byte[] part = bytes.PartOf(3, 1);
+        Assert.That(part, Is.EqualTo(new byte[] { 2, 3, 4 }));
+    }
+
+    [Test]
+    public void ToSafeBase64() {
+        byte[] bytes = [1, 2, 3];
+        string base64 = bytes.ToSafeBase64();
+        Assert.That(base64, Is.EqualTo("AQID"));
+    }
+
+    [Test]
+    public void SafeLength() {
+        byte[]? bytes = null;
+        Assert.That(bytes.SafeLength(), Is.Zero);
+        bytes = [];
+        Assert.That(bytes.SafeLength(), Is.Zero);
+        bytes = [1, 2, 3];
+        Assert.That(bytes.SafeLength(), Is.EqualTo(3));
+    }
+}

InterlockLedger.Commons.NUnit.Tests/System/IntegerExtensionsTests.cs

@@ -0,0 +1,51 @@
+// ******************************************************************************************************************************
+//
+// Copyright (c) 2018-2023 InterlockLedger Network
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES, LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ******************************************************************************************************************************
+
+namespace System;
+
+[TestFixture]
+public class IntegerExtensionsTests
+{
+    [Test]
+    public void In() {
+        Assert.That(1.In(1, 2, 3), Is.True);
+        Assert.That(4.In(1, 2, 3), Is.False);
+        Assert.That(1.In(), Is.False);
+    }
+
+    [Test]
+    public void ToBytes() {
+        byte[] bytes = 1.ToBytes();
+        byte[] expected = [0, 0, 0, 1];
+        Assert.That(bytes, Is.EqualTo(expected));
+    }
+}

InterlockLedger.Commons.NUnit.Tests/Types/System/ResultTests.cs

@@ -0,0 +1,135 @@
+// ******************************************************************************************************************************
+//
+// Copyright (c) 2018-2023 InterlockLedger Network
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES, LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// ******************************************************************************************************************************
+
+namespace System;
+
+[TestFixture]
+public class ResultTests
+{
+    [Test]
+    public void ResultOk()
+    {
+        var result = Result.Ok;
+        Assert.That(result.Success, Is.True);
+    }
+
+    [Test]
+    public void ResultFromException()
+    {
+        var exception = new Exception("Test Exception");
+        Result result = exception;
+        Assert.That(result.Success, Is.False);
+        Assert.That(result, Is.TypeOf<Error>());
+        var error = (Error)result;
+        Assert.That(error.ErrorMessage, Is.EqualTo("Test Exception"));
+        Assert.That(error.Exception, Is.EqualTo(exception));
+    }
+
+    [Test]
+    public void ResultBoolConversion()
+    {
+        bool success = Result.Ok;
+        Assert.That(success, Is.True);
+        Result error = new Exception();
+        success = error;
+        Assert.That(success, Is.False);
+    }
+
+    [Test]
+    public void ErrorFromException()
+    {
+        var exception = new Exception("Test Exception");
+        var error = new Error(exception);
+        Assert.That(error.Success, Is.False);
+        Assert.That(error.ErrorMessage, Is.EqualTo("Test Exception"));
+        Assert.That(error.Exception, Is.EqualTo(exception));
+        Assert.That(error.ErrorType, Is.EqualTo(IError.DefaultErrorType));
+    }
+
+    [Test]
+    public void ErrorFromString()
+    {
+        var error = new Error("Test Error");
+        Assert.That(error.Success, Is.False);
+        Assert.That(error.ErrorMessage, Is.EqualTo("Test Error"));
+        Assert.That(error.Exception, Is.Null);
+        Assert.That(error.ErrorType, Is.EqualTo(IError.DefaultErrorType));
+    }
+
+    [Test]
+    public void ResultOfTFromValue()
+    {
+        Result<int> result = 123;
+        Assert.That(result.Success, Is.True);
+        Assert.That(result.Value, Is.EqualTo(123));
+    }
+
+    [Test]
+    public void ResultOfTFromException()
+    {
+        var exception = new Exception("Test Exception");
+        Result<int> result = exception;
+        Assert.That(result.Success, Is.False);
+        Assert.Throws<InvalidOperationException>(() => { var _ = result.Value; });
+    }
+
+    [Test]
+    public void ResultOfTToT()
+    {
+        Result<int> result = 123;
+        int value = result;
+        Assert.That(value, Is.EqualTo(123));
+    }
+
+    [Test]
+    public void ErrorOfTFromException()
+    {
+        var exception = new Exception("Test Exception");
+        var error = new Error<int>(exception);
+        Assert.That(error.Success, Is.False);
+        Assert.That(error.ErrorMessage, Is.EqualTo("Test Exception"));
+        Assert.That(error.Exception, Is.EqualTo(exception));
+    }
+
+    [Test]
+    public void ResultExtensionsToConvertedResult()
+    {
+        Result<int> result = 123;
+        Result<string> convertedResult = result.ToConvertedResult(v => v.ToString());
+        Assert.That(convertedResult.Success, Is.True);
+        Assert.That(convertedResult.Value, Is.EqualTo("123"));
+
+        Result<int> errorResult = new Exception("Error");
+        convertedResult = errorResult.ToConvertedResult(v => v.ToString());
+        Assert.That(convertedResult.Success, Is.False);
+    }
+}