From e138b5cc72e7b7e05d7d14497e093802d1265112 Mon Sep 17 00:00:00 2001
From: Artur Lavrov <arturstylus@gmail.com>
Date: Sat, 27 Feb 2021 14:50:26 +0200
Subject: [PATCH] start working on #23 added overload with custom contract
 violation message

---
 .../Precondition/RequireTest.cs               | 10 +++
 .../Precondition/Require/That.cs              | 89 +++++++++++++++++--
 2 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/src/DeclarativeContracts.Tests/Precondition/RequireTest.cs b/src/DeclarativeContracts.Tests/Precondition/RequireTest.cs
index 538128d..b00f3ee 100644
--- a/src/DeclarativeContracts.Tests/Precondition/RequireTest.cs
+++ b/src/DeclarativeContracts.Tests/Precondition/RequireTest.cs
@@ -189,6 +189,16 @@ public void That_FuncThatReturnsFalse_ContractViolationExceptionWasThrown()
 
             Assert.Throws(typeof(ContractViolationException), () => Require.That(functor));
         }
+        
+        [Test]
+        public void That_FuncThatReturnsFalse_ContractViolationExceptionWasThrownWithCustomUserDefinedMessage()
+        {
+            Func<bool> functor = () => false;
+
+            string contractViolationCustomMessage = "functor return false";
+
+            Assert.Throws(typeof(ContractViolationException), () => Require.That(functor, contractViolationCustomMessage), contractViolationCustomMessage);
+        }
 
         [Test]
         public void That_FuncIsNull_ArgumentExceptionWasThrown()
diff --git a/src/DeclarativeContracts/Precondition/Require/That.cs b/src/DeclarativeContracts/Precondition/Require/That.cs
index 603ce96..35d1788 100644
--- a/src/DeclarativeContracts/Precondition/Require/That.cs
+++ b/src/DeclarativeContracts/Precondition/Require/That.cs
@@ -27,6 +27,25 @@ public static void That<TEntity, TMember>(TEntity entity, Func<TEntity, TMember>
             InternalThat(member, predicate);
         }
 
+        /// <summary>
+        /// Method that verify that entity member satisfy passed predicate
+        /// </summary>
+        /// <param name="entity">Entity that contains verifiable member</param>
+        /// <param name="entityMemberSelector">Func that returns entity member that needs to be checked</param>
+        /// <param name="predicate">Predicate that check is entity member satisfy a condition</param>
+        /// <param name="contractViolationMsg">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TEntity">Entity type</typeparam>
+        /// <typeparam name="TMember">Entity member type</typeparam>
+        /// <throws>Throws ContractViolationException if element does not satisfy predicate</throws>
+        /// <throws>Throws ArgumentException if entityMemberSelector or predicate is null</throws>
+        public static void That<TEntity, TMember>(TEntity entity, Func<TEntity, TMember> entityMemberSelector, Predicate<TMember> predicate, string contractViolationMsg)
+        {
+            ArgumentChecker.CheckArgumentsNull(entityMemberSelector, predicate);
+            
+            var member = entityMemberSelector(entity);
+            InternalThat(member, predicate, contractViolationMsg);
+        }
+        
         /// <summary>
         /// Method that verify that entity member satisfy passed predicate
         /// </summary>
@@ -42,6 +61,22 @@ public static void That<TElement>(TElement element, Predicate<TElement> predicat
             InternalThat(element, predicate);
         }
 
+        /// <summary>
+        /// Method that verify that entity member satisfy passed predicate
+        /// </summary>
+        /// <param name="element">Element that needs to be checked</param>
+        /// <param name="predicate">Predicated that checks member</param>
+        /// <param name="contractViolationMsg">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TElement">Element type</typeparam>
+        /// <throws>Throws ContractViolationException if element does not satisfy predicate</throws>
+        /// <throws>Throws ArgumentException if predicate is null</throws>
+        public static void That<TElement>(TElement element, Predicate<TElement> predicate, string contractViolationMsg)
+        {
+            ArgumentChecker.CheckArgumentsNull(predicate);
+
+            InternalThat(element, predicate, contractViolationMsg);
+        }
+        
         /// <summary>
         /// Method that verify that entity member satisfy passed predicate
         /// </summary>
@@ -58,7 +93,7 @@ public static void That<TElement, TException>(TElement element, Predicate<TEleme
             
             InternalThat(element, predicate, exceptionToThrow);
         }
-        
+
         /// <summary>
         /// Method that verify that execute predicate returns true
         /// </summary>
@@ -84,6 +119,32 @@ public static void That(Func<bool> predicate)
             }	
          }
 
+        /// <summary>
+        /// Method that verify that execute predicate returns true
+        /// </summary>
+        /// <param name="predicate">Predicate that should return true</param>
+        /// <param name="contractViolationMsg"></param>
+        /// <throws>Throws ContractViolationException if element does not satisfy predicate</throws>
+        /// <throws>Throws ArgumentException if predicate is null</throws>
+        public static void That(Func<bool> predicate, string contractViolationMsg)	
+        {	
+            ArgumentChecker.CheckArgumentsNull(predicate);
+
+            try	
+            { 	
+                var result = predicate.Invoke();	
+                if(!result){
+                    throw new ContractViolationException(contractViolationMsg);
+                }
+            }	
+            catch (Exception exception)	
+            {	
+                throw new ContractViolationException(	
+                    contractViolationMsg,	
+                    innerException: exception);	
+            }	
+        }
+        
         private static void InternalThat<TMember>(TMember member, Predicate<TMember> predicate, Exception exceptionToThrow = null)
         {
             bool predicateResult;
@@ -95,15 +156,33 @@ private static void InternalThat<TMember>(TMember member, Predicate<TMember> pre
             catch(Exception ex)
             {
                 throw exceptionToThrow ?? 
-                      new ContractViolationException(
-                          "Exception occured during predicate execution.See inner exception for details", ex);
+                      new ContractViolationException("Exception occured during predicate execution.See inner exception for details", ex);
             }
 
             if(!predicateResult)
             {
                 throw exceptionToThrow ?? 
-                      new ContractViolationException(
-                          "Contact precondition was violated. Expected that predicate returns true.");
+                      new ContractViolationException("Contact precondition was violated. Expected that predicate returns true.");
+            }
+        }
+        
+        private static void InternalThat<TMember>(TMember member, Predicate<TMember> predicate, string contractViolationMsg)
+        {
+            bool predicateResult;
+            
+            try
+            {
+                predicateResult =  predicate.Invoke(member);
+            }
+            catch(Exception ex)
+            {
+                throw new ContractViolationException(
+                    contractViolationMsg ?? "Exception occured during predicate execution.See inner exception for details", ex);
+            }
+
+            if(!predicateResult)
+            {
+                throw new ContractViolationException(contractViolationMsg ?? "Contact precondition was violated. Expected that predicate returns true.");
             }
         }
     }