c# – 测试帮助程序,用于报告重复事件的预期事件序列

public static void ExpectEventSequence(Queue<Action<EventHandler>> subscribeActions,Action triggerAction)
{
    var expectedSequence = new Queue<int>();
    for (int i = 0; i < subscribeActions.Count; i++)
    {
        expectedSequence.Enqueue(i);
    }

    ExpectEventSequence(subscribeActions,triggerAction,expectedSequence);
}

    public static void ExpectEventSequence(Queue<Action<EventHandler>> subscribeActions,Action triggerAction,Queue<int> expectedSequence)
    {
        var fired = new Queue<int>();
        var actionsCount = subscribeActions.Count;

        for(var i =0; i< actionsCount;i++)
        {
            subscription((o,e) =>
                {
                    fired.Enqueue(i);
                });
        }

        triggerAction();

        var executionIndex = 0;

        var inOrder = true;

        foreach (var firedIndex in fired)
        {

            if (firedIndex != expectedSequence.Dequeue())
            {
                inOrder = false;
                break;
            }

            executionIndex++;
        }

        if (subscribeActions.Count != fired.Count)
        {
            Assert.Fail("Not all events were fired.");
        }

        if (!inOrder)
        {
            Assert.Fail(string.Format(
                CultureInfo.CurrentCulture,"Events were not fired in the expected sequence from element {0}",executionIndex));
        }

    }

示例用法如下：

[Test()]
    public void FillFuel_Test([Values(1,5,10,100)]float maxFuel)
    {
        var fuelTank = new FuelTank()
        {
            MaxFuel = maxFuel
        };

        var eventHandlerSequence = new Queue<Action<EventHandler>>();

        eventHandlerSequence.Enqueue(x => fuelTank.FuelFull += x);

        //Dealing with a subclass of EventHandler
        eventHandlerSequence.Enqueue(x => fuelTank.FuelChanged += (o,e) => x(o,e));

        Test.ExpectEventSequence(eventHandlerSequence,() => fuelTank.FillFuel());
    }

并且测试的代码：

public float Fuel
    {
        get
        {
            return fuel;
        }
        private set
        {
            var adjustedFuel = Math.Max(0,Math.Min(value,MaxFuel));

            if (fuel != adjustedFuel)
            {
                var oldFuel = fuel;

                fuel = adjustedFuel;

                RaiseCheckFuelChangedEvents(oldFuel);
            }
        }
    }

    public void FillFuel()
    {
        Fuel = MaxFuel;
    }

    private void RaiseCheckFuelChangedEvents(float oldFuel)
    {
        FuelChanged.FireEvent(this,new FuelEventArgs(oldFuel,Fuel));

        if (fuel == 0)
        {
            FuelEmpty.FireEvent(this,EventArgs.Empty);
        }
        else if (fuel == MaxFuel)
        {
            FuelFull.FireEvent(this,EventArgs.Empty);
        }

        if (oldFuel == 0 && Fuel != 0)
        {
            FuelNoLongerEmpty.FireEvent(this,EventArgs.Empty);
        }
        else if (oldFuel == MaxFuel && Fuel != MaxFuel)
        {
            FuelNoLongerFull.FireEvent(this,EventArgs.Empty);
        }
    }

因此,测试预计FuelFilled将在FuelChanged之前被解雇,但实际上FuelChanged首先被解雇,但未通过测试.

然而,我的测试是报告FuelChanged被触发两次,但是当我单步执行代码时,很明显FuelFhanged和FuelChanged只触发一次后燃烧FuelFilled.

我认为这与lambdas使用本地状态的方式有关,也许for循环迭代器变量只被设置为最终值,所以我用这个取代了for循环：

var subscriptions = subscribeActions.ToList();

        foreach (var subscription in subscriptions)
        {
            subscription((o,e) =>
                {
                    var index = subscriptions.IndexOf(subscription);
                    fired.Enqueue(index);
                });
        }

