public void IsAliveTest()
{
using (var client = new TestHeadlessGameHost(@"client", true))
{
var testGame = new TestTestGame();
client.Run(testGame);
Assert.IsTrue(testGame.IsRootAlive);
}
}
public void TestPauseResume()
{
var gameCreated = new ManualResetEventSlim();
var task = Task.Run(() =>
{
using (host = new HeadlessGameHost(@"host", false))
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
});
Assert.IsTrue(gameCreated.Wait(timeout));
Assert.IsTrue(game.BecameAlive.Wait(timeout));
// check scheduling is working before suspend
var completed = new ManualResetEventSlim();
game.Schedule(() => completed.Set());
Assert.IsTrue(completed.Wait(timeout / 10));
host.Suspend();
// in single-threaded execution, the main thread may already be in the process of updating one last time.
int gameUpdates = 0;
game.Scheduler.AddDelayed(() => ++ gameUpdates, 0, true);
Assert.That(() => gameUpdates, Is.LessThan(2).After(timeout / 10));
// check that scheduler doesn't process while suspended..
completed.Reset();
game.Schedule(() => completed.Set());
Assert.IsFalse(completed.Wait(timeout / 10));
// ..and does after resume.
host.Resume();
Assert.IsTrue(completed.Wait(timeout / 10));
game.Exit();
Assert.IsTrue(task.Wait(timeout));
}
public void TestPauseResume()
{
var gameCreated = new ManualResetEventSlim();
var task = Task.Run(() =>
{
using (host = new HeadlessGameHost(@"host", false))
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
});
Assert.IsTrue(gameCreated.Wait(timeout));
Assert.IsTrue(game.BecameAlive.Wait(timeout));
// check scheduling is working before suspend
var completed = new ManualResetEventSlim();
game.Schedule(() => completed.Set());
Assert.IsTrue(completed.Wait(timeout / 10));
host.Suspend();
completed.Reset();
// check that scheduler doesn't process while suspended..
game.Schedule(() => completed.Set());
Assert.IsFalse(completed.Wait(timeout / 10));
host.Resume();
// ..and does after resume.
Assert.IsTrue(completed.Wait(timeout / 10));
game.Exit();
Assert.IsTrue(task.Wait(timeout));
}
public void TestExitBlocking()
{
var gameCreated = new ManualResetEventSlim();
var task = Task.Factory.StartNew(() =>
{
using (host = new ManualExitHeadlessGameHost())
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
}, TaskCreationOptions.LongRunning);
gameCreated.Wait(timeout);
Assert.IsTrue(game.BecameAlive.Wait(timeout));
Assert.That(host.ExecutionState, Is.EqualTo(ExecutionState.Running));
// block game from exiting.
game.BlockExit.Value = true;
requestExit();
Assert.That(game.LastExitResult, Is.True);
// exit should be blocked.
Assert.That(task.IsCompleted, Is.False);
Assert.That(host.ExecutionState, Is.EqualTo(ExecutionState.Running));
// unblock game from exiting.
game.BlockExit.Value = false;
requestExit();
Assert.That(game.LastExitResult, Is.False);
// finally, the game should exit.
task.Wait(timeout);
Assert.That(host.ExecutionState, Is.EqualTo(ExecutionState.Stopped));
}
public void TestChildDisposedBeforeGame()
{
var gameCreated = new ManualResetEventSlim();
var task = Task.Factory.StartNew(() =>
{
using (host = new TestRunHeadlessGameHost("host", new HostOptions(), bypassCleanup: false))
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
}, TaskCreationOptions.LongRunning);
Assert.IsTrue(gameCreated.Wait(timeout));
Assert.IsTrue(game.BecameAlive.Wait(timeout));
var container = new DisposableContainer();
game.Schedule(() => game.Add(container));
Assert.IsTrue(container.BecameAlive.Wait(timeout));
game.Schedule(() =>
{
game.ClearInternal(false);
game.DisposeChildAsync(container);
});
game.Exit();
Assert.IsTrue(task.Wait(timeout));
game.Dispose();
Assert.IsTrue(container.DisposedSuccessfully.Wait(timeout));
}
public void TestChildDisposedBeforeGame()
{
var gameCreated = new ManualResetEventSlim();
var task = Task.Run(() =>
{
using (host = new HeadlessGameHost(@"host", false))
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
});
Assert.IsTrue(gameCreated.Wait(timeout));
Assert.IsTrue(game.BecameAlive.Wait(timeout));
var container = new DisposableContainer();
game.Schedule(() => game.Add(container));
Assert.IsTrue(container.BecameAlive.Wait(timeout));
game.Schedule(() =>
{
game.ClearInternal(false);
game.DisposeChildAsync(container);
});
game.Exit();
Assert.IsTrue(task.Wait(timeout));
game.Dispose();
Assert.IsTrue(container.DisposedSuccessfully.Wait(timeout));
}
public void TestPauseResume(ExecutionMode threadMode)
{
var gameCreated = new ManualResetEventSlim();
IBindable <GameThreadState> updateThreadState = null;
var task = Task.Run(() =>
{
using (host = new ExecutionModeGameHost(@"host", threadMode))
{
game = new TestTestGame();
gameCreated.Set();
host.Run(game);
}
});
Assert.IsTrue(gameCreated.Wait(timeout));
Assert.IsTrue(game.BecameAlive.Wait(timeout));
// check scheduling is working before suspend
var completed = new ManualResetEventSlim();
game.Schedule(() =>
{
updateThreadState = host.UpdateThread.State.GetBoundCopy();
updateThreadState.BindValueChanged(state =>
{
if (state.NewValue != GameThreadState.Starting)
{
Assert.IsTrue(ThreadSafety.IsUpdateThread);
}
});
completed.Set();
});
Assert.IsTrue(completed.Wait(timeout / 10));
Assert.AreEqual(GameThreadState.Running, updateThreadState.Value);
host.Suspend();
// in single-threaded execution, the main thread may already be in the process of updating one last time.
int gameUpdates = 0;
game.Scheduler.AddDelayed(() => ++ gameUpdates, 0, true);
Assert.That(() => gameUpdates, Is.LessThan(2).After(timeout / 10));
Assert.AreEqual(GameThreadState.Paused, updateThreadState.Value);
// check that scheduler doesn't process while suspended..
completed.Reset();
game.Schedule(() => completed.Set());
Assert.IsFalse(completed.Wait(timeout / 10));
// ..and does after resume.
host.Resume();
Assert.IsTrue(completed.Wait(timeout / 10));
Assert.AreEqual(GameThreadState.Running, updateThreadState.Value);
game.Exit();
Assert.IsTrue(task.Wait(timeout));
Assert.AreEqual(GameThreadState.Exited, updateThreadState.Value);
}
