public void TestExitBeforePush()
{
TestScreen screen1 = null;
TestScreen screen2 = null;
AddStep("push slow", () => baseScreen.Push(screen1 = new TestScreenSlow()));
AddStep("exit slow", () => screen1.Exit());
AddUntilStep(() => screen1.LoadState >= LoadState.Ready, "wait for screen to load");
AddAssert("ensure not current", () => !screen1.IsCurrentScreen());
AddAssert("ensure base still current", () => baseScreen.IsCurrentScreen());
AddStep("push fast", () => baseScreen.Push(screen2 = new TestScreen()));
AddUntilStep(() => screen2.IsCurrentScreen(), "ensure new current");
}
public void TestAsyncPreloadPush()
{
TestScreenSlow screen1 = null;
AddStep("preload slow", () =>
{
screen1 = new TestScreenSlow();
screen1.AllowLoad.Set();
LoadComponentAsync(screen1);
});
pushAndEnsureCurrent(() => screen1);
}
public void TestCaseExitBeforePush()
{
TestScreen screen1 = null;
TestScreen screen2 = null;
AddStep("push slow", () => baseScreen.Push(screen1 = new TestScreenSlow()));
AddStep("exit slow", () => screen1.Exit());
AddAssert("ensure not current", () => !screen1.IsCurrentScreen);
AddWaitStep(5);
AddAssert("ensure not current", () => !screen1.IsCurrentScreen);
AddAssert("ensure base still current", () => baseScreen.IsCurrentScreen);
AddStep("push fast", () => baseScreen.Push(screen2 = new TestScreen()));
AddAssert("ensure new current", () => screen2.IsCurrentScreen);
}
public void TestMakeCurrentDuringLoad()
{
TestScreen screen1 = null;
TestScreenSlow screen2 = null;
pushAndEnsureCurrent(() => screen1 = new TestScreen());
AddStep("push slow", () => screen1.Push(screen2 = new TestScreenSlow()));
AddStep("make screen1 current", () => screen1.MakeCurrent());
AddStep("allow load of screen2", () => screen2.AllowLoad.Set());
AddUntilStep("wait for screen2 to load", () => screen2.LoadState == LoadState.Ready);
AddAssert("screen1 is current screen", () => screen1.IsCurrentScreen());
AddAssert("screen2 did not receive OnEntering", () => screen2.EnteredFrom == null);
AddAssert("screen2 did not receive OnExiting", () => screen2.ExitedTo == null);
}
public void TestAsyncDoublePush()
{
TestScreenSlow screen1 = null;
TestScreenSlow screen2 = null;
AddStep("push slow", () => stack.Push(screen1 = new TestScreenSlow()));
// important to note we are pushing to the stack here, unlike the failing case above.
AddStep("push second slow", () => stack.Push(screen2 = new TestScreenSlow()));
AddAssert("base screen registered suspend", () => baseScreen.SuspendedTo == screen1);
AddAssert("screen1 is not current", () => !screen1.IsCurrentScreen());
AddAssert("screen2 is not current", () => !screen2.IsCurrentScreen());
AddAssert("screen2 is current to stack", () => stack.CurrentScreen == screen2);
AddAssert("screen1 not registered suspend", () => screen1.SuspendedTo == null);
AddAssert("screen2 not registered entered", () => screen2.EnteredFrom == null);
AddStep("allow load 2", () => screen2.AllowLoad.Set());
// screen 2 won't actually be loading since the load is only triggered after screen1 is loaded.
AddWaitStep("wait for load", 10);
// furthermore, even though screen 2 is able to load, screen 1 has not yet so we shouldn't has received any events.
AddAssert("screen1 is not current", () => !screen1.IsCurrentScreen());
AddAssert("screen2 is not current", () => !screen2.IsCurrentScreen());
AddAssert("screen1 not registered suspend", () => screen1.SuspendedTo == null);
AddAssert("screen2 not registered entered", () => screen2.EnteredFrom == null);
AddStep("allow load 1", () => screen1.AllowLoad.Set());
AddUntilStep("screen1 is loaded", () => screen1.LoadState == LoadState.Loaded);
AddUntilStep("screen2 is loaded", () => screen2.LoadState == LoadState.Loaded);
AddUntilStep("screen1 is expired", () => !screen1.IsAlive);
AddUntilStep("screen1 is not current", () => !screen1.IsCurrentScreen());
AddUntilStep("screen2 is current", () => screen2.IsCurrentScreen());
AddAssert("screen1 registered suspend", () => screen1.SuspendedTo == screen2);
AddAssert("screen2 registered entered", () => screen2.EnteredFrom == screen1);
}
public void TestAsyncPushWithNonImmediateSuspend()
{
AddStep("override stack", () =>
{
// we can't use the [SetUp] screen stack as we need to change the ctor parameters.
Clear();
Add(stack = new ScreenStack(baseScreen = new TestScreen(), suspendImmediately: false)
{
RelativeSizeAxes = Axes.Both
});
});
TestScreenSlow screen1 = null;
AddStep("push slow", () => baseScreen.Push(screen1 = new TestScreenSlow()));
AddAssert("base screen not yet registered suspend", () => baseScreen.SuspendedTo == null);
AddAssert("ensure notcurrent", () => !screen1.IsCurrentScreen());
AddStep("allow load", () => screen1.AllowLoad.Set());
AddUntilStep("ensure current", () => screen1.IsCurrentScreen());
AddAssert("base screen registered suspend", () => baseScreen.SuspendedTo == screen1);
}
public void TestInvalidPushDoesNotBlockImmediateSuspend()
{
TestScreen screen1 = null;
TestScreenSlow screen2 = null;
AddStep("override stack", () =>
{
// we can't use the [SetUp] screen stack as we need to change the ctor parameters.
Clear();
Add(stack = new ScreenStack(baseScreen = new TestScreen(), true)
{
RelativeSizeAxes = Axes.Both
});
});
pushAndEnsureCurrent(() => screen1 = new TestScreen());
AddStep("push slow", () => screen1.Push(screen2 = new TestScreenSlow()));
AddStep("exit slow", () => screen2.Exit());
AddStep("allow load", () => screen2.AllowLoad.Set());
AddUntilStep("wait for screen 2 to load", () => screen2.LoadState >= LoadState.Ready);
AddAssert("screen 1 did receive suspending", () => screen1.SuspendedTo == screen2);
AddAssert("screen 1 did receive resumed", () => screen1.ResumedFrom == screen2);
}
public void TestMakeCurrentDuringLoadOfMany()
{
TestScreen screen1 = null;
TestScreenSlow screen2 = null;
TestScreenSlow screen3 = null;
pushAndEnsureCurrent(() => screen1 = new TestScreen(id: 1));
AddStep("push slow screen 2", () => stack.Push(screen2 = new TestScreenSlow(id: 2)));
AddStep("push slow screen 3", () => stack.Push(screen3 = new TestScreenSlow(id: 3)));
AddAssert("Screen 1 is not current", () => !screen1.IsCurrentScreen());
AddStep("Make current screen 1", () => screen1.MakeCurrent());
AddAssert("Screen 1 is current", () => screen1.IsCurrentScreen());
// Allow the screens to load out of order to test whether or not screen 3 tried to load.
// The load should be blocked since screen 2 is already exited by MakeCurrent.
AddStep("allow screen 3 to load", () => screen3.AllowLoad.Set());
AddStep("allow screen 2 to load", () => screen2.AllowLoad.Set());
AddAssert("Screen 1 is current", () => screen1.IsCurrentScreen());
AddAssert("Screen 2 did not load", () => !screen2.IsLoaded);
AddAssert("Screen 3 did not load", () => !screen3.IsLoaded);
}
public void TestNonCurrentScreenDoesNotAcceptInput()
{
ManualInputManager inputManager = null;
AddStep("override stack", () =>
{
// we can't use the [SetUp] screen stack as we need to change the ctor parameters.
Clear();
Add(inputManager = new ManualInputManager
{
Child = stack = new ScreenStack(baseScreen = new TestScreen())
{
RelativeSizeAxes = Axes.Both
}
});
});
TestScreen screen1 = null;
TestScreenSlow screen2 = null;
pushAndEnsureCurrent(() => screen1 = new TestScreen());
AddStep("Click center of screen", () => clickScreen(inputManager, screen1));
AddAssert("screen 1 clicked", () => screen1.ClickCount == 1);
AddStep("push slow", () => screen1.Push(screen2 = new TestScreenSlow()));
AddStep("Click center of screen", () => inputManager.Click(MouseButton.Left));
AddAssert("screen 1 not clicked", () => screen1.ClickCount == 1);
AddAssert("Screen 2 not clicked", () => screen2.ClickCount == 0 && !screen2.IsLoaded);
AddStep("Allow screen to load", () => screen2.AllowLoad.Set());
AddUntilStep("ensure current", () => screen2.IsCurrentScreen());
AddStep("Click center of screen", () => clickScreen(inputManager, screen2));
AddAssert("screen 1 not clicked", () => screen1.ClickCount == 1);
AddAssert("Screen 2 clicked", () => screen2.ClickCount == 1 && screen2.IsLoaded);
}
public void TestAsyncEventOrder(bool earlyExit, bool suspendImmediately)
{
if (!suspendImmediately)
{
AddStep("override stack", () =>
{
// we can't use the [SetUp] screen stack as we need to change the ctor parameters.
Clear();
Add(stack = new ScreenStack(baseScreen = new TestScreen(), suspendImmediately: false)
{
RelativeSizeAxes = Axes.Both
});
});
}
List <int> order = new List <int>();
var screen1 = new TestScreenSlow
{
Entered = () => order.Add(1),
Suspended = () => order.Add(2),
Resumed = () => order.Add(5),
};
var screen2 = new TestScreenSlow
{
Entered = () => order.Add(3),
Exited = () => order.Add(4),
};
AddStep("push slow", () => stack.Push(screen1));
AddStep("push second slow", () => stack.Push(screen2));
AddStep("allow load 1", () => screen1.AllowLoad.Set());
AddUntilStep("ensure screen1 not current", () => !screen1.IsCurrentScreen());
AddUntilStep("ensure screen2 not current", () => !screen2.IsCurrentScreen());
// but the stack has a different idea of "current"
AddAssert("ensure screen2 is current at the stack", () => stack.CurrentScreen == screen2);
if (suspendImmediately)
{
AddUntilStep("screen1's suspending fired", () => screen1.SuspendedTo == screen2);
}
else
{
AddUntilStep("screen1's entered and suspending fired", () => screen1.EnteredFrom != null);
}
if (earlyExit)
{
AddStep("early exit 2", () => screen2.Exit());
}
AddStep("allow load 2", () => screen2.AllowLoad.Set());
if (earlyExit)
{
AddAssert("screen2's entered did not fire", () => screen2.EnteredFrom == null);
AddAssert("screen2's exited did not fire", () => screen2.ExitedTo == null);
}
else
{
AddUntilStep("ensure screen2 is current", () => screen2.IsCurrentScreen());
AddAssert("screen2's entered fired", () => screen2.EnteredFrom == screen1);
AddStep("exit 2", () => screen2.Exit());
AddUntilStep("ensure screen1 is current", () => screen1.IsCurrentScreen());
AddAssert("screen2's exited fired", () => screen2.ExitedTo == screen1);
}
AddAssert("order is correct", () => order.SequenceEqual(order.OrderBy(i => i)));
}