但结果是相同的,触发包含{1; 1}而不是{1; 0}.

现在我想知道是否将同一个lambda分配给两个事件而不是使用不同的订阅/索引状态.有任何想法吗？

更新：到目前为止,我无法获得任何答案(与我的初始结果相同),尽管它们与我的实际代码相似,所以我认为问题位于我的FuelTank代码的其他位置.我在下面粘贴了FuelTank的完整代码：

public class FuelTank
{
    public FuelTank()
    {

    }

    public FuelTank(float initialFuel,float maxFuel)
    {
        MaxFuel = maxFuel;
        Fuel = initialFuel;
    }

    public float Fuel
    {
        get
        {
            return fuel;
        }
        private set
        {
            var adjustedFuel = Math.Max(0,MaxFuel));

            if (fuel != adjustedFuel)
            {
                var oldFuel = fuel;

                fuel = adjustedFuel;

                RaiseCheckFuelChangedEvents(oldFuel);
            }
        }
    }

    private float maxFuel;

    public float MaxFuel
    {
        get
        {
            return maxFuel;
        }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException("MaxFuel",value,"Argument must be not be less than 0.");
            }
            maxFuel = value;
        }
    }

    private float fuel;

    public event EventHandler<FuelEventArgs> FuelChanged;

    public event EventHandler FuelEmpty;

    public event EventHandler FuelFull;

    public event EventHandler FuelNoLongerEmpty;

    public event EventHandler FuelNoLongerFull;

    public void AddFuel(float fuel)
    {
        Fuel += fuel;
    }

    public void ClearFuel()
    {
        Fuel = 0;
    }

    public void DrainFuel(float fuel)
    {
        Fuel -= fuel;
    }

    public void FillFuel()
    {
        Fuel = MaxFuel;
    }

    private void RaiseCheckFuelChangedEvents(float oldFuel)
    {
        FuelChanged.FireEvent(this,EventArgs.Empty);
        }
    }
}

FuelEventArgs看起来像这样：

public class FuelEventArgs : EventArgs
{
    public float NewFuel
    {
        get;
        private set;
    }

    public float OldFuel
    {
        get;
        private set;
    }

    public FuelEventArgs(float oldFuel,float newFuel)
    {
        this.OldFuel = oldFuel;
        this.NewFuel = newFuel;
    }
}

FireEvent扩展方法如下所示：

public static class EventHandlerExtensions
{
    /// <summary>
    /// Fires the event. This method is thread safe.
    /// </summary>
    /// <param name="handler"> The handler. </param>
    /// <param name="sender">  Source of the event. </param>
    /// <param name="args">    The <see cref="EventArgs"/> instance containing the event data. </param>
    public static void FireEvent(this EventHandler handler,object sender,EventArgs args)
    {
        var handlerCopy = handler;

        if (handlerCopy != null)
        {
            handlerCopy(sender,args);
        }
    }

    /// <summary>
    /// Fires the event. This method is thread safe.
    /// </summary>
    /// <typeparam name="T"> The type of event args this handler has. </typeparam>
    /// <param name="handler"> The handler. </param>
    /// <param name="sender"> Source of the event. </param>
    /// <param name="args"> The <see cref="EventArgs"/> instance containing the event data. </param>
    public static void FireEvent<T>(this EventHandler<T> handler,T args) where T : EventArgs
    {
        var handlerCopy = handler;

        if (handlerCopy != null)
        {
            handlerCopy(sender,args);
        }
    }
}

完整的测试代码可以在问题的上面找到,在测试执行期间没有其他代码被调用.

我通过Unity测试工具插件使用NUnit测试框架,Unity3D引擎,.NET版本3.5(是的,它更接近Mono 2.0,我相信)和Visual Studio 2013.

更新2：

在将代码和测试提取到他们自己的项目之后(在Unity3D生态系统之外),所有测试都按预期运行,因此我将不得不将这个问题归结为Unity中的错误 – > Visual Studio桥.