Как контролировать «Равенство» для членов словаря, используя FluentAssertions

Есть ли способ, с FluentAssertions, контролировать, как значения словаря сравниваются для равенства?

У меня есть класс, одним из свойств которого является словарь (строка / двойной). Я хотел бы сравнить два экземпляра класса (ожидаемого и фактического) и для членов словаря, чтобы определить, как определяется «равенство».

Предполагая, что у меня есть класс, как показано:

[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void TestMethod1()
    {
        var t1 = new Thing();
        t1.Name = "Bob";
        t1.Values.Add("Hello", 100.111);
        t1.Values.Add("There", 100.112);
        t1.Values.Add("World", 100.113);

        var t2 = new Thing();
        t2.Name = "Bob";
        t2.Values.Add("Hello", 100.111);
        t2.Values.Add("There", 100.112);
        t2.Values.Add("World", 100.1133);

        t1.Should().BeEquivalentTo(t2);
    }
}

public class Thing
{
    public string Name { get; set; }

    public Dictionary<string, double> Values { get; set; } = new Dictionary<string, double>();
}

Я хотел бы иметь возможность указать, как, например, сравнивается запись «Мир» в словаре. В действительности может быть, что значения могут быть очень большими или одинаковыми в десяти десятичных разрядах (но не после этого), но я думаю, что мне может потребоваться сказать что-то вроде «того же, если разница меньше 1%»).

Мне нравится, как FluentAssertions сообщает мне член и почему они не совпадают, и попробовали пользовательский IAssertionRule (используя опции lambda), но это только казалось, сравнивает свойства класса, а не члены словаря.

Я не владею сравниваемыми классами, поэтому я не могу переопределить метод «Равный», и я не могу найти способ указать пользовательский сопоставитель (IEquatable), но я подозреваю, что потеряю четкую информацию о том, почему они не совпадают ,

Если бы это было возможно, но любой метод применим и к двойникам, которые были свойствами класса (в отличие от значений в словаре), это было бы нормально.

Благодарю.

c#,fluent-assertions,

1

Ответов: 3


1 принят

Следуя из ответа Nkosi, это пример BeApproximately, который я использую (чтобы разрешить использование decimal?с a ): [CustomAssertion] public static void BeApproximately(this NullableNumericAssertions<decimal> value, decimal? expected, decimal precision, string because = "", params object[] becauseArgs) { if (expected == null) value.BeNull(because); else { if (!Execute.Assertion.ForCondition(value.Subject != null).BecauseOf(because) .FailWith($"Expected {{context:subject}} to be '{expected}' {{reason}} but found null")) return; Decimal num = Math.Abs(expected.Value - (Decimal) value.Subject); Execute.Assertion.ForCondition(num <= precision).BecauseOf(because, becauseArgs).FailWith("Expected {context:value} to approximate {1} +/- {2}{reason}, but {0} differed by {3}.", (object) value.Subject, (object) expected.Value, (object) precision, (object) num); } }

BeApproximately

3

BeApproximatelyможет использоваться для сравнения удвоений в приемлемом диапазоне точности. Использование этого вместе с настройкой точности для всех парных должно удовлетворять желаемому поведению.

t1.Should().BeEquivalentTo(t2, options => options
    .Using<double>(ctx => 
        ctx.Subject.Should().BeApproximately(ctx.Expectation, ctx.Expectation * 0.01D))
    .WhenTypeIs<double>()
);

Сравнение ссылочного объектного графика: поведение сравнения эквивалентности


0

После превосходного поста Михала я начал работать со следующим, что показывает отличные обещания:

    [CustomAssertion]
    public static void BeWithinPercentageOf(this NumericAssertions<double> value, double expected, double tolerance, string because = "", params object[] becauseArgs)
    {
        if (!Execute.Assertion.ForCondition(value.Subject != null)
            .BecauseOf(because)
            .FailWith($"Expected {{context:subject}} to be '{expected}' {{reason}} but found null"))
            return;

        var actual = (double)value.Subject;
        var diff = Math.Abs(expected - actual);

        if (diff > double.Epsilon)
        {
            var percent = Math.Round(100 / (expected / diff), 2);

            Execute.Assertion.ForCondition(percent <= tolerance)
                .BecauseOf(because, becauseArgs)
                .FailWith("Expected {context:value} to be {1} (A±{2}%){reason}, but {0} differed by {3}%.", actual, expected, tolerance, percent);
        }
    }
C #, текучее-утверждение,
Похожие вопросы