mrpinkzh#16 renamed property mentions to member.

florianbaer · Jan 22, 2016 · 580f403 · 580f403
1 parent 5a207eb
commit 580f403
Show file tree

Hide file tree

Showing 24 changed files with 322 additions and 321 deletions.
diff --git a/src/ExAs/Assertions/MemberAssertion.cs b/src/ExAs/Assertions/MemberAssertion.cs
@@ -6,13 +6,13 @@ namespace ExAs.Assertions
 {
     public class MemberAssertion<T, TMember> : IAssertMember<T, TMember>
     {
-        private readonly Expression<Func<T, TMember>> genericPropertyExpression;
+        private readonly Expression<Func<T, TMember>> memberExpression;
         private readonly IAssert<T> parent;
         private IAssertValue<TMember> assertion;
 
-        public MemberAssertion(Expression<Func<T, TMember>> genericPropertyExpression, IAssert<T> parent)
+        public MemberAssertion(Expression<Func<T, TMember>> memberExpression, IAssert<T> parent)
         {
-            this.genericPropertyExpression = genericPropertyExpression;
+            this.memberExpression = memberExpression;
             this.parent = parent;
         }
 
@@ -24,7 +24,7 @@ public IAssert<T> SetAssertion(IAssertValue<TMember> newAssertion)
 
         public PropertyAssertionResult Assert(T actual)
         {
-            return PropertyAssertionFunctions.Assert(actual, genericPropertyExpression, assertion);
+            return MemberAssertionFunctions.Assert(actual, memberExpression, assertion);
         }
     }
 }
