NUnit断言

[TestFixture]
    public class AssertTest
    {
        private BaseTest btest;
        private BaseTest btest1;
        private ITest itest;
        private ITest itest1;
        private Test test;
        private Test test1;
        private List<Test> list;
        private List<Test> list1;
        private readonly string strTest = "abcdefg";
        private readonly string strTest1 = "abc";
        private readonly string strTest2 = "efg";
        private readonly string strTest3 = "AbcDeFg";

        [SetUp]
        public void Init()
        {
            btest = new BaseTest();
            itest = new Test();
            test = new Test();
            list = new List<Test>
            {
                test
            };

            btest1 = new BaseTest();
            itest1 = new Test();
            test1 = new Test();
            list1 = new List<Test>
            {
                test1
            };
        }

        #region 同等断言，重载支持普通值类型
        [Test]
        public void AreEqualObject()
        {
            // 成功，float型和double型的数值通常使用一个附加参数来进行比较，这个参数代表一个误差，在这个误差范围内，它们视为相等。
            Assert.AreEqual(5, 5.0);
        }

        [Test]
        public void AreNotEqual()
        {
            Assert.AreNotEqual(5, 6);
        }

        /// <summary>
        /// 一维数组长度，值相同
        /// </summary>
        [Test]
        public void AreEqualArray()
        {
            var arrStr = new string[] { "1", "2", "3" };
            var arrStr1 = new string[] { "1", "2", "3" };
            Assert.AreEqual(arrStr, arrStr1);
        }
        #endregion

        #region 一致性断言，判断两个参数引用一致
        [Test]
        public void AreSame()
        {
            Assert.AreSame(test, test);
        }

        [Test]
        public void AreNotSame()
        {
            Assert.AreNotSame(test, test1);
        }

        [Test]
        public void Contains()
        {
            Assert.Contains(test, list);
        }
        #endregion

        #region 比较断言，测试一个值类型小于或大于另一个值类型
        [Test]
        public void Greater()
        {
            Assert.Greater(6, 5);
        }
        [Test]
        public void GreaterOrEqual()
        {
            Assert.GreaterOrEqual(5, 5);
        }
        [Test]
        public void Less()
        {
            Assert.Less(4, 5);
        }
        [Test]
        public void LessOrEqual()
        {
            Assert.LessOrEqual(5, 5);
        }
        #endregion

        #region 类型断言
        /// <summary>
        /// 判断一个对象的类型是否是期望的类型
        /// </summary>
        [Test]
        public void IsInstanceOfType()
        {
            Assert.IsInstanceOf(typeof(Test), test);
            Assert.IsInstanceOf<Test>(test);
        }
        /// <summary>
        /// 判断对象是否是类型的子类
        /// </summary>
        [Test]
        public void IsInstanceOfTypeInterface()
        {
            Assert.IsInstanceOf<ITest>(test);
        }
        /// <summary>
        /// 判断对象是否是类型的子类
        /// </summary>
        [Test]
        public void IsInstanceOfTypeBase()
        {
            Assert.IsInstanceOf<BaseTest>(test);
        }
        [Test]
        public void IsNotInstanceOfType()
        {
            Assert.IsNotInstanceOf(typeof(ITest), btest);
            Assert.IsNotInstanceOf<Test>(btest);
        }
        /// <summary>
        /// 判断一个对象的类型是否属于某种类型，判断对象是否是类型的父类
        /// </summary>
        [Test]
        public void IsAssignableFrom()
        {
            Assert.IsAssignableFrom<Test>(test);
            Assert.IsAssignableFrom<Test>(itest);
            Assert.IsAssignableFrom<Test>(btest);
        }
        #endregion

        #region 条件测试断言
        [Test]
        public void IsTrue()
        {
            Assert.IsTrue(1 == 1);
        }

        [Test]
        public void IsFalse()
        {
            Assert.IsFalse(1 == 0);
        }

        [Test]
        public void IsNull()
        {
            object obj = null; 
            Assert.IsNull(obj);
        }

        [Test]
        public void IsNotNull()
        {
            Assert.IsNotNull(test);
        }
        /// <summary>
        /// 值是否是数字 not a number
        /// 返回NaN的运算有如下三种：
        //        至少有一个参数是NaN的运算
        //        不定式
        //下列除法运算：0/0、∞/∞、∞/−∞、−∞/∞、−∞/−∞
        //下列乘法运算：0×∞、0×−∞
        //下列加法运算：∞ + (−∞)、(−∞) + ∞
        //下列减法运算：∞ - ∞、(−∞) - (−∞)
        //产生复数结果的实数运算。例如：
        //对负数进行开偶次方的运算
        //对负数进行对数运算
        //对正弦或余弦到达域以外的数进行反正弦或反余弦运算[1]
        /// </summary>
        [Test]
        public void IsNaN()
        {
            var d = Math.Sqrt(-1);
            Assert.IsNaN(d);
        }
        [Test]
        public void IsEmpty()
        {
            var s = "";
            Assert.IsEmpty(s);
        }
        [Test]
        public void IsNotEmpty()
        {
            string s = null;
            Assert.IsNotEmpty(s);
        }

        [Test]
        public void IsCollectEmpty()
        {
            var c = new string[] { };
            Assert.IsEmpty(c);
        }
        [Test]
        public void IsCollectNotEmpty()
        {
            Assert.IsNotEmpty (list);
        }
        #endregion

        #region StringAssert断言
        [Test]
        public void StringContains()
        {
            // 预期包含实际
            StringAssert.Contains(strTest1, strTest);
        }
        [Test]
        public void StringStart()
        {
            StringAssert.StartsWith(strTest1, strTest);
        }
        [Test]
        public void StringEnd()
        {
            StringAssert.EndsWith(strTest2, strTest);
        }
        [Test]
        public void StringEqualIgnoringCase()
        {
            StringAssert.AreEqualIgnoringCase(strTest3, strTest);
        }
        #endregion

        #region 实用方法
        [Test]
        public void AssertStringContains()
        {
            if (strTest.IndexOf(strTest1) < 0)
                Assert.Fail("123");
        }
        #endregion
    }

    class BaseTest { }

    interface ITest { }

    class Test : BaseTest, ITest
    {
    }