NavigationUnitTest.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NUnit.Framework;

namespace Xamarin.Forms.Core.UnitTests
{
	[TestFixture]
	public class NavigationUnitTest : BaseTestFixture
	{
		[Test]
		public async Task TestNavigationImplPush()
		{
			NavigationPage nav = new NavigationPage();

			Assert.IsNull(nav.RootPage);
			Assert.IsNull(nav.CurrentPage);

			Label child = new Label { Text = "Label" };
			Page childRoot = new ContentPage { Content = child };

			await nav.Navigation.PushAsync(childRoot);

			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreSame(childRoot, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task TestNavigationImplPop()
		{
			NavigationPage nav = new NavigationPage();

			Label child = new Label();
			Page childRoot = new ContentPage { Content = child };

			Label child2 = new Label();
			Page childRoot2 = new ContentPage { Content = child2 };

			await nav.Navigation.PushAsync(childRoot);
			await nav.Navigation.PushAsync(childRoot2);

			bool fired = false;
			nav.Popped += (sender, e) => fired = true;

			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreNotSame(childRoot2, nav.RootPage);
			Assert.AreNotSame(nav.RootPage, nav.CurrentPage);

			var popped = await nav.Navigation.PopAsync();

			Assert.True(fired);
			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreSame(childRoot, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
			Assert.AreEqual(childRoot2, popped);

			await nav.PopAsync();
			var last = await nav.Navigation.PopAsync();

			Assert.IsNull(last);
			Assert.IsNotNull(nav.RootPage);
			Assert.IsNotNull(nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task TestPushRoot()
		{
			NavigationPage nav = new NavigationPage();

			Assert.IsNull(nav.RootPage);
			Assert.IsNull(nav.CurrentPage);

			Label child = new Label { Text = "Label" };
			Page childRoot = new ContentPage { Content = child };

			await nav.PushAsync(childRoot);

			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreSame(childRoot, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task TestPushEvent()
		{
			NavigationPage nav = new NavigationPage();

			Label child = new Label();
			Page childRoot = new ContentPage { Content = child };

			bool fired = false;
			nav.Pushed += (sender, e) => fired = true;

			await nav.PushAsync(childRoot);

			Assert.True(fired);
		}

		[Test]
		public async Task TestDoublePush()
		{
			NavigationPage nav = new NavigationPage();

			Label child = new Label();
			Page childRoot = new ContentPage { Content = child };

			await nav.PushAsync(childRoot);

			bool fired = false;
			nav.Pushed += (sender, e) => fired = true;

			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreSame(childRoot, nav.CurrentPage);

			await nav.PushAsync(childRoot);

			Assert.False(fired);
			Assert.AreSame(childRoot, nav.RootPage);
			Assert.AreSame(childRoot, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task TestPop()
		{
			NavigationPage nav = new NavigationPage();

			Label child = new Label();
			Page childRoot = new ContentPage { Content = child };

			Label child2 = new Label();
			Page childRoot2 = new ContentPage { Content = child2 };

			await nav.PushAsync(childRoot);
			await nav.PushAsync(childRoot2);

			bool fired = false;
			nav.Popped += (sender, e) => fired = true;
			var popped = await nav.PopAsync();

			Assert.True(fired);
			Assert.AreSame(childRoot, nav.CurrentPage);
			Assert.AreEqual(childRoot2, popped);

			await nav.PopAsync();
			var last = await nav.PopAsync();

			Assert.IsNull(last);
		}

		[Test]
		public void TestTint()
		{
			var nav = new NavigationPage();

			Assert.AreEqual(Color.Default, nav.Tint);

			bool signaled = false;
			nav.PropertyChanged += (sender, args) =>
			{
				if (args.PropertyName == "Tint")
					signaled = true;
			};

			nav.Tint = new Color(1, 0, 0);

			Assert.AreEqual(new Color(1, 0, 0), nav.Tint);
			Assert.True(signaled);
		}

		[Test]
		public void TestTintDoubleSet()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PropertyChanged += (sender, args) =>
			{
				if (args.PropertyName == "Tint")
					signaled = true;
			};

			nav.Tint = nav.Tint;

			Assert.False(signaled);
		}

		[Test]
		public async Task TestPopToRoot()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			nav.PopToRootAsync();

			Assert.True(signaled);
			Assert.AreSame(root, nav.RootPage);
			Assert.AreSame(root, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task TestPopToRootEventArgs()
		{
			var nav = new NavigationPage();

			List<Page> poppedChildren = null;
			nav.PoppedToRoot += (sender, args) => poppedChildren = (args as PoppedToRootEventArgs).PoppedPages.ToList();

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			await nav.PopToRootAsync();

			Assert.IsNotNull(poppedChildren);
			Assert.AreEqual(2, poppedChildren.Count);
			Assert.Contains(child1, poppedChildren);
			Assert.Contains(child2, poppedChildren);
			Assert.AreSame(root, nav.RootPage);
			Assert.AreSame(root, nav.CurrentPage);
			Assert.AreSame(nav.RootPage, nav.CurrentPage);
		}

		[Test]
		public async Task PeekOne()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			Assert.AreEqual(((INavigationPageController)nav).Peek(1), child1);
		}

		[Test]
		public async Task PeekZero()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			Assert.AreEqual(((INavigationPageController)nav).Peek(0), child2);
			Assert.AreEqual(((INavigationPageController)nav).Peek(), child2);
		}

		[Test]
		public async Task PeekPastStackDepth()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			Assert.AreEqual(((INavigationPageController)nav).Peek(3), null);
		}

		[Test]
		public async Task PeekShallow()
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			var root = new ContentPage { Content = new View() };
			var child1 = new ContentPage { Content = new View() };
			var child2 = new ContentPage { Content = new View() };

			await nav.PushAsync(root);
			await nav.PushAsync(child1);
			await nav.PushAsync(child2);

			Assert.AreEqual(((INavigationPageController)nav).Peek(-1), null);
		}

		[Test]
		public async Task PeekEmpty([Range(0, 3)] int depth)
		{
			var nav = new NavigationPage();

			bool signaled = false;
			nav.PoppedToRoot += (sender, args) => signaled = true;

			Assert.AreEqual(((INavigationPageController)nav).Peek(depth), null);
		}


		[Test]
		public void ConstructWithRoot()
		{
			var root = new ContentPage();
			var nav = new NavigationPage(root);


			Assert.AreEqual(1, ((INavigationPageController)nav).StackDepth);
			Assert.AreEqual(root, ((IElementController)nav).LogicalChildren[0]);

		}

		[Test]
		public void TitleViewSetProperty()
		{
			var root = new ContentPage();
			var nav = new NavigationPage(root);

			View target = new View();

			NavigationPage.SetTitleView(root, target);

			var result = NavigationPage.GetTitleView(root);

			Assert.AreSame(result, target);
		}

		[Test]
		public void TitleViewSetsParentWhenAdded()
		{
			var root = new ContentPage();
			var nav = new NavigationPage(root);

			View target = new View();

			NavigationPage.SetTitleView(root, target);

			Assert.AreSame(root, target.Parent);
		}

		[Test]
		public void TitleViewClearsParentWhenRemoved()
		{
			var root = new ContentPage();
			var nav = new NavigationPage(root);

			View target = new View();

			NavigationPage.SetTitleView(root, target);

			NavigationPage.SetTitleView(root, null);

			Assert.IsNull(target.Parent);
		}

		[Test]
		public async Task NavigationChangedEventArgs()
		{
			var rootPage = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(rootPage);

			var rootArg = new Page();

			navPage.Pushed += (s, e) =>
			{
				rootArg = e.Page;
			};

			var pushPage = new ContentPage
			{
				Title = "Page 2"
			};

			await navPage.PushAsync(pushPage);

			Assert.AreEqual(rootArg, pushPage);

			var secondPushPage = new ContentPage
			{
				Title = "Page 3"
			};

			await navPage.PushAsync(secondPushPage);

			Assert.AreEqual(rootArg, secondPushPage);
		}

		[Test]
		public async Task CurrentPageChanged()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);

			bool changing = false;
			navPage.PropertyChanging += (object sender, PropertyChangingEventArgs e) =>
			{
				if (e.PropertyName == NavigationPage.CurrentPageProperty.PropertyName)
				{
					Assert.That(navPage.CurrentPage, Is.SameAs(root));
					changing = true;
				}
			};

			var next = new ContentPage { Title = "Next" };

			bool changed = false;
			navPage.PropertyChanged += (sender, e) =>
			{
				if (e.PropertyName == NavigationPage.CurrentPageProperty.PropertyName)
				{
					Assert.That(navPage.CurrentPage, Is.SameAs(next));
					changed = true;
				}
			};

			await navPage.PushAsync(next);

			Assert.That(changing, Is.True, "PropertyChanging was not raised for 'CurrentPage'");
			Assert.That(changed, Is.True, "PropertyChanged was not raised for 'CurrentPage'");
		}

		[Test]
		public async Task HandlesPopToRoot()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);

			await navPage.PushAsync(new ContentPage());
			await navPage.PushAsync(new ContentPage());

			bool popped = false;
			navPage.PoppedToRoot += (sender, args) =>
			{
				popped = true;
			};

			await navPage.Navigation.PopToRootAsync();

			Assert.True(popped);
		}

		[Test]
		public void SendsBackButtonEventToCurrentPage()
		{
			var current = new BackButtonPage();
			var navPage = new NavigationPage(current);

			var emitted = false;
			current.BackPressed += (sender, args) => emitted = true;

			navPage.SendBackButtonPressed();

			Assert.True(emitted);
		}

		[Test]
		public void DoesNotSendBackEventToNonCurrentPage()
		{
			var current = new BackButtonPage();
			var navPage = new NavigationPage(current);
			navPage.PushAsync(new ContentPage());

			var emitted = false;
			current.BackPressed += (sender, args) => emitted = true;

			navPage.SendBackButtonPressed();

			Assert.False(emitted);
		}

		[Test]
		public async Task NavigatesBackWhenBackButtonPressed()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);

