Merge pull request #11 from havardt/Development

Improved check efficiency
havardt · Jun 3, 2019 · 817b59e · 817b59e
2 parents fb469d5 + c33c7be
commit 817b59e
Show file tree

Hide file tree

Showing 13 changed files with 116 additions and 86 deletions.
diff --git a/source/EzPasswordValidator.Tests/LengthCheckTest.cs b/source/EzPasswordValidator.Tests/LengthCheckTest.cs
@@ -45,6 +45,14 @@ public void WhenPasswordIsNullThenPasswordIsNotValid()
             Assert.IsFalse(_check.Execute(invalidPsw));
         }
 
+        [TestMethod]
+        public void WhenPasswordIsEmptyThenPasswordIsNotValid()
+        {
+            const string invalidPsw = "             ";
+
+            Assert.IsFalse(_check.Execute(invalidPsw));
+        }
+
         [TestMethod]
         public void WhenPasswordIsExactlyRequiredLengthThenPasswordIsValid()
         {

diff --git a/source/EzPasswordValidator.Tests/NumberCheckTest.cs b/source/EzPasswordValidator.Tests/NumberCheckTest.cs
@@ -1,5 +1,4 @@
-using System;
-using EzPasswordValidator.Checks;
+using EzPasswordValidator.Checks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace EzPasswordValidator.Tests

diff --git a/source/EzPasswordValidator.Tests/NumberRepetitionCheckTest.cs b/source/EzPasswordValidator.Tests/NumberRepetitionCheckTest.cs
@@ -25,14 +25,15 @@ public void WhenPasswordContainsNoNumbersThenPasswordIsValid()
 
         [DataRow("test22")]
         [DataRow("te22st")]
-        [DataRow("22test")]
+        [DataRow("224test")]
         [DataTestMethod]
         public void WhenPasswordContainsTheSameDigitTwoTimesInARowThenPasswordIsValid(string psw) =>
             Assert.IsTrue(_check.Execute(psw));
 
         [DataRow("test222")]
         [DataRow("te222st")]
         [DataRow("222test")]
+        [DataRow("37222test")]
         [DataTestMethod]
         public void WhenPasswordContainsTheSameDigitThreeTimesInARowThenPasswordIsInvalid(string psw) =>
             Assert.IsFalse(_check.Execute(psw));

diff --git a/source/EzPasswordValidator/Checks/CaseCheck.cs b/source/EzPasswordValidator/Checks/CaseCheck.cs
@@ -1,5 +1,4 @@
-using System.Linq;
-
+
 namespace EzPasswordValidator.Checks
 {
     /// <inheritdoc />
@@ -21,8 +20,31 @@ public CaseCheck()
         /// <summary>
         /// Checks that the password contains at least one upper- and lower-case letter.
         /// </summary>
-        protected override bool OnExecute(string password) =>
-            password.Any(char.IsUpper) && password.Any(char.IsLower);
-
+        protected override bool OnExecute(string password)
+        {
+            var hasUpper = false;
+            var hasLower = false;
+            foreach (char c in password)
+            {
+                if (char.IsUpper(c))
+                {
+                    hasUpper = true;
+                    if (hasLower)
+                    {
+                        return true;
+                    }
+                    continue;//No point checking if lower if the char is already an upper case char.
+                }
+                if (char.IsLower(c))
+                {
+                    hasLower = true;
+                    if (hasUpper)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
     }
 }
diff --git a/source/EzPasswordValidator/Checks/CheckHelper.cs b/source/EzPasswordValidator/Checks/CheckHelper.cs
@@ -0,0 +1,49 @@
+using System;
+
+namespace EzPasswordValidator.Checks
+{
+    public static class CheckHelper
+    {
+        /// <summary>
+        /// Checks if the given string contains character repetition of length 3 or longer.
+        /// </summary>
+        /// <param name="expr">The expression of which filters which characters to check for repetition.</param>
+        /// <param name="str">The string to check.</param>
+        /// <returns>
+        /// <c>true</c> if the given string passes the test and does NOT contain character repetition.
+        /// If the given string does contain character repetition over the allowed length then <c>false</c>
+        /// is returned.
+        /// </returns>
+        public static bool RepetitionCheck(Func<char, bool> expr, string str)
+        {
+            const char baseSymbol = (char)0;
+            char previousPrevious = baseSymbol;
+            char previous = baseSymbol;
+            foreach (char c in str)
+            {
+                if (expr.Invoke(c))
+                {
+                    if (previousPrevious == baseSymbol || previousPrevious != c)
+                    {
+                        previousPrevious = c;
+                    }
+                    else if (previous == baseSymbol || previous != c)
+                    {
+                        previous = c;
+                    }
+                    else
+                    {
+                        if (previousPrevious == previous && previous == c)
+                        {
+                            return false;
+                        }
+                    }
+                    continue;
+                }
+                previousPrevious = baseSymbol;
+                previous = baseSymbol;
+            }
+            return true;
+        }
+    }
+}
diff --git a/source/EzPasswordValidator/Checks/LengthCheck.cs b/source/EzPasswordValidator/Checks/LengthCheck.cs
@@ -45,6 +45,6 @@ public LengthCheck(uint requiredLength)
         /// <c>null</c> is always invalid.
         /// </summary>
         protected override bool OnExecute(string password) =>
-            !string.IsNullOrWhiteSpace(password) && password.Trim().Length >= RequiredLength;
+            password != null && password.Trim().Length >= RequiredLength;
     }
 }
diff --git a/source/EzPasswordValidator/Checks/LetterCheck.cs b/source/EzPasswordValidator/Checks/LetterCheck.cs
@@ -31,7 +31,6 @@ protected override bool OnExecute(string password)
                     return true;
                 }
             }
