# FluentAssertions 基础 断言

这边的是一些基础的断言，基本上所有的类型都是可以用的。

判断两个对象相等

    [Fact]
    public void Test_Example1()
    {
        object theObject = "whatever";
        string otherObject = "whatever";
        theObject.Should().Be(otherObject); // 两个内容相等，断言成功
        theObject.Should().NotBe(otherObject); // theObject 不是 otherObject  断言失败。 这个
    }

判断对象是不是为null

object theObject = null;
theObject.Should().BeNull(); // 必须是 null 断言成功
theObject.Should().NotBeNull(); //断言失败

判断类型对不对

using FluentAssertions;
using Xunit;
namespace MyFirstUnitTests
{
    public class MyTestClass
    {
        [Fact]
        public void Test_Example1()
        {
            object s1 = new Student() { Age = 1 };
             //判断是不是 Student 类型
            s1.Should().BeOfType<Student>();

//判断完是不是 Student 类型并继续断言它的Age属性值必须为1
            s1.Should().BeOfType<Student>().Subject.Age.Should().Be(1);
        }

        public class Student
        { 
            public int Age { get; set; }
        }
    }
}

判断是不是可以转型为其它类型

实际上相当于是不是从这个类型继承出来的。

using FluentAssertions;
using Xunit;
namespace MyFirstUnitTests
{
    public class MyTestClass
    {
        [Fact]
        public void Test_Example1()
        {
            object s1 = new Student() { Age = 1 };
            s1.Should().BeAssignableTo<object>(); // 能够赋值到ojbect 类型，
            s1.Should().BeAssignableTo<int>(); // 能够赋值到 int 类型， 断言失败
        }

        public class Student
        { 
            public int Age { get; set; }
        }
    }
}

异常断言 exceptions assertions

这个使用的方式比默认的Xunit的判断看起来还麻烦一些，因为要先定义 action

 [Fact]
public void MyTest()
{
    Action a = () => Add(null, 3);
    a.Should().Throw<ArgumentException>() //判断要抛出异常 ArgumentException
        .And.Message.Should().Be("a"); // 判断它的消息 使用And可以对这个exception的其它属性进行断言

    //也可以
    a.Should().Throw<ArgumentException>().Where(x => x.Message == "a")
    
}

public int Add(int? a, int b)
{
    throw new ArgumentException(nameof(a));
}