C# NUnit约束，它否定前面的内容

我试图构建一个约束，该约束仅在某些额外变量为true/false时“有效”

所以我可以这样使用它：

Assert.That(animals, Is.SupersetOf(dogs).If(isSuperset));

Not

约束否定后面的内容，但是没有约束否定前面的内容

到目前为止，我有：

public static Constraint If(this Constraint expression, bool isTrue)
{
  return ((Constraint)(((IResolveConstraint)expression).Resolve()))
         .And.Append(new EqualConstraint(isTrue).And.EqualTo(true));
}

但这不起作用。如何执行此操作？

我假设当If（false）时，您希望表达式始终通过：

public static class Ext
{
    public static Constraint If(this Constraint expression, bool isTrue)
    {
        return new IfConstraint(expression, isTrue);
    }

    public class IfConstraint : Constraint
    {
        private Constraint _linkedConstraint;
        private bool _isTrue;

        public IfConstraint(Constraint linkedConstraint, bool isTrue)
        {
            _linkedConstraint = linkedConstraint;
            _isTrue = isTrue;
        }

        public override ConstraintResult ApplyTo<TActual>(TActual actual)
        {
            if (!_isTrue)
                return new ConstraintResult(this, actual, true);
            return _linkedConstraint.ApplyTo<TActual>(actual);
        }
    }
}

公共静态类Ext
{
公共静态约束If（此约束表达式bool isTrue）
{
返回新的IfConstraint（expression，isTrue）；
}
公共类IfConstraint:Constraint
{
私有约束链接约束；
私人住宅区；
公共IfConstraint（约束链接约束，布尔isTrue）
{
_linkedConstraint=linkedConstraint；
_isTrue=isTrue；
}
公共覆盖约束结果应用程序（实际）
{
如果（！\u是真的）
返回新的ConstraintResult（this、actual、true）；
返回_linkedConstraint.ApplyTo（实际）；
}
}
}

我假设当If（false）时，您希望表达式始终通过：

public static class Ext
{
    public static Constraint If(this Constraint expression, bool isTrue)
    {
        return new IfConstraint(expression, isTrue);
    }

    public class IfConstraint : Constraint
    {
        private Constraint _linkedConstraint;
        private bool _isTrue;

        public IfConstraint(Constraint linkedConstraint, bool isTrue)
        {
            _linkedConstraint = linkedConstraint;
            _isTrue = isTrue;
        }

        public override ConstraintResult ApplyTo<TActual>(TActual actual)
        {
            if (!_isTrue)
                return new ConstraintResult(this, actual, true);
            return _linkedConstraint.ApplyTo<TActual>(actual);
        }
    }
}

公共静态类Ext
{
公共静态约束If（此约束表达式bool isTrue）
{
返回新的IfConstraint（expression，isTrue）；
}
公共类IfConstraint:Constraint
{
私有约束链接约束；
私人住宅区；
公共IfConstraint（约束链接约束，布尔isTrue）
{
_linkedConstraint=linkedConstraint；
_isTrue=isTrue；
}
公共覆盖约束结果应用程序（实际）
{
如果（！\u是真的）
返回新的ConstraintResult（this、actual、true）；
返回_linkedConstraint.ApplyTo（实际）；
}
}
}

看起来你已经得到了答案，但既然我已经得到了一个工作POC，我想我还是会分享它

以下是我所做的：

public class TheFooClass
{
    [Test]
    public void TheFooTest()
    {
        Assert.That(true, Is.True.If(false)); // passes
        Assert.That(true, Is.True.If(true)); // passes
        Assert.That(false, Is.True.If(false)); // passes
        Assert.That(false, Is.True.If(true)); // fails
    }
}

public static class AssertionExtensions
{
    public static Constraint If(this Constraint expression, bool isTrue)
    {
        return isTrue ? expression : new AlwaysTrue();
    }
}

