Merge pull request #68 from pfpack/feature/Failure_FirstVersion

Add first version of Failure

src/core-taggeds-result-failure/Failure.Tests/Failure.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+		<IsPackable>false</IsPackable>
+		<Authors>Andrei Sergeev, Pavel Moskovoy</Authors>
+		<Description>PrimeFuncPack: A Functional Programming Pack for .NET</Description>
+		<Copyright>Copyright © 2020 Andrei Sergeev, Pavel Moskovoy</Copyright>
+		<RootNamespace>PrimeFuncPack.Core.Tests</RootNamespace>
+		<AssemblyName>PrimeFuncPack.Core.Failure.Tests</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="PrimeFuncPack.Core.Failure" Version="*-*" />
+    <PackageReference Include="PrimeFuncPack.UnitTest.Data" Version="2.0.*" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.*" />
+    <PackageReference Include="xunit" Version="2.*" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.*">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="1.*">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

src/core-taggeds-result-failure/Failure.Tests/Stubs/SomeFailureCode.cs

@@ -0,0 +1,12 @@
+#nullable enable
+
+namespace PrimeFuncPack.Core.Tests
+{
+    public enum SomeFailureCode
+    {
+        Unknown,
+        First,
+        Second,
+        Third
+    }
+}

src/core-taggeds-result-failure/Failure.Tests/Test.Failure/FailureTest.Equals.Equality.cs

@@ -0,0 +1,116 @@
+#nullable enable
+
+using System;
+using PrimeFuncPack.UnitTest;
+using Xunit;
+using static PrimeFuncPack.UnitTest.TestData;
+
+namespace PrimeFuncPack.Core.Tests
+{
+    partial class FailureTest
+    {
+        [Fact]
+        public void Equality_FailureAIsDefaultAndFailureBIsDefault_ExpectTrue()
+        {
+            var failureA = new Failure<StructType>();
+            var failureB = default(Failure<StructType>);
+
+            var actual = failureA == failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(EmptyString)]
+        public void Equality_FailureAIsDefaultAndFailureBCodeIsDefaultAndFailueBMessageIsNullOrEmpty_ExpectTrue(
+            string? failureMessage)
+        {
+            var failureA = new Failure<double>();
+            var failureB = new Failure<double>(default, failureMessage);
+
+            var actual = failureA == failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(EmptyString)]
+        public void Equality_FailureACodeIsDefaultAndFailueAMessageIsNullOrEmptyAndFailureBIsDefault_ExpectTrue(
+            string? failureMessage)
+        {
+            var failureA = new Failure<byte>(default, failureMessage);
+            var failureB = new Failure<byte>();
+
+            var actual = failureA == failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(Zero, null, null)]
+        [InlineData(Zero, EmptyString, null)]
+        [InlineData(Zero, null, EmptyString)]
+        [InlineData(Zero, EmptyString, EmptyString)]
+        [InlineData(byte.MinValue, UpperSomeString, UpperSomeString)]
+        [InlineData(byte.MaxValue, SomeString, SomeString)]
+        public void Equality_FailureACodeIsSameAsFailureBCodeIsDefaultAndFailueAMessagesAreNullOrEmpty_ExpectTrue(
+            byte failueCode,
+            string? failureAMessage,
+            string? failureBMessage)
+        {
+            var failureA = new Failure<byte>(failueCode, failureAMessage);
+            var failureB = new Failure<byte>(failueCode, failureBMessage);
+
+            var actual = failureA == failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(SomeFailureCode.Third, null)]
+        [InlineData(SomeFailureCode.Unknown, WhiteSpaceString)]
+        [InlineData(SomeFailureCode.Unknown, TabString)]
+        [InlineData(SomeFailureCode.Unknown, LowerSomeString)]
+        public void Equality_FailureAIsDefaultAndFailureBCodeIsNotDefaultOrFailueBMessageIsNotEmpty_ExpectFalse(
+            SomeFailureCode failureBCode,
+            string? failureBMessage)
+        {
+            var failureA = new Failure<SomeFailureCode>();
+            var failureB = new Failure<SomeFailureCode>(failureBCode, failureBMessage);
+
+            var actual = failureA == failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(SomeFailureCode.Second, null)]
+        [InlineData(SomeFailureCode.Unknown, WhiteSpaceString)]
+        [InlineData(SomeFailureCode.Unknown, TabString)]
+        public void Equality_FailureACodeIsNotDefaultOrFailueAMessageIsNotEmptyAndFailureBIsDefault_ExpectFalse(
+            SomeFailureCode failureACode,
+            string? failureAMessage)
+        {
+            var failureA = new Failure<SomeFailureCode>(failureACode, failureAMessage);
+            var failureB = default(Failure<SomeFailureCode>);
+
+            var actual = failureA == failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(Zero, null, Zero, WhiteSpaceString)]
+        [InlineData(Zero, EmptyString, Zero, TabString)]
+        [InlineData(Zero, LowerSomeString, Zero, SomeString)]
+        [InlineData(PlusFifteen, WhiteSpaceString, PlusFifteen, TabString)]
+        [InlineData(Zero, SomeString, int.MaxValue, SomeString)]
+        [InlineData(int.MinValue, UpperSomeString, MinusFifteen, UpperSomeString)]
+        public void Equality_FailureACodeIsNotEqualFailureBCodeAndFailureAMessageIsNotEqualFailureBMessage_ExpectFalse(
+            int failureACode, string? failureAMessage,
+            int failureBCode, string? failureBMessage)
+        {
+            var failureA = new Failure<int>(failureACode, failureAMessage);
+            var failureB = new Failure<int>(failureBCode, failureBMessage);
+
+            var actual = failureA == failureB;
+            Assert.False(actual);
+        }
+    }
+}