			await navPage.PushAsync(new ContentPage());

			var result = navPage.SendBackButtonPressed();

			Assert.AreEqual(root, navPage.CurrentPage);
			Assert.True(result);
		}

		[Test]
		public async Task DoesNotNavigatesBackWhenBackButtonPressedIfHandled()
		{
			var root = new BackButtonPage { Title = "Root" };
			var second = new BackButtonPage() { Handle = true };
			var navPage = new NavigationPage(root);

			await navPage.PushAsync(second);

			navPage.SendBackButtonPressed();

			Assert.AreEqual(second, navPage.CurrentPage);
		}

		[Test]
		public void DoesNotHandleBackButtonWhenNoNavStack()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);

			var result = navPage.SendBackButtonPressed();
			Assert.False(result);
		}

		[Test]
		public void TestInsertPage()
		{
			var root = new ContentPage { Title = "Root" };
			var newPage = new ContentPage();
			var navPage = new NavigationPage(root);

			navPage.Navigation.InsertPageBefore(newPage, navPage.RootPage);

			Assert.AreSame(newPage, navPage.RootPage);
			Assert.AreNotSame(newPage, navPage.CurrentPage);
			Assert.AreNotSame(navPage.RootPage, navPage.CurrentPage);
			Assert.AreSame(root, navPage.CurrentPage);

			Assert.Throws<ArgumentException>(() =>
			{
				navPage.Navigation.InsertPageBefore(new ContentPage(), new ContentPage());
			});

			Assert.Throws<ArgumentException>(() =>
			{
				navPage.Navigation.InsertPageBefore(navPage.RootPage, navPage.CurrentPage);
			});

			Assert.Throws<ArgumentNullException>(() =>
			{
				navPage.Navigation.InsertPageBefore(null, navPage.CurrentPage);
			});

			Assert.Throws<ArgumentNullException>(() =>
			{
				navPage.Navigation.InsertPageBefore(new ContentPage(), null);
			});
		}

		[Test]
		public async Task TestRemovePage()
		{
			var root = new ContentPage { Title = "Root" };
			var newPage = new ContentPage();
			var navPage = new NavigationPage(root);
			await navPage.PushAsync(newPage);

			navPage.Navigation.RemovePage(root);

			Assert.AreSame(newPage, navPage.RootPage);
			Assert.AreSame(newPage, navPage.CurrentPage);
			Assert.AreSame(navPage.RootPage, navPage.CurrentPage);
			Assert.AreNotSame(root, navPage.CurrentPage);

			Assert.Throws<ArgumentException>(() =>
			{
				navPage.Navigation.RemovePage(root);
			});

			Assert.Throws<InvalidOperationException>(() =>
			{
				navPage.Navigation.RemovePage(newPage);
			});

			Assert.Throws<ArgumentNullException>(() =>
			{
				navPage.Navigation.RemovePage(null);
			});
		}

		[Test(Description = "CurrentPage should not be set to null when you attempt to pop the last page")]
		[Property("Bugzilla", 28335)]
		public async Task CurrentPageNotNullPoppingRoot()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);
			var popped = await navPage.PopAsync();
			Assert.That(popped, Is.Null);
			Assert.That(navPage.CurrentPage, Is.SameAs(root));
		}

		[Test]
		[Property("Bugzilla", 31171)]
		public async Task ReleasesPoppedPage()
		{
			var root = new ContentPage { Title = "Root" };
			var navPage = new NavigationPage(root);

			var isFinalized = false;

			await navPage.PushAsync(new PageWithFinalizer(() => isFinalized = true));
			await navPage.PopAsync();

			await Task.Delay(100);

			GC.Collect();
			GC.WaitForPendingFinalizers();

			Assert.IsTrue(isFinalized);
		}
	}

	internal class BackButtonPage : ContentPage
	{
		public event EventHandler BackPressed;

		public bool Handle = false;

		protected override bool OnBackButtonPressed()
		{
			if (BackPressed != null)
				BackPressed(this, EventArgs.Empty);
			return Handle;
		}
	}

	internal class PageWithFinalizer : Page
	{
		Action OnFinalize;
		public PageWithFinalizer(Action onFinalize)
		{
			OnFinalize = onFinalize;
		}

		~PageWithFinalizer()
		{
			OnFinalize();
		}
	}
}