public async Task DeadManSwitch_ResetCallback_NoExceptionWhenResetCallbackNull()
{
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(100), () => { }, null, true))
{
dms.Reset();
await Task.Delay(260);
}
}
public void DeadManSwitch_ResetCallback_CalledOnConstruction()
{
DeadManSwitchResetReason resetReason = DeadManSwitchResetReason.ManualReset;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(100), () => { }, (r) => resetReason = r, false))
{
Assert.AreEqual(DeadManSwitchResetReason.Initialize, resetReason, "Reset callback not called or not called with initialize as the reason when switch constructed.");
}
}
public IDeadManSwitchSession Create(DeadManSwitchOptions deadManSwitchOptions)
{
var deadManSwitchContext = new DeadManSwitchContext(deadManSwitchOptions);
var deadManSwitch = new DeadManSwitch(deadManSwitchContext, _loggerFactory.CreateLogger <DeadManSwitch>());
var deadManSwitchTriggerer = new DeadManSwitchTriggerer(deadManSwitchContext, deadManSwitchOptions, _loggerFactory.CreateLogger <DeadManSwitchTriggerer>());
var deadManSwitchWatcher =
new DeadManSwitchWatcher(deadManSwitchContext, deadManSwitchOptions, deadManSwitchTriggerer, _loggerFactory.CreateLogger <DeadManSwitchWatcher>());
return(new DeadManSwitchSession(deadManSwitchContext, deadManSwitch, deadManSwitchWatcher));
}
public void DeadManSwitch_ResetCallback_CalledOnManualReset()
{
DeadManSwitchResetReason resetReason = DeadManSwitchResetReason.Initialize;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(100), () => { }, (r) => resetReason = r, false))
{
dms.Reset();
Assert.AreEqual(DeadManSwitchResetReason.ManualReset, resetReason, "Reset callback not called or not called with manual as reason after calling Reset() method.");
}
}
public async Task DeadManSwitch_ResetCallback_CalledOnAutoReset()
{
DeadManSwitchResetReason resetReason = DeadManSwitchResetReason.Initialize;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(100), () => { }, (r) => resetReason = r, true))
{
await Task.Delay(150);
Assert.AreEqual(DeadManSwitchResetReason.AutoReset, resetReason, "Reset callback not called or not called with auto as reason after switch activated and auto reset enabled.");
}
}
public async Task DeadManSwitch_FiresIfResetNeverCalled()
{
bool activated = false;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(250), () => activated = true, false))
{
await Task.Delay(270);
Assert.AreEqual(true, activated, "Switch not activated after specified interval.");
}
}
static void Main(string[] args)
{
_DSwitch = new DeadManSwitch(5000, Fired, Reset, true);
while (true)
{
var k = Console.ReadKey();
if (k.Key == ConsoleKey.X)
{
break;
}
_DSwitch.Reset();
}
}
public async Task DeadManSwitch_DoesNotFireWhenReset()
{
bool activated = false;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(250), () => activated = true, false))
{
for (int cnt = 0; cnt < 10; cnt++)
{
await Task.Delay(100);
dms.Reset();
}
Assert.AreEqual(false, activated);
}
}
public async Task DeadManSwitch_DoesNotFireAfterDispose()
{
bool activated = false;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(250), () => activated = true, false))
{
for (int cnt = 0; cnt < 10; cnt++)
{
await Task.Delay(100);
dms.Reset();
}
Assert.AreEqual(false, activated, "Switch was incorrectly activated prior to interval elapsing.");
}
await Task.Delay(270);
Assert.AreEqual(false, activated, "Switch activated after it was disposed.");
}
public async Task DeadManSwitch_FiresWhenNotReset()
{
bool activated = false;
using (var dms = new DeadManSwitch(TimeSpan.FromMilliseconds(250), () => activated = true, false))
{
for (int cnt = 0; cnt < 10; cnt++)
{
await Task.Delay(100);
dms.Reset();
}
Assert.AreEqual(false, activated, "Switch was incorrectly activated prior to interval elapsing.");
await Task.Delay(270);
Assert.AreEqual(true, activated, "Switch not activated after specified interval.");
}
}
public void Constructor_ConstructsOkWithNullResetCallbackTimeAsTimespan()
{
using (var ds = new DeadManSwitch(TimeSpan.FromSeconds(1), () => { }, null, true))
{
}
}
public void Constructor_ThrowsOnNegativeDelayInMs()
{
var ds = new DeadManSwitch(-1, () => { }, false);
}
public void Constructor_ThrowsOnNegativeDelayAsTimespan()
{
var ds = new DeadManSwitch(TimeSpan.FromMilliseconds(-1), () => { }, false);
}
public void Constructor_ThrowsOnTooLargeDelayAsTimespan()
{
var ds = new DeadManSwitch(TimeSpan.MaxValue, () => { }, false);
}
public void Constructor_ThrowsOnZeroDelayAsTimespan()
{
var ds = new DeadManSwitch(TimeSpan.Zero, () => { }, false);
}
public void Constructor_ThrowsOnNullActivationCallback()
{
var ds = new DeadManSwitch(1000, null, false);
}
public void Constructor_ThrowsOnZeroDelayInMs()
{
var ds = new DeadManSwitch(0, () => { }, false);
}
public void Constructor_ConstructsOkWithNullResetCallbackTimeInMs()
{
using (var ds = new DeadManSwitch(1000, () => { }, null, true))
{
}
}
public void Constructor_ConstructsOkWithAcceptableValuesTimeAsTimespan()
{
using (var ds = new DeadManSwitch(TimeSpan.FromSeconds(1), () => { }, (r) => { }, false))
{
}
}
public void Constructor_ConstructsOkWithAcceptableValuesTimeInMs()
{
using (var ds = new DeadManSwitch(1000, () => { }, (r) => { }, false))
{
}
}