-
             return false;
         }
     }

diff --git a/source/EzPasswordValidator/Checks/LetterRepetitionCheck.cs b/source/EzPasswordValidator/Checks/LetterRepetitionCheck.cs
@@ -1,5 +1,4 @@
-using System.Text.RegularExpressions;
-
+
 namespace EzPasswordValidator.Checks
 {
     /// <inheritdoc />
@@ -26,37 +25,7 @@ public LetterRepetitionCheck()
         /// <returns>
         ///   <c>true</c> if the password does NOT contain letter repetition; <c>false</c> otherwise.
         /// </returns>
-        protected override bool OnExecute(string password)
-        {
-            const char baseChar = (char)0;
-            char previousPrevious = baseChar;
-            char previous = baseChar;
-            foreach (char c in password)
-            {
-                if (char.IsLetter(c))
-                {
-                    if (previousPrevious == baseChar || previousPrevious != c)
-                    {
-                        previousPrevious = c;
-                    }
-                    else if (previous == baseChar || previous != c)
-                    {
-                        previous = c;
-                    }
-                    else
-                    {
-                        if (previousPrevious == previous && previous == c)
-                        {
-                            return false;
-                        }
-                    }
-                    continue;
-                }
-
-                previousPrevious = baseChar;
-                previous = baseChar;
-            }
-            return true;
-        }
+        protected override bool OnExecute(string password) =>
+            CheckHelper.RepetitionCheck(char.IsLetter, password);
     }
 }