diff --git a/.../Assertions/PropertyAssertionFunctions.cs → ...As/Assertions/MemberAssertionFunctions.cs b/.../Assertions/PropertyAssertionFunctions.cs → ...As/Assertions/MemberAssertionFunctions.cs
@@ -5,18 +5,18 @@
 
 namespace ExAs.Assertions
 {
-    public static class PropertyAssertionFunctions
+    public static class MemberAssertionFunctions
     {
-        public static PropertyAssertionResult Assert<TType, TPropertyType>(TType instance,
-            Expression<Func<TType, TPropertyType>> propertExpression, IAssertValue<TPropertyType> assertion)
+        public static PropertyAssertionResult Assert<T, TMember>(T instance,
+            Expression<Func<T, TMember>> memberExpression, IAssertValue<TMember> assertion)
         {
-            string memberName = propertExpression.ExtractMemberName();
-            TPropertyType value = propertExpression.Compile()(instance);
+            string memberName = memberExpression.ExtractMemberName();
+            TMember value = memberExpression.Compile()(instance);
             return Assert(assertion, memberName, value);
         }
 
-        public static PropertyAssertionResult Assert<TPropertyType>(IAssertValue<TPropertyType> assertion, string memberName,
-            TPropertyType value)
+        public static PropertyAssertionResult Assert<TMember>(IAssertValue<TMember> assertion, string memberName,
+            TMember value)
         {
             if (assertion == null)
                 return new PropertyAssertionResult(memberName,

diff --git a/src/ExAs/BooleanAssertionExtensions.cs → src/ExAs/BooleanAssertions.cs b/src/ExAs/BooleanAssertionExtensions.cs → src/ExAs/BooleanAssertions.cs
@@ -3,16 +3,16 @@
 
 namespace ExAs
 {
-    public static class BooleanAssertionExtensions
+    public static class BooleanAssertions
     {
-        public static IAssert<T> IsTrue<T>(this IAssertMember<T, bool> property)
+        public static IAssert<T> IsTrue<T>(this IAssertMember<T, bool> member)
         {
-            return property.SetAssertion(new IsTrueAssertion());
+            return member.SetAssertion(new IsTrueAssertion());
         }
 
-        public static IAssert<T> IsFalse<T>(this IAssertMember<T, bool> property)
+        public static IAssert<T> IsFalse<T>(this IAssertMember<T, bool> member)
         {
-            return property.SetAssertion(new IsFalseAssertion());
+            return member.SetAssertion(new IsFalseAssertion());
         }
     }
 }
diff --git a/src/ExAs/ComparableAssertions.cs b/src/ExAs/ComparableAssertions.cs
@@ -0,0 +1,27 @@
+using System;
+using ExAs.Assertions;
+using ExAs.Assertions.MemberAssertions.Numbers;
+
+namespace ExAs
+{
+    public static class ComparableAssertions
+    {
+        public static IAssert<T> IsSmallerThan<T, TMember>(this IAssertMember<T, TMember> member, TMember expected)
+            where TMember : IComparable<TMember>
+        {
+            return member.SetAssertion(new IsSmallerAssertion<TMember>(expected));
+        }
+
+        public static IAssert<T> IsBiggerThan<T, TMember>(this IAssertMember<T, TMember> member, TMember expected)
+            where TMember : IComparable<TMember>
+        {
+            return member.SetAssertion(new IsBiggerAssertion<TMember>(expected));
+        }
+
+        public static IAssert<T> IsInRange<T, TMember>(this IAssertMember<T, TMember> member, TMember min, TMember max)
+            where TMember : IComparable<TMember>
+        {
+            return member.SetAssertion(new InRangeAssertion<TMember>(min, max));
+        }
+    }
+}
diff --git a/src/ExAs/ComparablePropertyAssertionExtensions.cs b/src/ExAs/ComparablePropertyAssertionExtensions.cs
diff --git a/src/ExAs/DateTimeAssertions.cs b/src/ExAs/DateTimeAssertions.cs
@@ -0,0 +1,19 @@
+using System;
+using ExAs.Assertions;
+using ExAs.Assertions.MemberAssertions.DateTimes;
+
+namespace ExAs
+{
+    public static class DateTimeAssertions
+    {
+        public static IAssert<T> IsOnSameDayAs<T>(this IAssertMember<T, DateTime> member, DateTime expectedDate)
+        {
+            return member.SetAssertion(new SameDayAssertion(expectedDate));
+        }
+
+        public static IAssert<T> IsCloseTo<T>(this IAssertMember<T, DateTime> member, DateTime expectedTime, TimeSpan plusMinusRange)
+        {
+            return member.SetAssertion(new CloseToAssertion(expectedTime, plusMinusRange));
+        }
+    }
+}
diff --git a/src/ExAs/DateTimePropertyAssertionExtensions.cs b/src/ExAs/DateTimePropertyAssertionExtensions.cs
diff --git a/src/ExAs/EnumerableAssertions.cs b/src/ExAs/EnumerableAssertions.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using ExAs.Assertions;
+using ExAs.Assertions.MemberAssertions.Enumerables;
+
+namespace ExAs
+{
+    public static class EnumerableAssertions
+    {
+        public static IAssert<T> IsEmpty<T, TElement>(this IAssertMember<T, IEnumerable<TElement>> member)
+        {
+            return member.SetAssertion(new IsEmptyAssertion<TElement>());
+        }
+
+        public static IAssert<T> IsNotEmpty<T, TElement>(this IAssertMember<T, IEnumerable<TElement>> member)
+        {
+            return member.SetAssertion(new IsNotEmptyAssertion<TElement>());
+        }
+
+        public static IAssert<T> HasAny<T, TElement>(
+            this IAssertMember<T, IEnumerable<TElement>> member,
+            Func<IAssert<TElement>, IAssert<TElement>> assertion)
+        {
+            return member.SetAssertion(new HasAnyAssertion<TElement>(assertion(new ObjectAssertion<TElement>())));
+        }
+
+        public static IAssert<T> HasNone<T, TElement>(
+            this IAssertMember<T, IEnumerable<TElement>> member,
+            Func<IAssert<TElement>, IAssert<TElement>> assertion)
+        {
+            return member.SetAssertion(new HasNoneAssertion<TElement>(assertion(new ObjectAssertion<TElement>())));
+        }
+
+        public static IAssert<T> HasCount<T, TMember>(this IAssertMember<T, IEnumerable<TMember>> member, int expected)
+        {
+            return member.SetAssertion(new HasCountAssertion<TMember>(expected));
+        }
+    }
+}
diff --git a/src/ExAs/EnumerablePropertyAssertionExtensions.cs b/src/ExAs/EnumerablePropertyAssertionExtensions.cs
diff --git a/src/ExAs/ExAs.csproj b/src/ExAs/ExAs.csproj
@@ -36,7 +36,7 @@
   <ItemGroup>
     <Compile Include="Assertions\EnumerableAssertion.cs" />
     <Compile Include="Assertions\IAssertMember.cs" />
-    <Compile Include="Assertions\PropertyAssertionFunctions.cs" />
+    <Compile Include="Assertions\MemberAssertionFunctions.cs" />
     <Compile Include="Assertions\MemberAssertions\Booleans\IsFalseAssertion.cs" />
     <Compile Include="Assertions\MemberAssertions\Booleans\IsTrueAssertion.cs" />
     <Compile Include="Assertions\MemberAssertions\DateTimes\CloseToAssertion.cs" />
@@ -59,14 +59,14 @@
     <Compile Include="Assertions\MemberAssertions\Timespans\IsCloseToAssertion.cs" />
     <Compile Include="Assertions\MemberAssertions\Timespans\IsNegativeAssertion.cs" />
     <Compile Include="Assertions\MemberAssertions\Timespans\IsPositiveAssertion.cs" />
-    <Compile Include="BooleanAssertionExtensions.cs" />
-    <Compile Include="ComparablePropertyAssertionExtensions.cs" />
-    <Compile Include="DateTimePropertyAssertionExtensions.cs" />
-    <Compile Include="EnumerablePropertyAssertionExtensions.cs" />
+    <Compile Include="BooleanAssertions.cs" />
+    <Compile Include="ComparableAssertions.cs" />
+    <Compile Include="DateTimeAssertions.cs" />
+    <Compile Include="EnumerableAssertions.cs" />
     <Compile Include="ExtendedAssertionException.cs" />
-    <Compile Include="NullableBooleanPropertyAssertionExtensions.cs" />
-    <Compile Include="NullableIntegerPropertyAssertionExtensions.cs" />
-    <Compile Include="ReadOnlyCollectionPropertyAssertionExtensions.cs" />
+    <Compile Include="NullableBooleanAssertions.cs" />
+    <Compile Include="NullableIntegerAssertions.cs" />
+    <Compile Include="ReadOnlyCollectionAssertions.cs" />
     <Compile Include="Results\ObjectAssertionResult.cs" />
     <Compile Include="Assertions\IAssertValue.cs" />
     <Compile Include="Assertions\ObjectAssertions\IsNotNullAssertion.cs" />
@@ -83,10 +83,10 @@
     <Compile Include="ExAsExtensions.cs" />
     <Compile Include="ObjectAssertionExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="PropertyAssertionExtensions.cs" />
-    <Compile Include="ShortPropertyAssertionExtensions.cs" />
-    <Compile Include="StringPropertyAssertionExtensions.cs" />
-    <Compile Include="TimespanPropertyAssertionExtensions.cs" />
+    <Compile Include="MemberAssertionExtensions.cs" />
+    <Compile Include="ShortAssertions.cs" />
+    <Compile Include="StringAssertions.cs" />
+    <Compile Include="TimespanAssertions.cs" />
     <Compile Include="Utils\ComposeLog.cs" />
     <Compile Include="Utils\MemberExpressionFunctions.cs" />
     <Compile Include="Utils\StringFunctions.cs" />

diff --git a/src/ExAs/MemberAssertionExtensions.cs b/src/ExAs/MemberAssertionExtensions.cs
@@ -0,0 +1,36 @@
+using System;
+using ExAs.Assertions;
+using ExAs.Assertions.MemberAssertions;
+using ExAs.Assertions.ObjectAssertions;
+
+namespace ExAs
+{
+    public static class MemberAssertionExtensions
+    {
+        public static IAssert<T> IsNull<T, TMember>(this IAssertMember<T, TMember> member)
+            where TMember : class
+        {
+            return member.SetAssertion(new IsNullAssertion<TMember>());
+        }
+
+        public static IAssert<T> IsNotNull<T, TMember>(this IAssertMember<T, TMember> member)
+            where TMember : class
+        {
+            return member.SetAssertion(new IsNotNullAssertion<TMember>());
+        }
+
+        public static IAssert<T> IsEqualTo<T, TMember>(this IAssertMember<T, TMember> member, TMember expected)
+        {
+            return member.SetAssertion(new EqualAssertion<TMember>(expected));
+        }
+
+        public static IAssert<T> Fulfills<T, TMember>(
+            this IAssertMember<T, TMember> member,
+            Func<IAssert<TMember>, IAssert<TMember>> assertion)
+        {
+            return
+                member.SetAssertion(
+                    new AssertToAssertValueAdapter<TMember>(assertion(new ObjectAssertion<TMember>())));
+        }
+    }
+}
diff --git a/...ableBooleanPropertyAssertionExtensions.cs → src/ExAs/NullableBooleanAssertions.cs b/...ableBooleanPropertyAssertionExtensions.cs → src/ExAs/NullableBooleanAssertions.cs
@@ -5,26 +5,26 @@
 
 namespace ExAs
 {
-    public static class NullableBooleanPropertyAssertionExtensions
+    public static class NullableBooleanAssertions
     {
-        public static IAssert<T> IsNull<T>(this IAssertMember<T, bool?> property)
+        public static IAssert<T> IsNull<T>(this IAssertMember<T, bool?> member)
         {
-            return property.SetAssertion(new IsNullAssertion<bool?>());
+            return member.SetAssertion(new IsNullAssertion<bool?>());
         }
 
-        public static IAssert<T> IsNotNull<T>(this IAssertMember<T, bool?> property)
+        public static IAssert<T> IsNotNull<T>(this IAssertMember<T, bool?> member)
         {
-            return property.SetAssertion(new IsNotNullAssertion<bool?>());
+            return member.SetAssertion(new IsNotNullAssertion<bool?>());
         }
 
-        public static IAssert<T> IsTrue<T>(this IAssertMember<T, bool?> property)
+        public static IAssert<T> IsTrue<T>(this IAssertMember<T, bool?> member)
         {
-            return property.SetAssertion(new NullableAssertionAdapter<bool>(new IsTrueAssertion()));
+            return member.SetAssertion(new NullableAssertionAdapter<bool>(new IsTrueAssertion()));
         }
 
-        public static IAssert<T> IsFalse<T>(this IAssertMember<T, bool?> property)
+        public static IAssert<T> IsFalse<T>(this IAssertMember<T, bool?> member)
         {
-            return property.SetAssertion(new NullableAssertionAdapter<bool>(new IsFalseAssertion()));
+            return member.SetAssertion(new NullableAssertionAdapter<bool>(new IsFalseAssertion()));
         }
     }
 }