src/core-taggeds-result-failure/Failure.Tests/Test.Failure/FailureTest.Equals.Inequality.cs

@@ -0,0 +1,118 @@
+#nullable enable
+
+using System;
+using PrimeFuncPack.UnitTest;
+using Xunit;
+using static PrimeFuncPack.UnitTest.TestData;
+
+namespace PrimeFuncPack.Core.Tests
+{
+    partial class FailureTest
+    {
+        [Fact]
+        public void Inequality_FailureAIsDefaultAndFailureBIsDefault_ExpectFalse()
+        {
+            var failureA = default(Failure<int>);
+            var failureB = new Failure<int>();
+
+            var actual = failureA != failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(EmptyString)]
+        public void Inequality_FailureAIsDefaultAndFailureBCodeIsDefaultAndFailueBMessageIsNullOrEmpty_ExpectFalse(
+            string? failureMessage)
+        {
+            var failureA = new Failure<StructType>();
+            var failureB = new Failure<StructType>(default, failureMessage);
+
+            var actual = failureA != failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(EmptyString)]
+        public void Inequality_FailureACodeIsDefaultAndFailueAMessageIsNullOrEmptyAndFailureBIsDefault_ExpectFalse(
+            string? failureMessage)
+        {
+            var failureA = new Failure<decimal>(default, failureMessage);
+            var failureB = new Failure<decimal>();
+
+            var actual = failureA != failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(SomeFailureCode.Unknown, null, null)]
+        [InlineData(SomeFailureCode.Unknown, EmptyString, null)]
+        [InlineData(SomeFailureCode.Unknown, null, EmptyString)]
+        [InlineData(SomeFailureCode.Unknown, EmptyString, EmptyString)]
+        [InlineData(SomeFailureCode.First, UpperSomeString, UpperSomeString)]
+        [InlineData(SomeFailureCode.Third, SomeString, SomeString)]
+        public void Inequality_FailureACodeIsSameAsFailureBCodeIsDefaultAndFailueAMessagesAreNullOrEmpty_ExpectFalse(
+            SomeFailureCode failueCode,
+            string? failureAMessage,
+            string? failureBMessage)
+        {
+            var failureA = new Failure<SomeFailureCode>(failueCode, failureAMessage);
+            var failureB = new Failure<SomeFailureCode>(failueCode, failureBMessage);
+
+            var actual = failureA != failureB;
+            Assert.False(actual);
+        }
+
+        [Theory]
+        [InlineData(PlusFifteen, null)]
+        [InlineData(Zero, WhiteSpaceString)]
+        [InlineData(Zero, TabString)]
+        [InlineData(Zero, LowerSomeString)]
+        public void Inequality_FailureAIsDefaultAndFailureBCodeIsNotDefaultOrFailueBMessageIsNotEmpty_ExpectTrue(
+            int failureBCode,
+            string? failureBMessage)
+        {
+            var failureA = new Failure<int>();
+            var failureB = new Failure<int>(failureBCode, failureBMessage);
+
+            var actual = failureA != failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(long.MinValue, null)]
+        [InlineData(Zero, WhiteSpaceString)]
+        [InlineData(Zero, TabString)]
+        [InlineData(Zero, SomeString)]
+        [InlineData(long.MinValue, LowerSomeString)]
+        public void Inequality_FailureACodeIsNotDefaultOrFailueAMessageIsNotEmptyAndFailureBIsDefault_ExpectTrue(
+            long failureACode,
+            string? failureAMessage)
+        {
+            var failureA = new Failure<long>(failureACode, failureAMessage);
+            var failureB = new Failure<long>();
+
+            var actual = failureA != failureB;
+            Assert.True(actual);
+        }
+
+        [Theory]
+        [InlineData(SomeFailureCode.Unknown, null, SomeFailureCode.Unknown, WhiteSpaceString)]
+        [InlineData(SomeFailureCode.Unknown, EmptyString, SomeFailureCode.Unknown, TabString)]
+        [InlineData(SomeFailureCode.Unknown, LowerSomeString, SomeFailureCode.Unknown, SomeString)]
+        [InlineData(SomeFailureCode.First, WhiteSpaceString, SomeFailureCode.First, TabString)]
+        [InlineData(SomeFailureCode.Unknown, SomeString, SomeFailureCode.Second, SomeString)]
+        [InlineData(SomeFailureCode.Third, UpperSomeString, SomeFailureCode.First, UpperSomeString)]
+        public void Inequality_FailureACodeIsNotEqualFailureBCodeAndFailureAMessageIsNotEqualFailureBMessage_ExpectTrue(
+            SomeFailureCode failureACode, string? failureAMessage,
+            SomeFailureCode failureBCode, string? failureBMessage)
+        {
+            var failureA = new Failure<SomeFailureCode>(failureACode, failureAMessage);
+            var failureB = new Failure<SomeFailureCode>(failureBCode, failureBMessage);
+
+            var actual = failureA != failureB;
+            Assert.True(actual);
+        }
+    }
+}