15 assert method for strings

source/AccUnit/AccessCodeLib.AccUnit.csproj

@@ -93,6 +93,7 @@
     <Compile Include="Assertions\Constraints\EmptyConstraint.cs" />
     <Compile Include="Assertions\Constraints\NullConstraint.cs" />
     <Compile Include="Assertions\Constraints\NotConstraint.cs" />
+    <Compile Include="Assertions\Constraints\StringComparerConstraint.cs" />
     <Compile Include="Assertions\Interfaces\AssertionException.cs" />
     <Compile Include="Assertions\Interfaces\IAssertion.cs" />
     <Compile Include="Assertions\Interfaces\IAssertionsBuilder.cs" />
@@ -102,11 +103,13 @@
     <Compile Include="Assertions\Interfaces\IMatchResultCollector.cs" />
     <Compile Include="Assertions\Interfaces\IMatchResultCollectorBridge.cs" />
     <Compile Include="Assertions\AssertThrowsContainer.cs" />
+    <Compile Include="Assertions\StringConstraintBuilder.cs" />
     <Compile Include="CodeCoverage\CodeModuleTracker.cs" />
     <Compile Include="CodeCoverage\ProcedureTracker.cs" />
     <Compile Include="Interfaces\ITestItemTag.cs" />
     <Compile Include="Interfaces\ITagList.cs" />
     <Compile Include="Interfaces\ITestClassMemberList.cs" />
+    <Compile Include="Interfaces\StringCompareMode.cs" />
     <Compile Include="Interop\InteropConverter.cs" />
     <Compile Include="~trash\CodeModuleMemberWithMarker.cs" />
     <Compile Include="~trash\CompareTypeHelper.cs" />

source/AccUnit/Assertions/ConstraintBuilder.cs

