diff --git a/xUnitStudy.Model/xUnitStudy.Model.csproj b/xUnitStudy.Model/xUnitStudy.Model.csproj
index 6fdccdd..d6a6233 100644
--- a/xUnitStudy.Model/xUnitStudy.Model.csproj
+++ b/xUnitStudy.Model/xUnitStudy.Model.csproj
@@ -45,6 +45,7 @@
   <ItemGroup>
     <Compile Include="Student.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="xUnitStudy\AssertEqualDemo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/xUnitStudy.Model/xUnitStudy/AssertEqualDemo.cs b/xUnitStudy.Model/xUnitStudy/AssertEqualDemo.cs
new file mode 100644
index 0000000..bce71cf
--- /dev/null
+++ b/xUnitStudy.Model/xUnitStudy/AssertEqualDemo.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace xUnitStudy.Model
+{
+    public class AssertEqualDemo : IEqualityComparer<AssertEqualDemo>
+    {
+        public int Id { get; set; }
+
+        public string Name { get; set; }
+
+        public bool Equals(AssertEqualDemo x, AssertEqualDemo y)
+        {
+            return x.Id == y.Id;
+        }
+
+        public int GetHashCode(AssertEqualDemo obj)
+        {
+            return Id;
+        }
+    }
+}
diff --git a/xUnitStudy.WebApi.Test/UseXUnitAssertTest.cs b/xUnitStudy.WebApi.Test/UseXUnitAssertTest.cs
index 6ba1cb6..b384986 100644
--- a/xUnitStudy.WebApi.Test/UseXUnitAssertTest.cs
+++ b/xUnitStudy.WebApi.Test/UseXUnitAssertTest.cs
@@ -4,25 +4,284 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using xUnitStudy.Model;
 
 namespace xUnitStudy.WebApi.Test
 {
-
-    public class UseXUnitAssertTest:IDisposable
+    [Trait("测试断言分组", "默认组")]
+    public class UseXUnitAssertTest : IDisposable
     {
         public UseXUnitAssertTest()
         {
 
         }
-        public void Dispose()
+
+        [Fact]
+        public void Equal_String_Test()
+        {
+            Assert.Equal("ping", "ping");
+        }
+
+        [Fact]
+        public void NotEqual_String_Test()
+        {
+            Assert.NotEqual("ping", "ack");
+        }
+
+        /// <summary>
+        /// 断言 string 相等
+        /// 设置大小写、行尾符、空白符号 比较选项
+        /// </summary>
+        [Fact]
+        public void Equal_String_Ignore_Test()
+        {
+            //ignoreCase:忽略字符大小写差异.如果为true,比较时忽略字符大小写
+            Assert.Equal("ABcdEF", "abcdef", ignoreCase: true);
+
+            //ignoreLineEndingDifferences：忽略行尾结束符差异。设置为true，则将\rn、\r和\n视为等效。
+            Assert.Equal("One line\r\n", "one line\n", ignoreCase: true, ignoreLineEndingDifferences: true);
+
+            //ignoreWhiteSpaceDifferences：忽略"空白"(空格、Tab)差异。设置为true，则将空格和制表符（以任何非零量）视为等效。
+            Assert.Equal("One line\r", "one    line\n", ignoreCase: true, ignoreLineEndingDifferences: true, ignoreWhiteSpaceDifferences: true);
+        }
+
+        [Fact]
+        public void Equal_Double_Test()
+        {
+            //注意：先舍入，然后再比较
+            //舍入规则：四舍五入
+            //精度范围[0,15]位小数
+
+            Assert.Equal(1.14d, 1.11d, precision: 1);
+            Assert.Equal(1.15d, 1.19d, precision: 1);
+
+            Assert //1.14d 约等于1.1 而1.15d 约等于1.2 所以不相等
+                  .NotEqual(1.14d, 1.15d, precision: 1);
+
+            //四舍五入到2位小数精度，相等
+            Assert.Equal(2.123d, 2.124d, 2);
+
+            //四舍五入到3位小数精度，相等
+            Assert.Equal(3.1234d, 3.1231d, 3);
+
+            //四舍五入到4位小数精度，不等
+            Assert.NotEqual(3.12345d, 3.12349d, 4);
+
+            //四舍五入到整数，相等
+            Assert.Equal(15d, 15.111d, precision: 0);
+
+            //没有小数位，四舍五入到整数
+            Assert.Equal(15d, 15d, precision: 0);
+        }
+
+        [Fact]
+        public void NotEqual_Double_Test()
+        {
+            //注意：先舍入，然后再比较
+            //舍入规则：四舍五入
+            //精度范围[0,15]位小数
+
+            Assert //1.14d 约等于1.1 而1.15d 约等于1.2 所以不相等
+                  .NotEqual(1.14d, 1.15d, precision: 1);
+
+            //舍入到2位小数精度，相等
+            Assert.NotEqual(2.124d, 2.126d, 2);
+
+            //舍入到3位小数精度，相等
+            Assert.NotEqual(3.1234d, 3.1239d, 3);
+
+            //舍入到4位小数精度，不等
+            Assert.NotEqual(3.12346d, 3.12341d, 4);
+
+            //舍入到整数，相等
+            Assert.NotEqual(16d, 15.111d, precision: 0);
+
+            //没有小数位，舍入到整数
+            Assert.NotEqual(16d, 160d, precision: 0);
+        }
+
+        [Fact]
+        public void Equal_Decimal_Test()
+        {
+            //注意：先舍入，然后再比较
+            //舍入规则：四舍五入
+            //精度范围[0,15]位小数
+
+            Assert.Equal(1.14M, 1.11M, precision: 1);
+            Assert.Equal(1.15M, 1.19M, precision: 1);
+
+            Assert //1.14M 约等于1.1 而1.15M 约等于1.2 所以不相等
+                  .NotEqual(1.14M, 1.15M, precision: 1);
+
+            //四舍五入到2位小数精度，相等
+            Assert.Equal(2.123M, 2.124M, 2);
+
+            //四舍五入到3位小数精度，相等
+            Assert.Equal(3.1234M, 3.1231M, 3);
+
+            //四舍五入到4位小数精度，不等
+            Assert.NotEqual(3.12345M, 3.12349M, 4);
+
+            //四舍五入到整数，相等
+            Assert.Equal(15M, 15.111M, precision: 0);
+
+            //没有小数位，四舍五入到整数
+            Assert.Equal(15M, 15M, precision: 0);
+        }
+
+        [Fact]
+        public void NotEqual_Decimal_Test()
+        {
+            //注意：先舍入，然后再比较
+            //舍入规则：四舍五入
+            //精度范围[0,15]位小数
+
+            Assert //1.14M 约等于1.1 而1.15M 约等于1.2 所以不相等
+                  .NotEqual(1.14M, 1.15M, precision: 1);
+
+            //四舍五入到2位小数精度，不等
+            Assert.NotEqual(2.123M, 2.129M, 2);
+
+            //四舍五入到3位小数精度，不等
+            Assert.NotEqual(3.1234M, 3.1236M, 3);
+
+            //四舍五入到4位小数精度，不等
+            Assert.NotEqual(3.12345M, 3.12349M, 4);
+
+            //四舍五入到整数，不等
+            Assert.NotEqual(15M, 15.501M, precision: 0);
+
+            //没有小数位，四舍五入到整数
+            Assert.NotEqual(29M, 15M, precision: 0);
+        }
+
+        [Fact]
+        public void Equal_Datetime_Test()
         {
-             
+            Assert.Equal(DateTime.Now, DateTime.Now.AddSeconds(1), TimeSpan.FromSeconds(2));
+            Assert.Equal(DateTime.Now, DateTime.Now.AddMinutes(1), TimeSpan.FromMinutes(2));
         }
 
+        /// <summary>
+        /// Equal 泛型版本
+        /// 泛型版基本上都有简化写法
+        /// </summary>
         [Fact]
-        public void Test()
+        public void Equal_GenericT_Test()
         {
-            
+            //形如：Assert.Equal<T>(Expected T, Actual T);
+            //常见类型都可以简化，或是有更好的非泛型版，此时，一般用非泛型版
+
+            Assert.Equal<string>("ping", "ping");
+            Assert  //基本使用非泛型版本
+                   .Equal("ping", "ping");
+
+            Assert.Equal<int>(3, 3);
+            Assert //简化为
+                   .Equal(3, 3);
+
+            Assert.Equal<long>(3, 3);
+            Assert //简化为
+                   .Equal(3L, 3L);
+
+            Assert.Equal<double>(5.5d, 5.5d);
+            Assert //简化为
+                   .Equal(5.5d, 5.5d);
+
+            Assert.Equal<decimal>(5.5M, 5.5M);
+            Assert //简化为
+                   .Equal(5.5M, 5.5M);
+
+            Assert.Equal<DateTime>(DateTime.Now.Date, DateTime.Now.Date);
+            Assert //简化为
+                   .Equal(DateTime.Now.Date, DateTime.Now.Date);
+
+            //类或其它自定义结构比较，可以使用
+
+            var obj = new object();
+            Assert.Equal<object>(obj, obj);
+            Assert //简化为
+                   .Equal(obj, obj);
+        }
+
+        /// <summary>
+        /// Equal 实现了IEqualityComparer接口的泛型版本
+        /// </summary>
+        [Fact]
+        public void Equal_Generic_IEqualityComparer_Test()
+        {
+            //形如：Assert.Equal<T>(Expected T, Actual T,IEqualityComparer comparer);
+            //实现 IEqualityComparer 接口
+
+            var expected = new AssertEqualDemo() { Id = 1, Name = "zhansan" };
+            var actual = new AssertEqualDemo() { Id = 1, Name = "lisi" };
+
+            //实现 IEqualityComparer 接口的，可以是被比较对象自己实现接口，也可以是单独的类。
+            var comparer = new AssertEqualDemo();
+
+            Assert.Equal<AssertEqualDemo>(expected, actual, comparer);
+            Assert.//可以简写为
+                Equal(expected, actual, comparer);
+
+            //id不一样，则不相等
+            expected.Id = 3;
+            Assert.NotEqual(expected, actual, comparer);
+        }
+
+        /// <summary>
+        /// 实现IEnumerable接口对象的 Equal比较
+        /// </summary>
+        [Fact]
+        public void Equal_Generic_IEnumerable_Test()
+        {
+            //对实现IEnumerable接口的对象进行 Equal比较
+            //形如：Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual)；
+
+            List<string> expected = new List<string>() {"first","second" };
+            List<string> actual = new List<string>() {"first","second" };
+
+            Assert.Equal<List<string>>(expected, actual);
+            Assert.//简写为
+                 Equal(expected, actual);
+         }
+
+        /// <summary>
+        /// 实现IEnumerable接口对象的 Equal 比较
+        /// 传入实现IEqualityComparer接口的比较器
+        /// </summary>
+        [Fact]
+        public void Equal_Generic_IEnumerable_IEqualityComparer_Test()
+        {
+            //对实现IEnumerable接口的对象进行 Equal比较
+            //形如：Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual，IEqualityComparer comparer)
+            //传入实现了 IEqualityComparer 接口的比较参数
+
+            var expected = new List<AssertEqualDemo>()
+            {
+                new AssertEqualDemo() { Id = 1, Name = "zhansan" },
+                new AssertEqualDemo() { Id = 2, Name = "lis" },
+            };
+            var actual = new List<AssertEqualDemo>()
+            {
+                new AssertEqualDemo() { Id = 1, Name = "wangwu" },
+                new AssertEqualDemo() { Id = 2, Name = "zhaoliu" },
+            };
+
+            //实现 IEqualityComparer 接口的，可以是被比较对象自己实现接口，也可以是单独的类。
+            var comparer = new AssertEqualDemo();
+
+            Assert.Equal<AssertEqualDemo>(expected, actual, comparer);
+            Assert.//可以简写为
+                Equal(expected, actual, comparer);
+
+            //id不一样，则不相等
+            expected[0].Id = 100;
+            Assert.NotEqual(expected, actual, comparer);
+        }
+
+        public void Dispose()
+        {
+
         }
     }
 }