Refactor tests

Divide tests for match expressions and statements into separate classes.
Also, upgrade dependencies.

Author: TolikPylypchuk

PatternMatching.Tests/MatchTests.cs …rnMatching.Tests/MatchExpressionTests.csPatternMatching.Tests/MatchTests.cs renamed to PatternMatching.Tests/MatchExpressionTests.cs PatternMatching.Tests/MatchTests.cs renamed to PatternMatching.Tests/MatchExpressionTests.cs

@@ -9,34 +9,22 @@
 
 namespace PatternMatching
 {
-    public class MatchTests
+    public class MatchExpressionTests
     {
         [Fact]
         public void MatchCreateShouldNeverReturnNull()
-        {
-            Match.Create<int, string>()
-                .Should()
-                .NotBeNull();
-
-            Match.Create<int>()
+            => Match.Create<int, string>()
                 .Should()
                 .NotBeNull();
-        }
 
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
         public void MatchCreateWithFallthroughShouldNeverReturnNull(bool fallthroughByDefault)
-        {
-            Match.Create<int, string>(fallthroughByDefault)
+            => Match.Create<int, string>(fallthroughByDefault)
                 .Should()
                 .NotBeNull();
 
-            Match.Create<int>(fallthroughByDefault)
-                .Should()
-                .NotBeNull();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property MatchExpressionShouldMatchPatternsCorrectly(Func<string, bool> predicate, string value)
         {
@@ -50,20 +38,6 @@ public Property MatchExpressionShouldMatchPatternsCorrectly(Func<string, bool> p
             return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property MatchStatementShouldMatchPatternsCorrectly(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-            bool matchSuccessful = false;
-
-            Match.Create<string>()
-                .Case(pattern, _ => matchSuccessful = true)
-                .Case(Pattern.Any<string>(), _ => matchSuccessful = false)
-                .ExecuteOn(value);
-
-            return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property NonStrictMatchExpressionShouldMatchPatternsCorrectly(Func<string, bool> predicate, string value)
         {
@@ -110,20 +84,6 @@ public Property NonStrictMatchExpressionShouldMatchPatternsCorrectlyWithNullable
             return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property StrictMatchStatementShouldMatchPatternsCorrectly(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-            bool matchSuccessful = false;
-
-            Match.Create<string>()
-                .Case(pattern, _ => matchSuccessful = true)
-                .Case(Pattern.Any<string>(), _ => matchSuccessful = false)
-                .ExecuteStrict(value);
-
-            return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property NonStrictMatchExpressionShouldReturnNothingIfNoMatchFound(Func<string, bool> predicate, string value)
         {
@@ -136,18 +96,6 @@ public Property NonStrictMatchExpressionShouldReturnNothingIfNoMatchFound(Func<s
             return (result.IsSome == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property MatchStatementShouldReturnFalseIfNoMatchFound(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            bool matched = Match.Create<string>()
-                .Case(pattern, _ => { })
-                .ExecuteOn(value);
-
-            return (matched == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void MatchExpressionShouldThrowIfNoMatchFound(Func<string, bool> predicate, string value)
         {
@@ -167,19 +115,6 @@ public void MatchExpressionShouldThrowIfNoMatchFound(Func<string, bool> predicat
             }
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void MatchStatementShouldNotThrowIfNoMatchFound(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, _ => { })
-                    .ExecuteOn(value);
-
-            action.Should().NotThrow<MatchException>();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void NonStrictMatchExpressionShouldNotThrowIfNoMatchFound(Func<string, bool> predicate, string value)
         {
@@ -193,25 +128,6 @@ public void NonStrictMatchExpressionShouldNotThrowIfNoMatchFound(Func<string, bo
             action.Should().NotThrow<MatchException>();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void StrictMatchStatementShouldThrowIfNoMatchFound(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, _ => { })
-                    .ExecuteStrict(value);
-
-            if (pattern.Match(value).IsSome)
-            {
-                action.Should().NotThrow<MatchException>();
-            } else
-            {
-                action.Should().Throw<MatchException>();
-            }
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property MatchExpressionToFunctionShouldMatchPatternsCorrectly(
             Func<string, bool> predicate,
@@ -227,22 +143,6 @@ public Property MatchExpressionToFunctionShouldMatchPatternsCorrectly(
             return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property MatchStatementToFunctionShouldMatchPatternsCorrectly(
-            Func<string, bool> predicate,
-            string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-            bool matchSuccessful = false;
-
-            Match.Create<string>()
-                .Case(pattern, _ => matchSuccessful = true)
-                .Case(Pattern.Any<string>(), _ => matchSuccessful = false)
-                .ToFunction()(value);
-
-            return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property NonStrictMatchExpressionToFunctionShouldMatchPatternsCorrectly(
             Func<string, bool> predicate,
@@ -291,22 +191,6 @@ public Property NonStrictMatchExpressionToFunctionShouldMatchPatternsCorrectlyWi
             return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property StrictMatchStatementToFunctionShouldMatchPatternsCorrectly(
-            Func<string, bool> predicate,
-            string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-            bool matchSuccessful = false;
-
-            Match.Create<string>()
-                .Case(pattern, _ => matchSuccessful = true)
-                .Case(Pattern.Any<string>(), _ => matchSuccessful = false)
-                .ToStrictFunction()(value);
-
-            return (matchSuccessful == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public Property NonStrictMatchExpressionToFunctionShouldReturnNothingIfNoMatchFound(
             Func<string, bool> predicate,
@@ -321,20 +205,6 @@ public Property NonStrictMatchExpressionToFunctionShouldReturnNothingIfNoMatchFo
             return (result.IsSome == pattern.Match(value).IsSome).ToProperty();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public Property MatchStatementToFunctionShouldReturnFalseIfNoMatchFound(
-            Func<string, bool> predicate,
-            string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            bool matched = Match.Create<string>()
-                .Case(pattern, _ => { })
-                .ToFunction()(value);
-
-            return (matched == pattern.Match(value).IsSome).ToProperty();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void MatchExpressionToFunctionShouldThrowIfNoMatchFound(Func<string, bool> predicate, string value)
         {
@@ -354,19 +224,6 @@ public void MatchExpressionToFunctionShouldThrowIfNoMatchFound(Func<string, bool
             }
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void MatchStatementToFunctionShouldNotThrowIfNoMatchFound(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, _ => { })
-                    .ToFunction()(value);
-
-            action.Should().NotThrow<MatchException>();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void NonStrictMatchExpressionToFunctionShouldNotThrowIfNoMatchFound(
             Func<string, bool> predicate,
@@ -382,25 +239,6 @@ public void NonStrictMatchExpressionToFunctionShouldNotThrowIfNoMatchFound(
             action.Should().NotThrow<MatchException>();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void StrictMatchStatementToFunctionShouldThrowIfNoMatchFound(Func<string, bool> predicate, string value)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, _ => { })
-                    .ToStrictFunction()(value);
-
-            if (pattern.Match(value).IsSome)
-            {
-                action.Should().NotThrow<MatchException>();
-            } else
-            {
-                action.Should().Throw<MatchException>();
-            }
-        }
-
         [Fact]
         public void MatchExpressionShouldThrowIfPatternIsNull()
         {
@@ -411,16 +249,6 @@ public void MatchExpressionShouldThrowIfPatternIsNull()
             action.Should().Throw<ArgumentNullException>();
         }
 
-        [Fact]
-        public void MatchStatementShouldThrowIfPatternIsNull()
-        {
-            Action action = () =>
-                Match.Create<string>()
-                    .Case<string>(null, _ => { });
-
-            action.Should().Throw<ArgumentNullException>();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void MatchExpressionShouldThrowIfCaseFunctionIsNull(Func<string, bool> predicate)
         {
@@ -433,18 +261,6 @@ public void MatchExpressionShouldThrowIfCaseFunctionIsNull(Func<string, bool> pr
             action.Should().Throw<ArgumentNullException>();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void MatchStatementShouldThrowIfCaseFunctionIsNull(Func<string, bool> predicate)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, null);
-
-            action.Should().Throw<ArgumentNullException>();
-        }
-
         [Fact]
         public void MatchExpressionShouldThrowIfCaseTypeFunctionIsNull()
         {
@@ -455,16 +271,6 @@ public void MatchExpressionShouldThrowIfCaseTypeFunctionIsNull()
             action.Should().Throw<ArgumentNullException>();
         }
 
-        [Fact]
-        public void MatchStatementShouldThrowIfCaseTypeFunctionIsNull()
-        {
-            Action action = () =>
-                Match.Create<string>()
-                    .Case<string>(null);
-
-            action.Should().Throw<ArgumentNullException>();
-        }
-
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
@@ -477,18 +283,6 @@ public void MatchExpressionShouldThrowIfPatternWithFallthroughIsNull(bool fallth
             action.Should().Throw<ArgumentNullException>();
         }
 
-        [Theory]
-        [InlineData(true)]
-        [InlineData(false)]
-        public void MatchStatementShouldThrowIfPatternWithFallthroughIsNull(bool fallthrough)
-        {
-            Action action = () =>
-                Match.Create<string>()
-                    .Case<string>(null, fallthrough, _ => { });
-
-            action.Should().Throw<ArgumentNullException>();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void MatchExpressionShouldThrowIfCaseFunctionWithFallthroughIsNull(
             Func<string, bool> predicate,
@@ -503,20 +297,6 @@ public void MatchExpressionShouldThrowIfCaseFunctionWithFallthroughIsNull(
             action.Should().Throw<ArgumentNullException>();
         }
 
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void MatchStatementShouldThrowIfCaseFunctionWithFallthroughIsNull(
-            Func<string, bool> predicate,
-            bool fallthrough)
-        {
-            var pattern = new SimplePattern<string>(predicate);
-
-            Action action = () =>
-                Match.Create<string>()
-                    .Case(pattern, fallthrough, null);
-
-            action.Should().Throw<ArgumentNullException>();
-        }
-
         [Property(Arbitrary = new[] { typeof(Generators) })]
         public void MatchExpressionShouldThrowIfCaseTypeFunctionWithFallthroughIsNull(bool fallthrough)
         {
@@ -526,15 +306,5 @@ public void MatchExpressionShouldThrowIfCaseTypeFunctionWithFallthroughIsNull(bo
 
             action.Should().Throw<ArgumentNullException>();
         }
-
-        [Property(Arbitrary = new[] { typeof(Generators) })]
-        public void MatchStatementShouldThrowIfCaseTypeFunctionWithFallthroughIsNull(bool fallthrough)
-        {
-            Action action = () =>
-                Match.Create<string>()
-                    .Case<string>(fallthrough, null);
-
-            action.Should().Throw<ArgumentNullException>();
-        }
     }
 }