使用 NUnit 对隐式运算符进行单元测试

Question

I'm trying to figure out how to write a unit test around an implicit conversion with NUnit.

So far the only way I have been able to do it is to create a static function that takes the type the object will be converted to as a parameter and instantly returns it.

public class Foo
{
    public Foo(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}

public class Bar
{
    public Bar(string name)
    {
        Name = name;
    }
    public string Name { get; set; }

    public static implicit operator Foo(Bar bar)
    {
        return new Foo(bar.Name);
    }
}

[Test]
public void BarToFooImplicitConversionTest()
{
    var bar = new Bar("FooBar");
    var foo = ConvertBarToFooImplicitly(bar);
    foo.Name.Should().Be("FooBar");
}

private static Foo ConvertBarToFooImplicitly(Foo foo)
{
    return foo;
}

Is there something in NUnit I'm missing or is there a better way to do this?

Answer 1

Just use explicit types instead of var to trigger implicit operators, eg

[Test]
public void Should_be_possible_to_convert_bar_to_foo()
{
    //Arrange
    const string fooBar = "FooBar";
    Bar bar = new Bar(fooBar);

    //Act
    Foo foo = bar;

    //Assert
    foo.Name.Should().Be(fooBar);
}