port matchesRegex placeholder from #xmlunit/xmlunit/178

Author: bodewig

RELEASE_NOTES.md

@@ -14,6 +14,10 @@ element/attribute. This allows placeholders like
   [#32](https://github.com/xmlunit/xmlunit.net/pull/32) by
   [MilkyWare](https://github.com/MilkyWare)
 
+* added a new `${xmlunit.matchesRegex(regex)}` placeholder
+  based on Java PR [xmlunit/#178](https://github.com/xmlunit/xmlunit/issues/178) by
+  [@Jazzyekim](https://github.com/Jazzyekim).
+
 ## XMLUnit.NET 2.7.2 - /Released 2020-03-08/
 
 * the XPath values for comparisons resulting in `CHILD_LOOKUP`

src/main/net-placeholders/IsDateTimePlaceholderHandler.cs

@@ -24,6 +24,11 @@ namespace Org.XmlUnit.Placeholder
     /// <summary>
     /// Handler for the "isDateTime" handler placeholder keyword
     /// </summary>
+    /// <remarks>
+    ///   <para>
+    /// since 2.8.0
+    ///   </para>
+    /// </remarks>
     public class IsDateTimePlaceholderHandler : IPlaceholderHandler
     {
         private const string _keyword = "isDateTime";

src/main/net-placeholders/MatchesRegexPlaceholderHandler.cs

@@ -0,0 +1,46 @@
+/*
+  This file is licensed to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+using System.Text.RegularExpressions;
+using Org.XmlUnit.Diff;
+
+namespace Org.XmlUnit.Placeholder {
+    /// <summary>
+    /// Handler for the "matchesRegex()" placeholder keyword.
+    /// </summary>
+    /// <remarks>
+    ///   <para>
+    /// since 2.8.0
+    ///   </para>
+    /// </remarks>
+    public class MatchesRegexPlaceholderHandler : IPlaceholderHandler {
+        private const string PLACEHOLDER_NAME = "matchesRegex";
+
+        /// <inheritdoc/>
+        public string Keyword { get { return PLACEHOLDER_NAME; } }
+        /// <inheritdoc/>
+        public ComparisonResult Evaluate(string testText, params string[] args) {
+            if (args.Length > 0 && args[0] != null && args[0] != "") {
+                var pattern = new Regex(args[0].Trim());
+                if (testText != null && Evaluate(testText.Trim(), pattern)) {
+                    return ComparisonResult.EQUAL;
+                }
+            }
+            return ComparisonResult.DIFFERENT;
+        }
+
+        private bool Evaluate(string testText, Regex pattern) {
+            return pattern.Match(testText).Success;
+        }
+    }
+}

src/main/net-placeholders/NetFramework/XMLUnit.Placeholders.NetFramework.csproj

@@ -74,6 +74,7 @@
     <Compile Include="..\IgnorePlaceholderHandler.cs" />
     <Compile Include="..\IsDateTimePlaceholderHandler.cs" />
     <Compile Include="..\IsNumberPlaceholderHandler.cs" />
+    <Compile Include="..\MatchesRegexPlaceholderHandler.cs" />
     <Compile Include="..\PlaceholderDifferenceEvaluator.cs" />
     <Compile Include="..\PlaceholderSupport.cs" />
   </ItemGroup>

src/tests/net-placeholders/MatchesRegexPlaceholderHandlerTest.cs

@@ -0,0 +1,88 @@
+/*
+  This file is licensed to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+using NUnit.Framework;
+using Org.XmlUnit.Diff;
+using Org.XmlUnit.Placeholder;
+
+namespace Org.XmlUnit.Placeholder
+{
+    [TestFixture]
+    public class MatchesRegexPlaceholderHandlerTest {
+
+        private IPlaceholderHandler placeholderHandler = new MatchesRegexPlaceholderHandler();
+
+        [Test]
+        public void ShouldGetKeyword() {
+            string expected = "matchesRegex";
+            string keyword = placeholderHandler.Keyword;
+
+            Assert.AreEqual(expected, keyword);
+        }
+
+        [Test]
+        public void ShouldEvaluateGivenSimpleRegex() {
+            string testTest = "1234";
+            string regex = "^\\d+$";
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.EQUAL, comparisonResult);
+        }
+
+        [Test]
+        public void ShouldNotEvaluateGivenNull() {
+            string testTest = null;
+            string regex = "^\\d+$";
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.DIFFERENT, comparisonResult);
+        }
+
+        [Test]
+        public void ShouldNotEvaluateGivenEmptystring() {
+            string testTest = "";
+            string regex = "^\\d+$";
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.DIFFERENT, comparisonResult);
+        }
+
+        [Test]
+        public void ShouldNotEvaluatestringDoesNotMatchRegex() {
+            string testTest = "not parsable as a number even though it contains 123 numbers";
+            string regex = "^\\d+$";
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.DIFFERENT, comparisonResult);
+        }
+
+        [Test]
+        public void ShouldNotEvaluateWithNullRegex() {
+            string testTest = "a string";
+            string regex = null;
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.DIFFERENT, comparisonResult);
+        }
+
+        [Test]
+        public void ShouldNotEvaluateWithEmptyRegex() {
+            string testTest = "a string";
+            string regex = "";
+            ComparisonResult comparisonResult = placeholderHandler.Evaluate(testTest, regex);
+
+            Assert.AreEqual(ComparisonResult.DIFFERENT, comparisonResult);
+        }
+    }
+
+}

src/tests/net-placeholders/NetFramework/XMLUnit.Placeholders.Tests.NetFramework.csproj

@@ -67,6 +67,7 @@
     </Compile>
     <Compile Include="..\IsDateTimePlaceholderHandlerTests.cs" />
     <Compile Include="..\IsNumberPlaceholderHandlerTest.cs" />
+    <Compile Include="..\MatchesRegexPlaceholderHandlerTest.cs" />
     <Compile Include="..\PlaceholderDifferenceEvaluatorTest.cs" />
     <Compile Include="..\PlaceholderSupportTest.cs" />
   </ItemGroup>