timers - Prueba de unidad System.Threading.Timer en.NET

timers timer vb net

Question

Cómo probar un temporizador en base a System.Threading.Timer en .NET El System.Threading.Timer tiene un método de devolución de llamada

Answer 1

Esperemos que sea cual sea esta característica es una parte más grande de permite configurar el intervalo del temporizador. Debería poder usar esa interfaz para inyectar un breve intervalo adecuado para la prueba unitaria. Tengo la pregunta el valor de esta prueba: ¿Estás probando el intervalo (sin sentido) o que la rutina se llama aproximadamente cada cierto tiempo?

Answer 2

Lo probaré de la misma manera que cualquier otra clase pero con intervalos de tiempo cortos para evitar que la prueba de la unidad se ejecute durante un tiempo prolongado. Otro enfoque es probar tu propio código solo y usar un temporizador simulado (por ejemplo, NMock), pero depende de cómo sea el diseño de tu código. ¿Puedes publicar algunos fragmentos de código?

Answer 3

Si el tiempo simplemente cambia el método de devolución de llamada, entonces solo necesita verificar la corrección de ese método, no cómo funciona el tiempo del sistema.

Además de eso, recomiendo usar el MultimediaTimer en su lugar, es mucho más preciso.

Answer 4

Puede realizar una prueba unitaria al no crear realmente una dependencia directa en System.Threading.Timer . En su lugar, cree una interfaz ITimer y un contenedor alrededor de System.Threading.Timer que lo implementa.

Primero necesita convertir la devolución de llamada a un evento, para que pueda formar parte de una interfaz:

public delegate void TimerEventHandler(object sender, TimerEventArgs e);

public class TimerEventArgs : EventArgs
{
    public TimerEventArgs(object state)
    {
        this.State = state;
    }

    public object State { get; private set; }
}

Luego crea una interfaz:

public interface ITimer
{
    void Change(TimeSpan dueTime, TimeSpan period);
    event TimerEventHandler Tick;
}

Y una envoltura

public class ThreadingTimer : ITimer, IDisposable
{
    private Timer timer;

    public ThreadingTimer(object state, TimeSpan dueTime, TimeSpan period)
    {
        timer = new Timer(TimerCallback, state, dueTime, period);
    }

    public void Change(TimeSpan dueTime, TimeSpan period)
    {
        timer.Change(dueTime, period);
    }

    public void Dispose()
    {
        timer.Dispose();
    }

    private void TimerCallback(object state)
    {
        EventHandler tick = Tick;
        if (tick != null)
            tick(this, new TimerEventArgs(state));
    }

    public event TimerEventHandler Tick;
}

Obviamente, agregará las sobrecargas del constructor y / o el método de Change que necesite usar desde el Threading.Timer . Ahora puedes probar cualquier cosa dependiendo de ITimer con un temporizador falso:

public class FakeTimer : ITimer
{
    private object state;

    public FakeTimer(object state)
    {
        this.state = state;
    }

    public void Change(TimeSpan dueTime, TimeSpan period)
    {
        // Do nothing
    }

    public void RaiseTickEvent()
    {
        EventHandler tick = Tick;
        if (tick != null)
            tick(this, new TimerEventArgs(state));
    }

    public event TimerEventHandler Tick;
}

Siempre que quiera simular un tic, simplemente llame a RaiseTickEvent en el falso.

[TestMethod]
public void Component_should_respond_to_tick
{
    ITimer timer = new FakeTimer(someState);
    MyClass c = new MyClass(timer);
    timer.RaiseTickEvent();
    Assert.AreEqual(true, c.TickOccurred);
}