Added various extensions.

Added coding style helpers. Unit tests.
2026-07-24 03:56:27 +00:00 · 2021-04-01 12:38:26 +02:00
parent 66b766326b
commit 9a7125fbb0
24 changed files with 1111 additions and 43 deletions
@@ -0,0 +1,111 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Extensions.Tests
+{
+    [TestClass]
+    public class OptionalTests
+    {
+        [TestMethod]
+        public void SomeValueShouldEqualOptional()
+        {
+            var value = string.Empty;
+            var optional = value.ToOptional();
+
+            Assert.IsTrue(optional.Equals(value));
+        }
+
+        [TestMethod]
+        public void OptionalFromNullShouldNotEqual()
+        {
+            object value = null;
+            var optional = value.ToOptional();
+
+            Assert.IsFalse(optional.Equals(value));
+        }
+
+        [TestMethod]
+        public void OptionalFromValueShouldBeSome()
+        {
+            var optional = Optional.FromValue<object>(new object());
+
+            optional.DoAny(
+                onNone: () => throw new InvalidOperationException());
+        }
+
+        [TestMethod]
+        public void OptionalFromNullShouldBeNone()
+        {
+            var optional = Optional.FromValue<object>(null);
+
+            optional.DoAny(
+                onSome: _ => throw new InvalidOperationException());
+        }
+
+        [TestMethod]
+        public void DoShouldExecute()
+        {
+            var optional = Optional.FromValue(string.Empty);
+            var nullOptional = Optional.FromValue<string>(null);
+
+            optional.Do(
+                onSome: _ => { },
+                onNone: () => throw new InvalidOperationException());
+
+            nullOptional.Do(
+                onSome: _ => throw new InvalidOperationException(),
+                onNone: () => { });
+        }
+
+        [TestMethod]
+        public void DoAnyShouldExecute()
+        {
+            var optional = Optional.FromValue(string.Empty);
+            var nullOptional = Optional.FromValue<string>(null);
+
+            optional.DoAny(
+                onNone: () => throw new InvalidOperationException());
+
+            nullOptional.DoAny(
+                onSome: _ => throw new InvalidOperationException());
+        }
+
+        [TestMethod]
+        public void SwitchShouldExecute()
+        {
+            var optional = Optional.FromValue(string.Empty);
+            var nullOptional = Optional.FromValue<string>(null);
+
+            var newValue = optional.Switch(
+                onSome: _ => string.Empty,
+                onNone: () => throw new InvalidOperationException())
+                .ExtractValue();
+
+            var newNullValue = nullOptional.Switch<string>(
+                onSome: _ => throw new InvalidOperationException(),
+                onNone: () => null)
+                .ExtractValue();
+
+            newValue.Should().Be(string.Empty);
+            newNullValue.Should().Be(null);
+        }
+
+        [TestMethod]
+        public void SwitchAnyShouldExecute()
+        {
+            var optional = Optional.FromValue(string.Empty);
+            var nullOptional = Optional.FromValue<string>(null);
+
+            var newValue = optional.SwitchAny(
+                onSome: _ => string.Empty)
+                .ExtractValue();
+
+            var newNullValue = nullOptional.SwitchAny<string>(
+                onNone: () => null)
+                .ExtractValue();
+
+            newValue.Should().Be(string.Empty);
+            newNullValue.Should().Be(null);
+        }
+    }
+}
@@ -0,0 +1,117 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Extensions.Tests
+{
+    [TestClass]
+    public class ResultTests
+    {
+        [TestMethod]
+        public void SuccessResultShouldCreateFromSuccess()
+        {
+            var success = string.Empty;
+            var result = Result<string, object>.Success(success);
+
+            result.DoAny(
+                onFailure: () => throw new InvalidOperationException());
+        }
+
+        [TestMethod]
+        public void FailureResultShouldCreateFromFailure()
+        {
+            var failure = new object();
+            var result = Result<string, object>.Failure(failure);
+
+            result.DoAny(
+                onSuccess: () => throw new InvalidOperationException());
+        }
+
+        [TestMethod]
+        public void DoShouldExecute()
+        {
+            var success = string.Empty;
+            var successResult = Result<string, object>.Success(success);
+
+            var failure = new object();
+            var failedResult = Result<string, object>.Failure(failure);
+
+            successResult.Do(
+                onSuccess: _ => { },
+                onFailure: _ => throw new InvalidOperationException());
+
+            failedResult.Do(
+                onSuccess: _ => throw new InvalidOperationException(),
+                onFailure: _ => { });
+        }
+
+        [TestMethod]
+        public void DoAnyShouldExecute()
+        {
+            var success = string.Empty;
+            var successResult = Result<string, object>.Success(success);
+
+            var failure = new object();
+            var failedResult = Result<string, object>.Failure(failure);
+
+            successResult.DoAny(
+                onSuccess: _ => { });
+
+            failedResult.DoAny(
+                onFailure: _ => { });
+        }
+
+        [TestMethod]
+        public void SwitchShouldExecute()
+        {
+            var success = string.Empty;
+            var successResult = Result<string, object>.Success(success);
+
+            var failure = new object();
+            var failedResult = Result<string, object>.Failure(failure);
+
+            var successSwitch = successResult.Switch(
+                onSuccess: _ => string.Empty,
+                onFailure: _ => throw new InvalidOperationException());
+
+            var failedSwitch = failedResult.Switch(
+                onSuccess: _ => throw new InvalidOperationException(),
+                onFailure: _ => string.Empty);
+
+            success.Should().Be(failedSwitch);
+        }
+
+        [TestMethod]
+        public void SwitchAnyShouldExecute()
+        {
+            var success = string.Empty;
+            var successResult = Result<string, object>.Success(success);
+
+            var failure = new object();
+            var failedResult = Result<string, object>.Failure(failure);
+
+            var successSwitch = successResult.SwitchAny(
+                onSuccess: _ => string.Empty);
+
+            var failedSwitch = failedResult.SwitchAny(
+                onFailure: _ => string.Empty);
+
+            success.Should().Be(failedSwitch);
+        }
+
+        [TestMethod]
+        public void ToOptionalShouldConvert()
+        {
+            var success = string.Empty;
+            var successResult = Result<string, object>.Success(success);
+
+            var failure = new object();
+            var failedResult = Result<string, object>.Failure(failure);
+
+            var successOptional = successResult.ToOptional();
+            var failureOptional = failedResult.ToOptional();
+
+            successOptional.Should().NotBeNull();
+            failureOptional.Should().NotBeNull();
+        }
+    }
+}