public class AlwaysTrue : Constraint
{
    public override ConstraintResult ApplyTo<TActual>(TActual actual)
    {
        var trueResult = new ConstraintResult(new TrueConstraint(), true);
        trueResult.Status = ConstraintStatus.Success;
        return trueResult;
    }
}

footclass的公共类
{
[测试]
公开作废ootest（）
{
Assert.That（true，Is.true.If（false））；//通过
Assert.That（true，Is.true.If（true））；//通过
Assert.That（false，Is.True.If（false））；//通过
Assert.That（false，Is.True.If（True））；//失败
}
}
公共静态类断言扩展
{
公共静态约束If（此约束表达式bool isTrue）
{
return isTrue？表达式：new AlwaysTrue（）；
}
}
公共类AlwaysTrue:约束
{
公共覆盖约束结果应用程序（实际）
{
var trueResult=new ConstraintResult（new TrueConstraint（），true）；
trueResult.Status=ConstraintStatus.Success；
返回真实结果；
}
}

看起来你已经得到了答案，但既然我已经得到了一个工作POC，我想我还是会分享它

以下是我所做的：

public class TheFooClass
{
    [Test]
    public void TheFooTest()
    {
        Assert.That(true, Is.True.If(false)); // passes
        Assert.That(true, Is.True.If(true)); // passes
        Assert.That(false, Is.True.If(false)); // passes
        Assert.That(false, Is.True.If(true)); // fails
    }
}

public static class AssertionExtensions
{
    public static Constraint If(this Constraint expression, bool isTrue)
    {
        return isTrue ? expression : new AlwaysTrue();
    }
}

public class AlwaysTrue : Constraint
{
    public override ConstraintResult ApplyTo<TActual>(TActual actual)
    {
        var trueResult = new ConstraintResult(new TrueConstraint(), true);
        trueResult.Status = ConstraintStatus.Success;
        return trueResult;
    }
}

footclass的公共类
{
[测试]
公开作废ootest（）
{
Assert.That（true，Is.true.If（false））；//通过
Assert.That（true，Is.true.If（true））；//通过
Assert.That（false，Is.True.If（false））；//通过
Assert.That（false，Is.True.If（True））；//失败
}
}
公共静态类断言扩展
{
公共静态约束If（此约束表达式bool isTrue）
{
return isTrue？表达式：new AlwaysTrue（）；
}
}
公共类AlwaysTrue:约束
{
公共覆盖约束结果应用程序（实际）
{
var trueResult=new ConstraintResult（new TrueConstraint（），true）；
trueResult.Status=ConstraintStatus.Success；
返回真实结果；
}
}

你能把整个断言包装在一个if中吗？@Joe\u DM是的，我可以这样做，但我想在断言中执行if/else，使测试更整洁。仅仅根据方法链接的工作方式，很难让右侧的方法覆盖左侧的方法。我能想到的唯一方法是，如果它都是延迟执行的，然后在调用之前手动计算表达式。我最初的怀疑是这件事做不到。但我很高兴我错了。我希望有人拥有你想要的东西。事实上，刚刚注意到这似乎是在传递表达式，所以它可能已经是一个延迟执行，你可以这样做。在名为

If

的新约束中，当

为true

为false时，是否可以返回通过的结果？e、 g.忽略传入的表达式，只返回一个始终为真的新约束，或者成功（无论NUnit如何）您可以将整个断言包装在if中吗？@Joe_DM是的，我可以这样做，但我想在断言中执行if/else，以使测试更整洁。仅基于方法链接的工作方式，很难让右侧的方法覆盖左侧的方法。我能想到的唯一方法是，如果它都是延迟执行的，然后在调用之前手动计算表达式。我最初的怀疑是这件事做不到。但我很高兴我错了。我希望有人拥有你想要的东西。事实上，刚刚注意到这似乎是在传递表达式，所以它可能已经是一个延迟执行，你可以这样做。在名为

If

的新约束中，当

为true

为false时，是否可以返回通过的结果？e、 g.忽略传入的表达式，只返回一个始终为true的新约束或success（无论NUnit如何执行）