A way to define a collection in argument constraint

Would be nice a new argument matcher for a collection of values, that can be good if we are testing some method that process an argument list

Something like this IsInOrderFromColection

    public interface IDep { Double(int n);  }

     var mock = A.Fake<IDep>();
     A.CallTo(() => mock.Double(A<int>._)).Returns(0);

     var numbers = new[] { 2, 4, 5 };
     foreach (var n in numbers)
        mock.Double(n);

      A.CallTo(() => 
         mock.Double(A<int>.That.IsInOrderFromColection(2, 4, 5) ))
         .MustHaveHappened();

it should verify if the Double method is called with 2, 4 and 5 in sequence,

[thomaslevesque]

@blairconrad sorry, my example was wrong, I fixed it. current needs to be reassigned with the result of Then in the loop body.

[blairconrad]

@lucasteles, I understand your reticence to include a loop in your test, but it might not be hard to hide it within a method. Hmm. Lemme try something.

I’m back. I hacked this up:

public class MustHaveHappenedForEachArgument
{
    public interface IDep { int Double(int n); }

    [Test]
    public void T()
    {
        var mock = A.Fake<IDep>();
        A.CallTo(() => mock.Double(A<int>._)).Returns(0);

        var numbers = new[] { 2, 4, 5 };
        foreach (var n in numbers)
        {
            mock.Double(n);
        }

        AssertWasCalledWithEach(n => () => mock.Double(n), numbers);
    }

    private static void AssertWasCalledWithEach(Func<int, Expression<Func<int>>> callSpecificationFactory, IEnumerable<int> args)
    {
        var current = NullOrderableCallAssertion.Default;
        foreach (var arg in args)
        {
            current = current.Then( // originally did not assign - thanks, @thomaslevesque 	
                A.CallTo(callSpecificationFactory(arg)).MustHaveHappened());
        }
    }

    private class NullOrderableCallAssertion : IOrderableCallAssertion
    {
        public static IOrderableCallAssertion Default { get; } = new NullOrderableCallAssertion();

        private NullOrderableCallAssertion() { }

        public IOrderableCallAssertion Then(UnorderedCallAssertion nextAssertion)
        {
            return nextAssertion;
        }
    }
}

It’s not perfect, but maybe makes things more palatable for you? I tried fully genericizing the method, but the compiler could not figure out the signature.