@@ -4,51 +4,129 @@
 
 namespace AccessCodeLib.AccUnit.Assertions
 {
-    public class ConstraintBuilder : IConstraintBuilder, IConstraint
+    public class ConstraintBuilder : ConstraintBuilderBase<object>, IConstraintBuilder, IConstraint
+    {
+        public ConstraintBuilder()
+        {
+        }
+
+        public ConstraintBuilder(bool strict) : base(strict)
+        {
+        }
+
+        public new IConstraintBuilder EqualTo(object expected)
+        {
+            AddComparerConstraint("actual = expected", expected, 0);
+            return this;
+        }
+
+        public new IConstraintBuilder LessThan(object expected)
+        {
+            AddComparerConstraint("actual < expected", expected, -1);
+            return this;
+        }
+
+        public new IConstraintBuilder LessThanOrEqualTo(object expected)
+        {
+            AddComparerConstraint("actual <= expected", expected, -1, 0);
+            return this;
+        }
+
+        public new IConstraintBuilder GreaterThan(object expected)
+        {
+            AddComparerConstraint("actual > expected", expected, +1);
+            return this;
+        }
+
+        public new IConstraintBuilder GreaterThanOrEqualTo(object expected)
+        {
+            AddComparerConstraint("actual >= expected", expected, +1, 0);
+            return this;
+        }
+
+        public new IConstraintBuilder Null
+        {
+            get
+            {
+                AddChild(new NullConstraint());
+                return this;
+            }
+        }
+
+        public new IConstraintBuilder DBNull
+        {
+            get
+            {
+                AddChild(new DBNullConstraint());
+                return this;
+            }
+        }
+
+        public new IConstraintBuilder Empty
+        {
+            get
+            {
+                AddChild(new EmptyConstraint());
+                return this;
+            }
+        }
+
+        public new IConstraintBuilder Not
+        {
+            get
+            {
+                AddChild(new NotConstraint());
+                return this;
+            }
+        }
+
+    }
+
+    public abstract class ConstraintBuilderBase<T> : IConstraintBuilderBase<T>, IConstraint
     {
         private IConstraint _firstchild;
 
         private readonly bool _strict = false;
 
-        public ConstraintBuilder()
+        public ConstraintBuilderBase()
         {
         }
 
-        public ConstraintBuilder(bool strict)
+        public ConstraintBuilderBase(bool strict)
         {
             _strict = strict;
         }
 
-        public IConstraintBuilder EqualTo(object expected)
+        public IConstraintBuilderBase<T> EqualTo(T expected)
         {
             AddComparerConstraint("actual = expected", expected, 0);
             return this;
         }
 
-        public IConstraintBuilder LessThan(object expected)
+        public IConstraintBuilderBase<T> LessThan(T expected)
         {
             AddComparerConstraint("actual < expected", expected, -1);
             return this;
         }
 
-        public IConstraintBuilder LessThanOrEqualTo(object expected)
+        public IConstraintBuilderBase<T> LessThanOrEqualTo(T expected)
         {
             AddComparerConstraint("actual <= expected", expected, -1, 0);
             return this;
         }
 
-        public IConstraintBuilder GreaterThan(object expected)
+        public IConstraintBuilderBase<T> GreaterThan(T expected)
         {
             AddComparerConstraint("actual > expected", expected, +1);
             return this;
         }
-        public IConstraintBuilder GreaterThanOrEqualTo(object expected)
+        public IConstraintBuilderBase<T> GreaterThanOrEqualTo(T expected)
         {
             AddComparerConstraint("actual >= expected", expected, +1, 0);
             return this;
         }
 
-        private void AddComparerConstraint(string compareText, object expected, int expectedComparerResult)
+        protected virtual void AddComparerConstraint(string compareText, object expected, int expectedComparerResult)
         {
             if (expected is Array expectedArray)
             {
@@ -75,7 +153,7 @@ private void AddComparerConstraint(string compareText, object expected, int expe
             AddChild((IConstraint)newConstraint);
         }
 
-        private void AddArrayComparerConstraint(string compareText, Array expected, int expectedComparerResult)
+        protected virtual void AddArrayComparerConstraint(string compareText, Array expected, int expectedComparerResult)
         {
             Type T = expected.GetType().GetElementType();
             Type myType = typeof(ArrayConstraint<>).MakeGenericType(T);
@@ -112,7 +190,7 @@ private static bool IsNumeric(Type T)
             typeof(byte), typeof(uint), typeof(ulong), typeof(ushort), typeof(sbyte)
         };
 
-        private void AddComparerConstraint(string compareText, object expected, int expectedComparerResult, int expectedComparerResult2)
+        protected virtual void AddComparerConstraint(string compareText, object expected, int expectedComparerResult, int expectedComparerResult2)
         {
             if (expected is Array expectedArray)
             {
@@ -126,7 +204,7 @@ private void AddComparerConstraint(string compareText, object expected, int expe
             AddChild((IConstraint)newConstraint);
         }
 
-        private void AddArrayComparerConstraint(string compareText, Array expected, int expectedComparerResult, int expectedComparerResult2)
+        protected virtual void AddArrayComparerConstraint(string compareText, Array expected, int expectedComparerResult, int expectedComparerResult2)
         {
             //var newConstraint = new ArrayConstraint(compareText, expected, expectedComparerResult, expectedComparerResult2);
 
@@ -136,7 +214,7 @@ private void AddArrayComparerConstraint(string compareText, Array expected, int
             AddChild((IConstraint)newConstraint);
         }
 
-        public IConstraintBuilder Null
+        public IConstraintBuilderBase<T> Null
         {
             get
             {
@@ -145,7 +223,7 @@ public IConstraintBuilder Null
             }
         }
 
-        public IConstraintBuilder DBNull
+        public IConstraintBuilderBase<T> DBNull
         {
             get
             {
@@ -154,7 +232,7 @@ public IConstraintBuilder DBNull
             }
         }
 
-        public IConstraintBuilder Empty
+        public IConstraintBuilderBase<T> Empty
         {
             get
             {
@@ -163,7 +241,7 @@ public IConstraintBuilder Empty
             }
         }
 
-        public IConstraintBuilder Not
+        public IConstraintBuilderBase<T> Not
         {
             get
             {
@@ -174,8 +252,7 @@ public IConstraintBuilder Not
 
         IConstraint IConstraint.Child { get; set; }
 
-
-        private void AddChild(IConstraint constraint)
+        protected void AddChild(IConstraint constraint)
         {
             if (_firstchild is null)
             {

source/AccUnit/Assertions/Constraints/ComparerConstraint.cs

@@ -110,4 +110,4 @@ private static string FormattedTypeDescription(Type type, bool strict = false)
             return (!strict && type == typeof(double)) ? "numeric type" : type.Name;
         }
     }
-}
+}

source/AccUnit/Assertions/Constraints/StringComparerConstraint.cs

@@ -0,0 +1,85 @@
+using System;
+
+namespace AccessCodeLib.AccUnit.Assertions.Constraints
+{
+    class StringComparerConstraint : ComparerConstraint<string>
+    {
+        readonly StringComparison _compareMethod;
+        readonly bool _nullIsEqualEmptyString = false;
+
+        public StringComparerConstraint(string compareText, string expected, int expectedComparerResult, StringComparison compareMethod = StringComparison.InvariantCulture, bool nullIsEqualEmptyString = false)
+            : base(compareText, expected, expectedComparerResult, false)
+        {
+            _compareMethod = compareMethod;
+            _nullIsEqualEmptyString = nullIsEqualEmptyString;
+        }
+
+        public StringComparerConstraint(string compareText, string expected, int expectedComparerResult, int expectedComparerResult2, StringComparison compareMethod = StringComparison.InvariantCulture, bool nullIsEqualEmptyString = false)
+             : base(compareText, expected, expectedComparerResult, expectedComparerResult2, false)
+        {
+            _compareMethod = compareMethod;
+            _nullIsEqualEmptyString = nullIsEqualEmptyString;
+        }
+
+        protected override IMatchResult Compare(object actual)
+        {
+            if (actual is null || (_nullIsEqualEmptyString && actual is string  s && s == string.Empty))
+            {
+                if (Expected == null || _nullIsEqualEmptyString && Expected == string.Empty)
+                {
+                    if (ExpectedComparerResult == 0 || (UseOr == true && ExpectedComparerResult2 == 0))
+                    {
+                        return new MatchResult(CompareText, true, null, actual, Expected);
+                    }
+                    return new MatchResult(CompareText, false, "actual is vbNullstring, expected is " + (Expected == null ? "vbNullstring" : "Empty"), actual, Expected);
+                }
+
+                return new MatchResult(CompareText, false, "actual is vbNullstring and expected is not vbNullString" + (Expected == string.Empty ? " or Empty" : ""), actual, Expected);
+            }
+
+            if (actual == DBNull.Value)
+            {
+                return new MatchResult(CompareText, false, "actual is Null and expected is not Null", actual, Expected);
+            }
+
+            // Check type
+            var actualType = ConstraintBuilder.Type2Compare(actual, Strict);
+            var expectedType = typeof(string);
+            if (actualType != expectedType)
+            {
+                var returnText = "actual (" + actual.GetType().Name + ") is not of type String";
+                return new MatchResult(CompareText, false, returnText, actual, Expected);
+            }
+
+            // Check value
+            var a = (string)Convert.ChangeType(actual, typeof(string));
+            var result = string.Compare(a, Expected, _compareMethod);
+
+            if (result == ExpectedComparerResult)
+            {
+                return new MatchResult(CompareText, true, null, actual, Expected);
+            }
+
+            if (UseOr && (result == ExpectedComparerResult2))
+            {
+                return new MatchResult(CompareText, true, null, actual, Expected);
+            }
+
+            string compareInfo;
+            if (result < 0)
+            {
+                compareInfo = "actual is less then expected";
+            }
+            else if (result > 0)
+            {
+                compareInfo = "actual is greather then expected";
+            }
+            else
+            {
+                compareInfo = "actual is equal expected";
+            }
+
+            return new MatchResult(CompareText, false, compareInfo, actual, Expected);
+        }
+    }
+}

source/AccUnit/Assertions/Interfaces/IConstraintBuilder.cs

@@ -1,12 +1,21 @@
 namespace AccessCodeLib.AccUnit.Assertions
 {
-    public interface IConstraintBuilder : IConstraint
+    public interface IConstraintBuilderBase<T> : IConstraint
     {
-        IConstraintBuilder EqualTo(object expected);
-        IConstraintBuilder LessThan(object expected);
-        IConstraintBuilder LessThanOrEqualTo(object expected);
-        IConstraintBuilder GreaterThan(object expected);
-        IConstraintBuilder GreaterThanOrEqualTo(object expected);
+        IConstraintBuilderBase<T> EqualTo(T expected);
+        IConstraintBuilderBase<T> LessThan(T expected);
+        IConstraintBuilderBase<T> LessThanOrEqualTo(T expected);
+        IConstraintBuilderBase<T> GreaterThan(T expected);
+        IConstraintBuilderBase<T> GreaterThanOrEqualTo(T expected);
+    }
+
+    public interface IConstraintBuilder : IConstraint, IConstraintBuilderBase<object>
+    {
+        new IConstraintBuilder EqualTo(object expected);
+        new IConstraintBuilder LessThan(object expected);
+        new IConstraintBuilder LessThanOrEqualTo(object expected);
+        new IConstraintBuilder GreaterThan(object expected);
+        new IConstraintBuilder GreaterThanOrEqualTo(object expected);
 
         IConstraintBuilder Null { get; }
         IConstraintBuilder DBNull { get; }
@@ -19,4 +28,16 @@ public interface IConstraintBuilder : IConstraint
         IConstraintBuilder Not { get; }
         // Is.All
     }
+
+    public interface IStringConstraintBuilder : IConstraint, IConstraintBuilderBase<string>, IConstraintBuilder
+    {
+        new IConstraintBuilder EqualTo(string expected);
+        new IConstraintBuilder LessThan(string expected);
+        new IConstraintBuilder LessThanOrEqualTo(string expected);
+        new IConstraintBuilder GreaterThan(string expected);
+        new IConstraintBuilder GreaterThanOrEqualTo(string expected);
+
+        new IStringConstraintBuilder Not { get; }
+    }
+
 }