Add unit tests for provided types (covering additional/custom methods)

W4k.Either.sln

@@ -36,6 +36,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{CF4A053F-B
 		docs\notes.md = docs\notes.md
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "W4k.Either.UnitTests", "tests\W4k.Either.UnitTests\W4k.Either.UnitTests.csproj", "{43D36E15-6EF5-4E18-A28F-9D8155EE35A5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -62,6 +64,10 @@ Global
 		{8EFA14E0-FA66-4CA8-9E70-BC4D39B4C9D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8EFA14E0-FA66-4CA8-9E70-BC4D39B4C9D7}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8EFA14E0-FA66-4CA8-9E70-BC4D39B4C9D7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{43D36E15-6EF5-4E18-A28F-9D8155EE35A5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{43D36E15-6EF5-4E18-A28F-9D8155EE35A5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{43D36E15-6EF5-4E18-A28F-9D8155EE35A5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{43D36E15-6EF5-4E18-A28F-9D8155EE35A5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -75,5 +81,6 @@ Global
 		{3D54F6E0-5490-4E07-A300-AEB8816F5693} = {80323585-95E5-4B7A-980D-8E469628EF10}
 		{BD719D0A-7987-48EB-9EA0-B92C6F67B1D2} = {D0F3E3DE-EF0E-4E4A-96E5-2F5ACA88039D}
 		{8EFA14E0-FA66-4CA8-9E70-BC4D39B4C9D7} = {D0F3E3DE-EF0E-4E4A-96E5-2F5ACA88039D}
+		{43D36E15-6EF5-4E18-A28F-9D8155EE35A5} = {D0F3E3DE-EF0E-4E4A-96E5-2F5ACA88039D}
 	EndGlobalSection
 EndGlobal

tests/W4k.Either.UnitTests/EitherShould.cs

@@ -0,0 +1,18 @@
+namespace W4k.Either;
+
+public class EitherShould
+{
+    [Fact]
+    public void BeLeft()
+    {
+        Either<int, string> either = 42;
+        Assert.True(either.IsLeft);
+    }
+
+    [Fact]
+    public void BeRight()
+    {
+        Either<int, string> either = "foo";
+        Assert.True(either.IsRight);
+    }
+}

tests/W4k.Either.UnitTests/MaybeShould.cs

@@ -0,0 +1,22 @@
+namespace W4k.Either;
+
+public class MaybeShould
+{
+    [Fact]
+    public void BeCreatedWithSome()
+    {
+        var maybe = Maybe.Some(42);
+
+        Assert.True(maybe.HasValue);
+        Assert.Equal(42, maybe.Value);
+    }
+
+    [Fact]
+    public void BeCreatedWithNone()
+    {
+        var maybe = Maybe.None<int>();
+
+        Assert.False(maybe.HasValue);
+        Assert.Equal(default, maybe.Value);
+    }
+}

tests/W4k.Either.UnitTests/OptionalResultShould.cs

@@ -0,0 +1,87 @@
+namespace W4k.Either;
+
+public class OptionalResultShould
+{
+    [Fact]
+    public void CreateSuccessResultWithValue()
+    {
+        const string value = "le value";
+        var result = OptionalResult.Success<string, IError>(value);
+
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasValue);
+        Assert.False(result.IsFailed);
+
+        Assert.Equal(value, result.Value);
+        Assert.Throws<InvalidOperationException>(() => result.Error);
+    }
+
+    [Fact]
+    public void CreateSuccessResultWithoutValue()
+    {
+        var result = OptionalResult.Empty<string, IError>();
+
+        Assert.True(result.IsSuccess);
+        Assert.False(result.HasValue);
+        Assert.False(result.IsFailed);
+
+        Assert.Equal(default, result.Value);
+    }
+
+    [Fact]
+    public void CreateFailedResult()
+    {
+        var error = new TestError();
+        var result = OptionalResult.Failed<string, IError>(error);
+
+        Assert.False(result.IsSuccess);
+        Assert.False(result.HasValue);
+        Assert.True(result.IsFailed);
+
+        Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal(error, result.Error);
+    }
+
+    [Fact]
+    public void DeconstructSuccessResultWithValue()
+    {
+        var result = OptionalResult.Success<string, IError>("le success");
+
+        var (v, e) = result;
+
+        Assert.NotNull(v);
+        Assert.Null(e);
+    }
+
+    [Fact]
+    public void DeconstructSuccessResultWithoutValue()
+    {
+        var result = OptionalResult.Empty<string, IError>();
+
+        var (v, e) = result;
+
+        Assert.Null(v);
+        Assert.Null(e);
+    }    
+
+    [Fact]
+    public void DeconstructFailedResultWithValue()
+    {
+        var result = OptionalResult.Failed<string, IError>(new TestError());
+
+        var (v, e) = result;
+
+        Assert.Null(v);
+        Assert.NotNull(e);
+    }      
+
+    private interface IError
+    {
+        public string Message { get; }
+    }
+
+    private sealed class TestError : IError
+    {
+        public string Message => "le error";
+    }
+}

tests/W4k.Either.UnitTests/ResultShould.cs

@@ -0,0 +1,83 @@
+namespace W4k.Either;
+
+public class ResultShould
+{
+    [Fact]
+    public void CreateSuccessResultWithoutValue()
+    {
+        var result = Result.Success<IError>();
+
+        Assert.True(result.IsSuccess);
+        Assert.False(result.IsFailed);
+    }
+
+    [Fact]
+    public void CreateFailedResultWithoutValue()
+    {
+        var error = new TestError();
+        var result = Result.Failed<IError>(error);
+
+        Assert.False(result.IsSuccess);
+        Assert.True(result.IsFailed);
+
+        Assert.Equal(error, result.Error);
+    }
+
+    [Fact]
+    public void CreateSuccessResultWithValue()
+    {
+        const string value = "le success";
+        var result = Result.Success<string, IError>(value);
+
+        Assert.True(result.IsSuccess);
+        Assert.False(result.IsFailed);
+
+        Assert.Equal(value, result.Value);
+        Assert.Throws<InvalidOperationException>(() => result.Error);
+    }
+
+    [Fact]
+    public void CreateFailedResultWithValue()
+    {
+        var error = new TestError();
+        var result = Result.Failed<string, IError>(error);
+
+        Assert.False(result.IsSuccess);
+        Assert.True(result.IsFailed);
+
+        Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal(error, result.Error);
+    }
+
+    [Fact]
+    public void DeconstructSuccessResultWithValue()
+    {
+        var result = Result.Success<string, IError>("le success");
+
+        var (v, e) = result;
+
+        Assert.NotNull(v);
+        Assert.Null(e);
+    }
+
+    [Fact]
+    public void DeconstructFailedResultWithValue()
+    {
+        var result = Result.Failed<string, IError>(new TestError());
+
+        var (v, e) = result;
+
+        Assert.Null(v);
+        Assert.NotNull(e);
+    }    
+
+    private interface IError
+    {
+        public string Message { get; }
+    }
+
+    private sealed class TestError : IError
+    {
+        public string Message => "le error";
+    }
+}

tests/W4k.Either.UnitTests/Usings.cs

@@ -0,0 +1 @@
+global using Xunit;

tests/W4k.Either.UnitTests/W4k.Either.UnitTests.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <RootNamespace>W4k.Either</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\W4k.Either\W4k.Either.csproj" />
+  </ItemGroup>
+
+</Project>