using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
using xUnitStudy.Model;

namespace xUnitStudy.WebApi.Test
{
    /// <summary>
    /// https://xunit.github.io/docs/comparisons
    /// </summary>
    [Trait("测试断言分组", "默认组")]
    public class UseAssertTest : IDisposable
    {
        #region 准备
        public UseAssertTest()
        {

        }
        #endregion

        #region Equal
        [Fact]
        public void Equal_String_Test()
        {
            Assert.Equal("ping", "ping");
        }

        /// <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 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 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 Equal_Generic_T_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>(3L, 3L);
            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);
        }
        #endregion

        #region NotEqual
        [Fact]
        public void NotEqual_String_Test()
        {
            Assert.NotEqual("ping", "ack");
        }

        [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 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 NotEqual_Generic_T_Test()
        {
            //形如：Assert.NotEqual<T>(Expected T, Actual T);

            Assert.NotEqual<string>("ping", "ack");
            Assert  //基本使用非泛型版本
                   .NotEqual("ping", "ack");

            Assert.NotEqual<int>(3, 4);
            Assert //简化为
                   .NotEqual(3, 4);

            Assert.NotEqual<long>(3L, 4L);
            Assert //简化为
                   .NotEqual(3L, 4L);

            Assert.NotEqual<double>(5.5d, 6.5d);
            Assert //简化为
                   .NotEqual(5.5d, 6.5d);

            Assert.NotEqual<decimal>(5.5M, 5.6M);
            Assert //简化为
                   .NotEqual(5.5M, 6.5M);

            Assert.NotEqual<DateTime>(DateTime.Now.Date, DateTime.Now.Date.AddDays(1));
            Assert //简化为
                   .NotEqual(DateTime.Now.Date, DateTime.Now.Date.AddDays(1));

            //类或其它自定义结构比较，可以使用

            var obj = new object();
            var obj2 = new object();
            Assert.NotEqual<object>(obj, obj2);
            Assert //简化为
                   .NotEqual(obj, obj2);
        }

        [Fact]
        public void NotEqual_Generic_IEqualityComparer_Test()
        {
            //形如：Assert.NotEqual<T>(Expected T, Actual T,IEqualityComparer comparer);
            //实现 IEqualityComparer 接口

            var expected = new AssertEqualDemo() { Id = 1, Name = "zhansan" };
            var actual = new AssertEqualDemo() { Id = 1, Name = "lishi" };

            //实现 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);
        }

        [Fact]
        public void NotEqual_Generic_IEnumerable_Test()
        {
            //对实现IEnumerable接口的对象进行 Equal比较
            //形如：NotEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual)

            List<string> expected = new List<string>() { "first", "second", "third" };
            List<string> actual = new List<string>() { "first", "second" };

            Assert.NotEqual<List<string>>(expected, actual);
            Assert.//简写为
                  NotEqual(expected, actual);
        }

        [Fact]
        public void NotEqual_Generic_IEnumerable_IEqualityComparer_Test()
        {
            //对实现IEnumerable接口的对象进行 Equal比较
            //形如：NotEqual<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);
        }
        #endregion

        #region StrictEqual
        [Fact]
        public void StrictEqual_Test()
        {
            //使用类型的默认比较器验证两个对象是否严格相等,用法类似Equal<T>
            //不支持自定义IEqualityComparer<T>
            Assert.StrictEqual<decimal>(1L, 1m);


            Person person1 = new Person() { Id = 2 };
            Person person2 = new Person() { Id = 2 };

            Person person3 = new Person() { Id = 1 };
            IPerson person4 = person3;

            Assert.StrictEqual(person3, person4);
        }

        [Fact]
        public void NotStrictEqual_Test()
        {
            //使用类型的默认比较器验证两个对象是否严格相等,用法类似NotEqual<T>
            //不支持自定义IEqualityComparer<T>
            Assert.NotStrictEqual<decimal>(2.55M, 3.55M);


            Person person1 = new Person() { Id = 2 };
            Person person2 = new Person() { Id = 2 };

            Person person3 = new Person() { Id = 1 };
            IPerson person4 = person1;

            Assert.NotStrictEqual(person1, person2);
        }
        #endregion

        #region Same
        [Fact]
        public void Same_String_Test()
        {
            //验证两个引用类型的对象，是同一个实例
            //注意：必须是引用类型，不能是值类型

            //特别注明：sting类型，虽然是引用类型，但是比较特殊。采取复制策略，相同值可以(不严谨的说法)认为引用相同
            string expected = "hell,world!";
            string actual = "hell,world!";
            Assert.Same(expected, actual);

            string expected2 = "hell,world!";
            string actual2 = expected2;
            Assert.Same(expected2, actual2);
        }

        [Fact]
        public void Same_Object_Test()
        {
            object obj1 = new object();
            object obj2 = new object();
            object obj3 = obj1;
            object obj4 = obj2;

            Assert.Same(obj1, obj3);
            Assert.Same(obj2, obj4);
        }

        [Fact]
        public void Same_Class_Test()
        {
            object obj1 = new AssertEqualDemo() { Id = 1, Name = "zhangsan" };
            object obj2 = new AssertEqualDemo() { Id = 1, Name = "zhangsan" };
            object obj3 = obj1;
            object obj4 = obj2;

            Assert.Same(obj1, obj3);
            Assert.Same(obj2, obj4);
        }
        #endregion

        #region NotSame
        [Fact]
        public void NotSame_String_Test()
        {
            //验证两个引用类型的对象，是同一个实例
            //注意：必须是引用类型，不能是值类型

            //特别注明：sting类型，虽然是引用类型，但是比较特殊。采取复制策略，相同值可以(不严谨的说法)认为引用相同
            string expected = "hell,world!";
            string actual = "I am chinese!";
            Assert.NotSame(expected, actual);

            Assert.NotSame("abc", "xyz");
        }

        [Fact]
        public void NotSame_Object_Test()
        {
            object obj1 = new object();
            object obj2 = new object();
            Object obj3 = obj2;

            Assert.NotSame(obj1, obj2);
            Assert.NotSame(obj1, obj3);
            Assert.NotSame(new object(), new object());
        }

        [Fact]
        public void NotSame_Class_Test()
        {
            object obj1 = new AssertEqualDemo() { Id = 1, Name = "zhangsan" };
            object obj2 = new AssertEqualDemo() { Id = 1, Name = "zhangsan" };
            object obj3 = obj1;
            object obj4 = obj2;

            Assert.NotSame(obj1, obj2);
            Assert.NotSame(obj3, obj4);
            Assert.NotSame(obj1, obj4);
            Assert.NotSame(obj2, obj3);
        }
        #endregion

        #region True
        [Fact]
        public void True_Condition_Test()
        {
            Assert.True(true);
            Assert.True("ping" == "ping");
            Assert.True(2 == 1 + 1);
            Assert.True("ping" == "ping" && 2 == 1 + 1);
        }

        [Fact]
        public void True_Nullable_Test()
        {
            bool? expected = null;
            Assert.True(!expected.HasValue);

            int? expected2 = null;
            Assert.True(expected2 == null);
            expected2 = 2;
            Assert.True(2 == expected2.Value);
        }

        [Fact]
        public void True_Message_Test()
        {
            Assert.True(true, "userMessage");
            Assert.True("ping" == "ping", "userMessage");
            Assert.True(2 == 1 + 1, "userMessage");

            int? nullableInt = null;
            Assert.True(null == nullableInt, "userMessage");
        }
        #endregion

        #region False
        [Fact]
        public void False_Condition_Test()
        {
            Assert.False(false);
            Assert.False("ping" == "ack");
            Assert.False(3 == 1 + 1);
            Assert.False("ping" == "ping" && 3 == 1 + 1);
        }

        [Fact]
        public void False_Nullable_Test()
        {
            bool? expected = null;
            Assert.False(expected.HasValue);

            int? expected2 = 3;
            Assert.False(expected2 == null);
            Assert.False(4 == expected2.Value);
        }

        [Fact]
        public void False_Message_Test()
        {
            Assert.False(false, "userMessage");
            Assert.False("ping" == "ack", "userMessage");
            Assert.False(2 == 1 + 3, "userMessage");

            int? nullableInt = 3;
            Assert.False(null == nullableInt, "userMessage");
        }
        #endregion

        #region True|False 可替代断言
        /// <summary>
        /// 直接设置验证通过
        /// </summary>
        [Fact]
        public void Pass_Test()
        {
            Assert.True(true, "用True断言替代");
        }

        [Fact]
        public void Fail_Test()
        {
            //Assert.True(false, "用True断言替代");
        }

        /// <summary>
        /// 大于
        /// </summary>
        [Fact]
        public void GreaterThan_Test()
        {
            Assert //大于比较，用True(x > y) 替代
                  .True(2 > 1);

            int max = 5;
            int min = 2;

            Assert.True(max > min);
        }

        /// <summary>
        /// 小于
        /// </summary>
        [Fact]
        public void LessThan_Test()
        {
            Assert //小于比较，用True(x < y) 替代
                  .True(2 < 3);

            int max = 5;
            int min = 2;

            Assert.True(min < max);
        }

        [Fact]
        public void NaN_Test()
        {
            //NaN=Not a Number,是否不为数字

            //说明：在浮点数计算中，0除以0将得到NaN，正数除以0将得到PositiveInfinity,负数除以0将得到NegativeInfinity。
            //浮点数运算从不引发异常

            Assert.True(double.IsNaN(0 / 0d));

            Assert.True(double.IsPositiveInfinity(1 / 0d));

            Assert.True(double.IsNegativeInfinity(-1 / 0d));

        }
        #endregion

        #region Null|Empty
        [Fact]
        public void Empty_Test()
        {
            List<string> expected = new List<string>();

            Assert //针对于集合，为Empty,即是集合中元素的个数为0。但集合为空引用null值时将引发异常
                  .Empty(expected);
        }

        [Fact]
        public void NotEmpty_Test()
        {
            List<string> expected = new List<string>() { "first", "second" };

            Assert //针对于集合，不为Empty,即是集合中元素的个数大于0。集合为空引用null值时将引发异常
                  .NotEmpty(expected);
        }

        [Fact]
        public void Null_Test()
        {
            Assert //null值，空引用
                  .Null(null);

            string exp = null;
            Assert.Null(exp);

            List<string> list = null;
            Assert.Null(list);
        }

        [Fact]
        public void NotNull_Test()
        {
            Assert //null值，空引用
                  .NotNull(new object());

            Assert.NotNull("");
            Assert.NotNull(string.Empty);

            Assert.NotNull(new List<string>());

            Assert.NotNull(new List<string>() { "first", "second" });
        }
        #endregion

        #region Type|Assignable
        [Fact]
        public void IsType_Test()
        {
            //此形式，只在泛型不能使用时，才使用；应优先使用泛型版。
            Assert.IsType(typeof(string), "aaaa");

            //泛型版
            Assert.IsType<string>("hell,world!");
            Assert.IsType<int>(2);
            Assert.IsType<long>(2L);
            Assert.IsType<double>(2d);
            Assert.IsType<decimal>(2M);
            Assert.IsType<DateTime>(DateTime.Now);
            Assert.IsType<AssertEqualDemo>(new AssertEqualDemo());
        }

        [Fact]
        public void IsNotType_Test()
        {
            //此形式，只在泛型不能使用时，才使用；应优先使用泛型版。
            Assert.IsNotType(typeof(string), 22);

            //泛型版
            Assert.IsNotType<string>(2);
            Assert.IsNotType<int>("hello");
            Assert.IsNotType<long>("521");
            Assert.IsNotType<double>(new object());
            Assert.IsNotType<decimal>("55555");
            Assert.IsNotType<DateTime>("2018-08-03");
            Assert.IsNotType<AssertEqualDemo>(new object());
        }

        [Fact]
        public void IsAssignableFrom_Test()
        {
            //可以从指定的类型派生
            Assert.IsAssignableFrom<object>(22);


            Person person = new Person() { Id = 1, FirstName = "first", LastName = "last" };
            Assert. //接口派生
                    IsAssignableFrom<IPerson>(person);

            Teacher teacher = new Teacher() { Id = 1, FirstName = "first", LastName = "last", Grade = 2 };
            Assert. //类继承
                    IsAssignableFrom<Person>(teacher);

            Assert //接口派生
                  .IsAssignableFrom<IPerson>(teacher);


            Assert //万源归宗
                  .IsAssignableFrom<object>(teacher);
        }

        /// <summary>
        /// 断言非派生、继承关系
        /// Assert.False(obj is Type)替代
        /// </summary>
        [Fact]
        public void IsNotAssignableFrom_Test()
        {
            // Assert.False(obj is Type) 替代

            //可以从指定的类型派生
            Assert.False(88 is String);
            Assert.False(new object() is int);

            Person person = new Person() { Id = 1, FirstName = "first", LastName = "last" };
            Teacher teacher = new Teacher() { Id = 2, FirstName = "first", LastName = "last", Grade = 2 };
            IPerson person2 = new Person() { Id = 3, FirstName = "first", LastName = "last" };

            Assert.False(person is Teacher);
            Assert.False(person2 is Teacher);
        }
        #endregion

        #region Contains For String
        [Fact]
        public void Contains_String_Test()
        {
            Assert.Contains("hello", "hello,world.");
            Assert.Contains("llo", "hello,world.");
            Assert.Contains("world", "hello,world.");
        }

        [Fact]
        public void Contains_String_Comparison_Ordinal_Test()
        {
            //StringComparison.Ordinal 二进制比较：最快,最严格
            //进行非语言(non-linguistic)上的比较,对两个字符串进行byte级别的比较,比较结果严格而准确,性能非常好。
            Assert.Contains("hello", "hello,world", StringComparison.Ordinal);
            Assert.Contains("llo", "hello,world", StringComparison.Ordinal);
            Assert.Contains("orld", "hello,world", StringComparison.Ordinal);
        }

        [Fact]
        public void Contains_String_Comparison_OrdinalIgnoreCase_Test()
        {
            //StringComparison.OrdinalIgnoreCase与StringComparison.Ordinal相同，只是不区分大小写
            Assert.Contains("hello", "Hello,World", StringComparison.OrdinalIgnoreCase);
            Assert.Contains("llo", "Hello,World", StringComparison.OrdinalIgnoreCase);
            Assert.Contains("orld", "Hello,World", StringComparison.OrdinalIgnoreCase);
        }

        [Fact]
        public void Contains_String_Comparison_CurrentCulture_Test()
        {
            //StringComparison.CurrentCulture 默认的比较方式：使用区域敏感排序规则和当前区域比较字符串
            //在当前的区域信息下进行比较,这是String.Compare在没有指定StringComparison的时候默认的比较方式

            Assert.Contains("", "", StringComparison.CurrentCulture);
            Assert.Contains("orl", "hello,world", StringComparison.CurrentCulture);

            //设置特定区域
            string s1 = "encyclopædia";
            string s2 = "encyclopaedia";

            //当前的区域信息是美国:s1与s2是相等的。
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            Assert.Contains(s1, s2, StringComparison.CurrentCulture);

            //当前的区域信息是se-SE，s1与s2是相等的
            Thread.CurrentThread.CurrentCulture = new CultureInfo("se-SE");
            Assert.DoesNotContain(s1, s2, StringComparison.CurrentCulture);
        }

        [Fact]
        public void Contains_String_Comparison_CurrentCultureIgnoreCase_Test()
        {
            //用法同：StringComparison.CurrentCulture，只是不区分大小写

            Assert.Contains("A", "aBB", StringComparison.CurrentCultureIgnoreCase);
            Assert.Contains("worl", "Hello,World", StringComparison.CurrentCultureIgnoreCase);

            //设置特定区域
            string s1 = "Encyclopædia";
            string s2 = "encyclopaediA";

            //当前的区域信息是美国:s1与s2是相等的。
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            Assert.Contains(s1, s2, StringComparison.CurrentCultureIgnoreCase);

            //当前的区域信息是se-SE，s1与s2是相等的
            Thread.CurrentThread.CurrentCulture = new CultureInfo("se-SE");
            Assert.DoesNotContain(s1, s2, StringComparison.CurrentCultureIgnoreCase);
        }

        [Fact]
        public void Contains_String_Comparison_InvariantCulture_Test()
        {
            //StringComparison.InvariantCulture：使用区域敏感排序规则和固定区域比较字符串
            //在任何系统中(不同的culture)比较都将得到相同的结果,他是使用CultureInfo.InvariantCulture的静态成员CompareInfo来进行比较操作的.
            //StringComparison.InvariantCultureIgnoreCase与StringComparison.InvariantCulture，只是忽略大小写

            Assert.Contains("ping", "ping", StringComparison.InvariantCulture);
            Assert.Contains("p", "ping", StringComparison.InvariantCulture);
            Assert.Contains("in", "ping", StringComparison.InvariantCulture);
            Assert.Contains("ing", "ping", StringComparison.InvariantCulture);

            //区域无关性
            string s1 = "encyclopædia";
            string s2 = "encyclopaedia";

            Assert.Contains(s1, s2, StringComparison.InvariantCulture);

            //设置区为美国：无效
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            Assert.Contains(s1, s2, StringComparison.InvariantCulture);

            //设置区为se-SE：无效 
            Thread.CurrentThread.CurrentCulture = new CultureInfo("se-SE");
            Assert.Contains(s1, s2, StringComparison.InvariantCulture);
        }

        [Fact]
        public void Contains_String_Comparison_InvariantCultureIgnoreCase_Test()
        {
            //StringComparison.InvariantCultureIgnoreCase与StringComparison.InvariantCulture，只是忽略大小写

            Assert.Contains("ping", "PinG", StringComparison.InvariantCultureIgnoreCase);
            Assert.Contains("p", "PinG", StringComparison.InvariantCultureIgnoreCase);
            Assert.Contains("in", "PinG", StringComparison.InvariantCultureIgnoreCase);
            Assert.Contains("ing", "PinG", StringComparison.InvariantCultureIgnoreCase);

            //区域无关性
            string s1 = "Encyclopædia";
            string s2 = "encyclopaediA";

            Assert.Contains(s1, s2, StringComparison.InvariantCultureIgnoreCase);

            //设置区为美国：无效
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            Assert.Contains(s1, s2, StringComparison.InvariantCultureIgnoreCase);

            //设置区为se-SE：无效 
            Thread.CurrentThread.CurrentCulture = new CultureInfo("se-SE");
            Assert.Contains(s1, s2, StringComparison.InvariantCultureIgnoreCase);
        }
        #endregion

        #region Contains Collection
        [Fact]
        public void Contains_Generic_In_IEnumerable_Test()
        {
            //字符数组
            var stringArray = new List<string>() { "first", "second", "third", "four" };
            Assert.Contains<string>("first", stringArray);
            Assert //可以简化写法
                   .Contains("second", stringArray);

            //int 数组
            var intArray = new List<int>() { 1, 2, 3, 4, 5 };
            Assert.Contains<int>(2, intArray);
            Assert //可以简化写法
                   .Contains(3, intArray);

            //类组

            //内部各项都相等，但实例(引用)不同，则不包含
            var classArray = new List<Person>()
            {
                new Person(){ Id=1, FirstName="first1", LastName="last1"},
                new Person(){ Id=2, FirstName="first2", LastName="last2"},
                new Person(){ Id=3, FirstName="first3", LastName="last3"},
            };

            Person person1 = new Person() { Id = 1, FirstName = "first1", LastName = "last1" };
            Person person2 = new Person() { Id = 2, FirstName = "first2", LastName = "last2" };
            Person person3 = new Person() { Id = 3, FirstName = "first3", LastName = "last3" };

            Assert.DoesNotContain<Person>(person1, classArray);
            Assert //简化写法
                   .DoesNotContain(person2, classArray);
            Assert //简化写法
                   .DoesNotContain(person3, classArray);

            //相同的引用才包含
            classArray.Add(person1);
            classArray.Add(person2);
            classArray.Add(person3);

            Assert.Contains(person1, classArray);
            Assert.Contains(person2, classArray);
            Assert.Contains(person3, classArray);

        }

        [Fact]
        public void Contains_Generic_In_IEnumerable_IEqualityComparer_Test()
        {
            //以 IEqualityComparer 比较器为断言依据

            Person person1 = new Person() { Id = 1, FirstName = "first1", LastName = "last1" };
            Person person2 = new Person() { Id = 2, FirstName = "first2", LastName = "last2" };
            Person person3 = new Person() { Id = 3, FirstName = "first3", LastName = "last3" };

            var classArray = new List<Person>()
            {
                new Person() { Id = 1, FirstName = "ab", LastName = "cd" },
                new Person() { Id = 2, FirstName = "ef", LastName = "g" },
                new Person() { Id = 3, FirstName = "s", LastName = "b" },
            };

            //自定义比较器
            IEqualityComparer<Person> equalityComparer = new Person();

            Assert.Contains(person1, classArray, equalityComparer);
            Assert.Contains(person2, classArray, equalityComparer);
            Assert.Contains(person3, classArray, equalityComparer);
        }

        [Fact]
        public void Contains_Generic_IEnumerable_Filter_Test()
        {
            Person person1 = new Person() { Id = 1, FirstName = "first1", LastName = "last1" };
            Person person2 = new Person() { Id = 2, FirstName = "first2", LastName = "last2" };
            Person person3 = new Person() { Id = 3, FirstName = "first3", LastName = "last3" };

            var classArray = new List<Person>()
            {
                person1,
                person2,
                person3,
            };

            //Predicate<T> 委托（入参T,返回 bool），作为筛选条件
            Assert.Contains<Person>(classArray, person => person.Id == 1);
            Assert //简写为
                   .Contains<Person>(classArray, person => person.FirstName == "first1");
            Assert //简写为
                   .Contains<Person>(classArray, person => person.Id == 3 && person.LastName == "last3");
        }

        [Fact]
        public void Contains_Generic_In_IDictionary_Test()
        {
            //字符串
            KeyValuePair<string, string> sring_kv1 = new KeyValuePair<string, string>("key1", "first");
            KeyValuePair<string, string> string_kv2 = new KeyValuePair<string, string>("key2", "second");
            KeyValuePair<string, string> string_kv3 = new KeyValuePair<string, string>("key3", "third");

            IDictionary<string, string> stringDic = new Dictionary<string, string>();
            stringDic.Add("key1", "first");
            stringDic.Add("key2", "second");
            stringDic.Add("key3", "third");

            Assert.Contains<string, string>("key1", stringDic);
            Assert.Contains<KeyValuePair<string, string>>(sring_kv1, stringDic);

            //数字
            KeyValuePair<string, int> int_kv1 = new KeyValuePair<string, int>("key1", 1);
            KeyValuePair<string, int> int_kv2 = new KeyValuePair<string, int>("key2", 2);
            KeyValuePair<string, int> int_kv3 = new KeyValuePair<string, int>("key3", 3);

            IDictionary<string, int> intDic = new Dictionary<string, int>();
            intDic.Add("key1", 1);
            intDic.Add("key2", 2);
            intDic.Add("key3", 3);

            Assert.Contains<string, int>("key1", intDic);
            Assert.Contains<KeyValuePair<string, int>>(int_kv1, intDic);

            //类
            Person person1 = new Person() { Id = 1, FirstName = "first1", LastName = "last1" };
            Person person2 = new Person() { Id = 2, FirstName = "first2", LastName = "last2" };
            Person person3 = new Person() { Id = 3, FirstName = "first3", LastName = "last3" };

            KeyValuePair<string, Person> class_kv1 = new KeyValuePair<string, Person>("key1", person1);
            KeyValuePair<string, Person> class_kv2 = new KeyValuePair<string, Person>("key2", person2);
            KeyValuePair<string, Person> class_kv3 = new KeyValuePair<string, Person>("key3", person3);

            IDictionary<string, Person> classDic = new Dictionary<string, Person>();
            classDic.Add("key1", person1);
            classDic.Add("key2", person2);
            classDic.Add("key3", person3);

            Assert.Contains<string, Person>("key1", classDic);
            Assert.Contains<KeyValuePair<string, Person>>(class_kv1, classDic);
            Assert.Contains(class_kv2, classDic);
            Assert.Contains(class_kv3, classDic);
        }

        [Fact]
        public void Contains_Generic_In_IReadOnlyDictionary_Test()
        {
            //类似 IDictionary

            //字符串
            KeyValuePair<string, string> sring_kv1 = new KeyValuePair<string, string>("key1", "first");
            KeyValuePair<string, string> string_kv2 = new KeyValuePair<string, string>("key2", "second");
            KeyValuePair<string, string> string_kv3 = new KeyValuePair<string, string>("key3", "third");

            IDictionary<string, string> stringDic = new Dictionary<string, string>();
            stringDic.Add("key1", "first");
            stringDic.Add("key2", "second");
            stringDic.Add("key3", "third");

            IReadOnlyDictionary<string, string> stringReadOnlyDic = stringDic as IReadOnlyDictionary<string, string>;

            Assert.Contains<string, string>("key1", stringReadOnlyDic);
            Assert.Contains<KeyValuePair<string, string>>(sring_kv1, stringReadOnlyDic);

            //类
            Person person1 = new Person() { Id = 1, FirstName = "first1", LastName = "last1" };
            Person person2 = new Person() { Id = 2, FirstName = "first2", LastName = "last2" };
            Person person3 = new Person() { Id = 3, FirstName = "first3", LastName = "last3" };

            KeyValuePair<string, Person> class_kv1 = new KeyValuePair<string, Person>("key1", person1);
            KeyValuePair<string, Person> class_kv2 = new KeyValuePair<string, Person>("key2", person2);
            KeyValuePair<string, Person> class_kv3 = new KeyValuePair<string, Person>("key3", person3);

            IDictionary<string, Person> classDic = new Dictionary<string, Person>();
            classDic.Add("key1", person1);
            classDic.Add("key2", person2);
            classDic.Add("key3", person3);

            IReadOnlyDictionary<string, Person> classReadOnlyDic = classDic as IReadOnlyDictionary<string, Person>;

            Assert.Contains<string, Person>("key1", classReadOnlyDic);
            Assert.Contains<KeyValuePair<string, Person>>(class_kv1, classReadOnlyDic);
            Assert.Contains(class_kv2, classReadOnlyDic);
            Assert.Contains(class_kv3, classReadOnlyDic);

        }
        #endregion

        #region DoesNotContain 类似Contain 略过
        #endregion

        #region InRange

        [Fact]
        public void InRange_Test()
        {
            Assert.InRange(5, 1, 10);
            Assert.InRange("b", "a", "d");
        }

        [Fact]
        public void InRange_IComparable_Test()
        {
            IComparer<Person> comparer = new Person();

            Person person1 = new Person() { Id = 1 };
            Person person2 = new Person() { Id = 2 };
            Person person3 = new Person() { Id = 3 };

            Assert.InRange(person2, person1, person3, comparer);
        }

        #endregion

        #region NotInRange
        [Fact]
        public void NotInRange_Test()
        {
            Assert.NotInRange<int>(5, 10, 100);
            Assert.NotInRange(20, 100, 2000);
            Assert.NotInRange("a", "b", "d");
            Assert.NotInRange("z", "b", "d");
        }

        [Fact]
        public void NotInRange_IComparable_Test()
        {
            IComparer<Person> comparer = new Person();

            Person person1 = new Person() { Id = 1 };
            Person person2 = new Person() { Id = 2 };
            Person person3 = new Person() { Id = 3 };

            Assert.NotInRange(person1, person2, person3, comparer);
        }
        #endregion

        #region Throws
        [Fact]
        public void Throws_Func_Test()
        {
            //方法不推荐使用：用泛型版本替代
            var result = Assert.Throws(typeof(ArgumentNullException), () => { ArgumentNullException ex = new ArgumentNullException("userName"); throw ex; return ex; });
        }

        [Fact]
        public void Throws_Action_Test()
        {
            //方法不推荐使用：用泛型版本替代
            var result = Assert.Throws(typeof(FormatException), () => decimal.Parse("abc"));
        }

        [Fact]
        public async Task Throws_Async_Test()
        {
            //方法不推荐使用：用泛型版本替代
            var result = await Assert.ThrowsAsync(typeof(FormatException), () => { return Task.Run(() => { int.Parse("abc"); }); });
        }

        [Fact]
        public void Throws_Generic_Func_Test()
        {
            var result = Assert.Throws<FormatException>(() => ThrowAndReturnFormatException());
        }

        [Fact]
        public void Throws_Generic_Action_Test()
        {
            var result = Assert.Throws<FormatException>(() => ThrowFormatException());
        }

        [Fact]
        public void Throws_Generic_ParamName_Func_Test()
        {
            var paramName = "userName";
            var result = Assert.Throws<ArgumentNullException>(paramName, () => ThrowAndReturnArgumentNullException(paramName));
        }

        [Fact]
        public void Throws_Generic_ParamName_Action_Test()
        {
            var paramName = "userName";
            var result = Assert.Throws<ArgumentNullException>(paramName, () => ThrowArgumentNullException(paramName));
        }

        [Fact]
        public async Task Throws_Generic_Func_Async_Test()
        {
            var reslut = await Assert.ThrowsAsync<FormatException>(() => ThrowAndReturnFormatExceptionAsync());
        }

        [Fact]
        public async Task Throws_Generic_ParamName_Async_Test()
        {
            var paramName = "userName";
            var reslut = await Assert.ThrowsAsync<ArgumentNullException>(paramName, () => ThrowAndReturnArgumentNullExceptionAsync(paramName));
        }

        [Fact]
        public void ThrowsAny_Func_Test()
        {
            var result = Assert.ThrowsAny<FormatException>(() => ThrowAndReturnFormatException());
        }

        /// <summary>
        /// 断言异常或派生类异常
        /// </summary>
        [Fact]
        public void ThrowsAny_Action_Test()
        {
            var result = Assert.ThrowsAny<FormatException>(() => ThrowFormatException());
        }

        [Fact]
        public async Task ThrowsAny_Func_Async_Test()
        {
            var result = await Assert.ThrowsAnyAsync<FormatException>(() => ThrowAndReturnFormatExceptionAsync());
        }

        [Fact]
        public void NotThrow_Exception_Test()
        {
            //2.0及更高版本，移除了 NotThrow断言
            //使用TryCatch替代或自定断言扩展

            Exception exception = null;
            try
            {
                //dosomething
                exception = null;
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            Assert.Null(exception);

        }
        #endregion

        #region Matches
        [Fact]
        public void Matches_String_Test()
        {
            //用户名正则：大小写字线、数字、下划线组成，6-16位长度
            var userNameReg = @"^[a-zA-Z]\w{5,15}$";
            Assert.Matches(userNameReg, "bicijinlian");
            Assert.Matches(userNameReg, "wangerxiao_1981");

            //email正则
            var emailReg = @"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$";
            Assert.Matches(emailReg, "bicijinlian@163.com");
            Assert.Matches(emailReg, "wangerxiao_1981@126.com");
            Assert.Matches(emailReg, "15601716045@126.com");
        }

        [Fact]
        public void DoesNotMatch_String_Test()
        {
            //用户名正则：大小写字线、数字、下划线组成，6-16位长度
            var userNameReg = @"^[a-zA-Z]\w{5,15}$";
            Assert.DoesNotMatch(userNameReg, "abcd0123456789abcdefg");
            Assert.DoesNotMatch(userNameReg, "wang");
            Assert.DoesNotMatch(userNameReg, "bicijinlian$");
            Assert.DoesNotMatch(userNameReg, "wangerxiao_1981@163");

            //email正则
            var emailReg = @"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$";
            Assert.DoesNotMatch(emailReg, "bicijinlian");
            Assert.DoesNotMatch(emailReg, "wangerxiao_1981@126");
            Assert.DoesNotMatch(emailReg, "15601716045126.com");
        }

        [Fact]
        public void Matches_Regex_Test()
        {
            //用户名正则：大小写字线、数字、下划线组成，6-16位长度
            var userNameReg = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z]\w{5,15}$");
            Assert.Matches(userNameReg, "bicijinlian");
            Assert.Matches(userNameReg, "wangerxiao_1981");

            //email正则
            var emailReg = new System.Text.RegularExpressions.Regex(@"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$");
            Assert.Matches(emailReg, "bicijinlian@163.com");
            Assert.Matches(emailReg, "wangerxiao_1981@126.com");
            Assert.Matches(emailReg, "15601716045@126.com");
        }

        [Fact]
        public void DoesNotMatch_Regex_Test()
        {
            //用户名正则：大小写字线、数字、下划线组成，6-16位长度
            var userNameReg = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z]\w{5,15}$");
            Assert.DoesNotMatch(userNameReg, "abcd0123456789abcdefg");
            Assert.DoesNotMatch(userNameReg, "wang");
            Assert.DoesNotMatch(userNameReg, "bicijinlian$");
            Assert.DoesNotMatch(userNameReg, "wangerxiao_1981@163");

            //email正则
            var emailReg = new System.Text.RegularExpressions.Regex(@"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$");
            Assert.DoesNotMatch(emailReg, "bicijinlian");
            Assert.DoesNotMatch(emailReg, "wangerxiao_1981@126");
            Assert.DoesNotMatch(emailReg, "15601716045126.com");
        }
        #endregion

        #region StartWith | EndWith
        [Fact]
        public void StartsWith_Test()
        {
            Assert.StartsWith("Start", "StartAndEnd");
            Assert.StartsWith("start", "StartAndEnd", StringComparison.CurrentCultureIgnoreCase);
        }

        [Fact]
        public void EndsWith_Test()
        {
            Assert.EndsWith("end", "startAndend");
            Assert.EndsWith("end", "StartAndEnd", StringComparison.CurrentCultureIgnoreCase);
        }

        #endregion

        #region Single
        [Fact]
        public void Single_Collection_Test()
        {
            //只有一项的集合

            List<string> stringArray = new List<string>() { "first" };
            Assert.Single(stringArray);

            List<decimal> decimalArray = new List<decimal>() { 5.66M };
            Assert.Single(decimalArray);

            List<Person> classArray = new List<Person>() { new Person() { Id = 2 } };
            Assert.Single(classArray);
        }

        /// <summary>
        /// 集合中，指定项没有重复项
        /// </summary>
        [Fact]
        public void Single_Collection_Expected_Test()
        {
            //集合中，指定的项只有一个，即是指定项在集合中没有重复项
            //不被指定的项，可以有多个

            List<string> stringArray = new List<string>() { "first", "second", "second" };

            Assert //如果换成：List<string> stringArray = new List<string>() { "first","second","first" }
                   //因为"first"有两项，则断言失败
                  .Single(stringArray, "first");

            List<decimal> decimalArray = new List<decimal>() { 5.66M, 7.7M, 8.8M };
            Assert.Single(decimalArray, 5.66M);

            Person person1 = new Person() { Id = 1 };
            Person person2 = new Person() { Id = 2 };
            Person person3 = new Person() { Id = 2 };
            List<Person> classArray = new List<Person>() { person1, person2 };
            Assert.Single(classArray, person1);

            List<Person> classArray2 = new List<Person>() { person1, person2, person3 };
            Assert.True(true, "person2和person3是相同的项，所以 Assert.Single(classArray, person2) 会失败");
        }

        [Fact]
        public void Single_Generic_Test()
        {
            //只有一项的集合(推荐简化写法)

            List<string> stringArray = new List<string>() { "first" };
            Assert.Single<string>(stringArray);

            List<decimal> decimalArray = new List<decimal>() { 5.66M };
            Assert.Single<decimal>(decimalArray);

            List<Person> classArray = new List<Person>() { new Person() { Id = 2 } };
            Assert.Single<Person>(classArray);
        }

        [Fact]
        public void Single_Generic_Predicate_Test()
        {
            //集合中，指定表达式的项只有一个，即是Predicate<>筛选结果在集合中没有重复项
            //不被指定的项，可以有多个

            List<string> stringArray = new List<string>() { "first", "second", "second" };

            Assert //如果换成：List<string> stringArray = new List<string>() { "first","second","first" }
                   //因为"first"有两项，则断言失败
                  .Single<string>(stringArray, s => s.StartsWith("f"));

            List<decimal> decimalArray = new List<decimal>() { 5.66M, 7.7M, 8.8M };
            Assert.Single(decimalArray, d => d > 8);

            Person person1 = new Person() { Id = 1 };
            Person person2 = new Person() { Id = 2 };
            Person person3 = new Person() { Id = 2 };

            List<Person> classArray = new List<Person>() { person1, person2, person3 };

            Assert.Single(classArray, p => p.Id == 1);

            //Assert.Single(classArray, p => p.Id == 2),则失败
        }

        #endregion

        [Fact]
        public void All_Test()
        {
            List<string> items = new List<string>() { "abc", "ac", "ad", "adddeddd" };
            Assert.All<string>(items, f => f.StartsWith("a"));
        }

        /// <summary>
        /// 相当于集合的自定义断言，实用意义不大
        /// (Action<T>参数中自定义代码)
        /// 看源代码，可能是集合类断言的基类
        /// </summary>
        [Fact]
        public void Collection_Test()
        {
            //验证集合是否包含给定元素数量，满足元素检查器提供的条件。

            List<string> list = new List<string>() { "first", "second" };
            //参数Action<T>[] elementInspectors,元素检查器，依次检查每个元素。
            //元素检查器的总数必须与集合中元素的数量完全匹配

            //看源代码：每个Action<T>执行时,均不抛出异常，则断言通过
            Action<string>[] actions = new Action<string>[2]
            {
                new Action<string> (s=> {} ),
                new Action<string> (s=>{}),
            };

            Assert.Collection(list, actions);
        }

        #region ISet(集合)
        /// <summary>
        /// 子集断言
        /// ISet是集合接口：包含不重复元素，实际集合的交、并、子集等运算
        /// 实现了ISet接口的集合：HashSet和SortedSet
        /// </summary>
        [Fact]
        public void Subset_Test()
        {
            //"真实值"是"期望值"的子集

            HashSet<string> hset = new HashSet<string>() { "first", "second", "third" };
            HashSet<string> sub1 = new HashSet<string>() { "first", "second" };
            HashSet<string> sub2 = new HashSet<string>() { "second", "third" };

            //expectedSuperset 期望超集，真实值是子集
            Assert.Subset(expectedSuperset: hset, actual: sub1);
            Assert.Subset(hset, sub2);

            //自己是自己子集
            Assert.Subset(hset, hset);
        }

        /// <summary>
        /// 超集断言
        /// </summary>
        [Fact]
        public void Superset_Test()
        {
            //"真实值"是"期望值"的超集

            HashSet<string> hset = new HashSet<string>() { "first", "second", "third" };
            HashSet<string> sub1 = new HashSet<string>() { "first", "second" };
            HashSet<string> sub2 = new HashSet<string>() { "second", "third" };

            //expectedSuperset 期望超集，真实值是子集
            Assert.Superset(sub1, hset);
            Assert.Superset(sub2, hset);

            //自己是自己子的超集
            Assert.Superset(hset, hset);
        }

        /// <summary>
        /// 真子集断言
        /// </summary>
        [Fact]
        public void ProperSubset_Test()
        {
            //"真实值"是"期望值"的真子集

            HashSet<string> hset = new HashSet<string>() { "first", "second", "third" };
            HashSet<string> sub1 = new HashSet<string>() { "first", "second" };
            HashSet<string> sub2 = new HashSet<string>() { "second", "third" };

            //expectedSuperset 期望超集，真实值是子集
            Assert.ProperSubset(expectedSuperset: hset, actual: sub1);
            Assert.ProperSubset(hset, sub2);

            //自己不是自己真子集
            //Assert.ProperSubset(hset, hset);
        }

        /// <summary>
        /// 真超集断言
        /// </summary>
        [Fact]
        public void ProperSuperset_Test()
        {
            //"真实值"是"期望值"的真超集

            HashSet<string> hset = new HashSet<string>() { "first", "second", "third" };
            HashSet<string> sub1 = new HashSet<string>() { "first", "second" };
            HashSet<string> sub2 = new HashSet<string>() { "second", "third" };

            //expectedSuperset 期望超集，真实值是子集
            Assert.ProperSuperset(sub1, hset);
            Assert.ProperSuperset(sub2, hset);

            //自己不是自己子的真超集
            //Assert.ProperSuperset(hset, hset);
        }
        #endregion

        #region 事件(暂未实现)

        /// <summary>
        /// 属性更改事件
        /// </summary>
        [Fact]
        public void PropertyChanged_Test()
        {

        }

        /// <summary>
        /// 属性更改事件(异步)
        /// </summary>
        [Fact]
        public void PropertyChangedAsync_Test()
        {

        }

        /// <summary>
        /// 断言 特定事件被触发
        /// </summary>
        [Fact]
        public void Raises_Test()
        {

        }

        /// <summary>
        /// 断言 事件或派生事件 被触发
        /// </summary>
        [Fact]
        public void RaisesAny_Test()
        {

        }

        /// <summary>
        /// 断言 特定事件被触发(异步)
        /// </summary>
        [Fact]
        public void RaisesAsync_Test()
        {

        }

        /// <summary>
        /// 断言 事件或派生事件 被触发(异步)
        /// </summary>
        [Fact]
        public void RaisesAnyAsync_Test()
        {

        }
        #endregion

        #region 私有方法

        private void ThrowArgumentNullException(string paramName)
        {
            ArgumentNullException ex = new ArgumentNullException(paramName, "message");
            throw ex;
        }

        private ArgumentNullException ThrowAndReturnArgumentNullException(string paramName)
        {
            ArgumentNullException ex = new ArgumentNullException(paramName, "message");
            throw ex;
        }

        private async Task<ArgumentNullException> ThrowAndReturnArgumentNullExceptionAsync(string paramName)
        {
            Func<string, ArgumentNullException> func = (para) =>
             {
                 ArgumentNullException ex = new ArgumentNullException(paramName, "message");
                 throw ex;
             };
            var reslut = await Task.Run(() => func(paramName));
            return reslut;
        }

        private void ThrowFormatException()
        {
            int.Parse("ping");
        }

        private FormatException ThrowAndReturnFormatException()
        {
            FormatException exception = null;
            try
            {
                int.Parse("ping");
            }
            catch (FormatException ex)
            {
                exception = ex;
                throw ex;
            }

            return exception;
        }

        private async Task ThrowFormatExceptionAsync()
        {
            await Task.Run(() => { int.Parse("ping"); });
        }

        private async Task ThrowAndReturnFormatExceptionAsync()
        {
            Func<FormatException> func = () =>
            {
                int.Parse("ping");
                return new FormatException();
            };

            await Task.Run(() => func());
        }
        #endregion

        #region 清理
        public void Dispose()
        {

        }
        #endregion
    }
}