public void DisposeTest()
{
const int n = 1000;
var def = TestLifetime.CreateNested();
var scheduler = CreateSequentialScheduler("TestScheduler", def.Lifetime);
var count = 0;
var reached = false;
def.Lifetime.Start(scheduler, () =>
{
for (var i = 0; i < n; i++)
{
scheduler.Queue(() => count++);
}
Assert.AreEqual(0, count);
def.Terminate();
Assert.AreEqual(0, count);
Assert.Throws <LifetimeCanceledException>(() => scheduler.Queue(() => reached = true));
}).Wait();
Assert.AreEqual(LifetimeStatus.Terminated, def.Status);
SpinWait.SpinUntil(() => count == n, TimeSpan.FromSeconds(5));
Assert.AreEqual(n, count);
Assert.IsFalse(reached);
Assert.Throws <LifetimeCanceledException>(() => scheduler.Queue(() => reached = true));
Assert.IsFalse(reached);
}
public void TestInFile()
{
var path = Path.GetTempFileName();
TestLifetime.OnTermination(() => File.Delete(path));
Lifetime.Using(lf =>
{
var factory = Log.CreateFileLogFactory(lf, path, append: false, enabledLevel: LoggingLevel.VERBOSE);
var log1 = factory.GetLog("sample1");
var log2 = factory.GetLog("sample2");
log1.Info("info record");
log2.Verbose("verbose record");
log2.Trace("trace record"); //must be filtered
});
var lines = File.ReadAllLines(path);
Assert.AreEqual(2, lines.Length);
Assert.True(lines[0].Contains("|I| sample1"));
Assert.True(lines[0].Contains("| info record"));
Assert.True(lines[1].Contains("|V| sample2"));
Assert.True(lines[1].Contains("| verbose record"));
}
public void SimpleTest()
{
const int n = 1000;
var scheduler = CreateSequentialScheduler("TestScheduler", TestLifetime);
Assert.IsFalse(scheduler.OutOfOrderExecution, "scheduler.OutOfOrderExecution");
{
Assert.IsFalse(scheduler.IsActive);
for (var i = 0; i < 100; i++)
{
var sum = 0;
var range = Enumerable.Range(0, n);
var tasks = range.Select(j => TestLifetime.Start(scheduler, () =>
{
sum += j;
Assert.IsTrue(scheduler.IsActive);
})).ToArray();
Task.WaitAll(tasks);
Assert.AreEqual(range.Sum(), sum);
}
}
Assert.IsFalse(scheduler.IsActive);
{
TestLifetime.StartAsync(scheduler, async() =>
{
Assert.IsTrue(scheduler.IsActive);
var reached = false;
scheduler.Queue(() =>
{
reached = true;
Assert.IsTrue(scheduler.IsActive);
});
SpinWait.SpinUntil(() => reached, TimeSpan.FromMilliseconds(100));
Assert.IsFalse(reached);
await Task.Yield();
Assert.IsTrue(scheduler.IsActive);
Assert.IsTrue(reached);
}).Wait();
}
}
public void TestTerminatesAfter()
{
var lf = TestLifetime.CreateTerminatedAfter(TimeSpan.FromMilliseconds(100));
Assert.True(lf.IsAlive);
Thread.Sleep(200);
Assert.True(lf.IsNotAlive);
lf = TestLifetime.CreateTerminatedAfter(TimeSpan.FromMilliseconds(100));
Assert.True(lf.IsAlive);
LifetimeDefinition.Terminate();
Assert.True(lf.IsNotAlive);
Thread.Sleep(200);
Assert.True(lf.IsNotAlive);
}
public void IsActiveTest()
{
const int n = 1000;
using var def = TestLifetime.CreateNested();
var scheduler1 = CreateSequentialScheduler("TestScheduler1", def.Lifetime);
var scheduler2 = CreateSequentialScheduler("TestScheduler2", def.Lifetime);
Assert.IsFalse(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
def.Lifetime.Start(scheduler1, () =>
{
Assert.IsTrue(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
def.Lifetime.Start(scheduler2, () =>
{
Assert.IsFalse(scheduler1.IsActive);
Assert.IsTrue(scheduler2.IsActive);
}).Wait();
Assert.IsTrue(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
}).Wait();
def.Lifetime.StartAsync(scheduler1, async() =>
{
Assert.IsTrue(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
await def.Lifetime.Start(scheduler2, () =>
{
Assert.IsFalse(scheduler1.IsActive);
Assert.IsTrue(scheduler2.IsActive);
});
Assert.IsTrue(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
}).Wait();
Assert.IsFalse(scheduler1.IsActive);
Assert.IsFalse(scheduler2.IsActive);
}
