Unidad System.Threading.Timer de prueba en .NET

Question

Como unidad de prueba de un temporizador basado en System.Threading.Timer en .NET El System.Threading.Timer tiene un método de devolución de llamada

Answer 1

Puede probar la unidad no creando realmente una dependencia directa en System.Threading.Timer. En su lugar, cree una interfaz ITimer y un contenedor alrededor de System.Threading.Timer que la implemente.

primer lugar usted necesita para convertir la devolución de llamada a un evento, por lo que se puede hacer 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; } 
} 

A continuación, cree una interfaz:

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

Y un envoltorio:

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 se agregarían las sobrecargas del constructor y/o Change método que necesita usar desde el Threading.Timer. Ahora puede probar la unidad nada dependiendo de ITimer con un temporizador falsa:

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; 
} 

Cada vez que desee simular una garrapata, simplemente llame a RaiseTickEvent en las falsificaciones.

[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); 
} 

Answer 2

voy a probarlo en el 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 exactitud de ese método, no cómo funciona la hora del sistema.

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

Answer 4

Afortunadamente cualquiera que 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?