diff --git a/source/EzPasswordValidator/Checks/NumberCheck.cs b/source/EzPasswordValidator/Checks/NumberCheck.cs
@@ -1,5 +1,4 @@
-using System.Text.RegularExpressions;
-
+
 namespace EzPasswordValidator.Checks
 {
     /// <inheritdoc />
@@ -21,7 +20,17 @@ public NumberCheck()
         /// <summary>
         /// Checks that the password contains at least one number.
         /// </summary>
-        protected override bool OnExecute(string password) =>
-            Regex.IsMatch(password, "^.*[0-9]+.*$");
+        protected override bool OnExecute(string password)
+        {
+            foreach (char c in password)
+            {
+                if (char.IsDigit(c))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
     }
 }
diff --git a/source/EzPasswordValidator/Checks/NumberRepetitionCheck.cs b/source/EzPasswordValidator/Checks/NumberRepetitionCheck.cs
@@ -1,5 +1,4 @@
-using System.Text.RegularExpressions;
-
+
 namespace EzPasswordValidator.Checks
 {
     /// <inheritdoc />
@@ -25,6 +24,6 @@ public NumberRepetitionCheck()
         ///   <c>true</c> if the check is passed and NO number repetition is found; <c>false</c> otherwise.
         /// </returns>
         protected override bool OnExecute(string password) => 
-            !Regex.IsMatch(password, @"^.*([0-9])\1{2}.*$");
+            CheckHelper.RepetitionCheck(char.IsDigit, password);
     }
 }
diff --git a/source/EzPasswordValidator/Checks/NumberSequenceCheck.cs b/source/EzPasswordValidator/Checks/NumberSequenceCheck.cs
@@ -1,4 +1,4 @@
-using System.Text.RegularExpressions;
+using System.Linq;
 
 namespace EzPasswordValidator.Checks
 {
@@ -9,6 +9,12 @@ namespace EzPasswordValidator.Checks
     /// <seealso cref="EzPasswordValidator.Checks.Check" />
     public sealed class NumberSequenceCheck : Check
     {
+        public static string[] Sequences =
+        {
+            "012", "123", "234", "345", "456", "567", "678", "789",
+            "987", "876", "765", "654", "543", "432", "321", "210"
+        };
+
         /// <inheritdoc />
         /// <summary>
         /// Initializes a new instance of the <see cref="NumberSequenceCheck" /> class.
@@ -25,7 +31,6 @@ public NumberSequenceCheck()
         /// <returns>
         ///   <c>true</c> if the check is passed and NO number sequence is found; <c>false</c> otherwise.
         /// </returns>
-        protected override bool OnExecute(string password) =>
-            !Regex.IsMatch(password, @"^.*(012|123|234|345|456|567|678|789|987|876|765|654|543|432|321|210)+.*$");
+        protected override bool OnExecute(string password) => Sequences.All(s => !password.Contains(s));
     }
 }
diff --git a/source/EzPasswordValidator/Checks/SymbolCheck.cs b/source/EzPasswordValidator/Checks/SymbolCheck.cs
@@ -40,7 +40,6 @@ protected override bool OnExecute(string password)
                     return true;
                 }   
             }
-
             return false;
         }
     }

diff --git a/source/EzPasswordValidator/Checks/SymbolRepetitionCheck.cs b/source/EzPasswordValidator/Checks/SymbolRepetitionCheck.cs
@@ -25,36 +25,7 @@ public SymbolRepetitionCheck()
         /// <returns>
         ///   <c>true</c> if the password does NOT contain symbol repetition; <c>false</c> otherwise.
         /// </returns>
-        protected override bool OnExecute(string password)
-        {
-            const char baseSymbol = (char) 0;
-            char previousPrevious = baseSymbol;
-            char previous = baseSymbol;
-            foreach (char c in password)
-            {
-                if (SymbolCheck.SymbolsHashSet.Contains(c))
-                {
-                    if (previousPrevious == baseSymbol || previousPrevious != c)
-                    {
-                        previousPrevious = c;
-                    }else if (previous == baseSymbol || previous != c)
-                    {
-                        previous = c;
-                    }
-                    else
-                    {
-                        if (previousPrevious == previous && previous == c)
-                        {
-                            return false;
-                        }
-                    }
-                    continue;
-                }
-
-                previousPrevious = baseSymbol;
-                previous = baseSymbol;
-            }
-            return true;
-        }
+        protected override bool OnExecute(string password) => 
+            CheckHelper.RepetitionCheck(c => SymbolCheck.SymbolsHashSet.Contains(c), password);
     }
 }