Xamarin.Forms/Xamarin.Forms.Core.UnitTests/MultiPageTests.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using NUnit.Framework;

namespace Xamarin.Forms.Core.UnitTests
{
	public abstract class MultiPageTests<T> : BaseTestFixture
		where T : Page
	{
		protected abstract MultiPage<T> CreateMultiPage();
		protected abstract T CreateContainedPage();
		protected abstract int GetIndex(T page);

		[SetUp]
		public override void Setup()
		{
			base.Setup();
			Device.PlatformServices = new MockPlatformServices();
		}

		[TearDown]
		public override void TearDown()
		{
			base.TearDown();
			Device.PlatformServices = null;
		}

		[Test]
		public void TestSetChildren()
		{
			var container = CreateMultiPage();
			var page = (Page)container;

			int childCount = 0;
			page.ChildAdded += (sender, args) => childCount++;

			int pagesAdded = 0;
			container.PagesChanged += (sender, args) =>
			{
				if (args.Action == NotifyCollectionChangedAction.Add)
					pagesAdded++;
			};

			container.Children.Add(CreateContainedPage());
			container.Children.Add(CreateContainedPage());

			Assert.AreEqual(2, childCount);
			Assert.AreEqual(2, ((IElementController)page).LogicalChildren.Count);
			Assert.AreEqual(2, pagesAdded);
		}

		[Test]
		public void TestOverwriteChildren()
		{
			var page = CreateMultiPage();
			page.Children.Add(CreateContainedPage());
			page.Children.Add(CreateContainedPage());

			int childCount = 0;
			int removeCount = 0;
			page.ChildAdded += (sender, args) => childCount++;
			page.ChildRemoved += (sender, args) => removeCount++;

			foreach (var child in page.Children.ToArray())
				page.Children.Remove((T)child);

			page.Children.Add(CreateContainedPage());
			page.Children.Add(CreateContainedPage());

			Assert.AreEqual(2, removeCount);
			Assert.AreEqual(2, childCount);
			Assert.AreEqual(2, ((IElementController)page).LogicalChildren.Count);
		}

		[Test]
		public void CurrentPageSetAfterAdd()
		{
			var page = CreateMultiPage();
			Assert.That(page.CurrentPage, Is.Null);

			var child = CreateContainedPage();

			bool property = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					property = true;
			};

			page.Children.Add(child);

			Assert.That(page.CurrentPage, Is.SameAs(child));
			Assert.That(property, Is.True, "CurrentPage property change did not fire");
		}

		[Test]
		public void CurrentPageChangedAfterRemove()
		{
			var page = CreateMultiPage();
			var child = CreateContainedPage();
			var child2 = CreateContainedPage();
			page.Children.Add(child);
			page.Children.Add(child2);

			bool property = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					property = true;
			};

			page.Children.Remove(child);

			Assert.That(page.CurrentPage, Is.SameAs(child2), "MultiPage.CurrentPage is not set to a new page after current was removed");
			Assert.That(property, Is.True, "CurrentPage property change did not fire");
		}

		[Test]
		public void CurrentPageNullAfterRemove()
		{
			var page = CreateMultiPage();
			var child = CreateContainedPage();
			page.Children.Add(child);

			bool property = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					property = true;
			};

			page.Children.Remove(child);

			Assert.That(page.CurrentPage, Is.Null, "MultiPage.CurrentPage is still set after that page was removed");
			Assert.That(property, Is.True, "CurrentPage property change did not fire");
		}

		[Test]
		public void TemplatedPage()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			page.ItemsSource = new[] { "Foo", "Bar" };

			Action<Page, string> assertPage = (p, s) =>
			{
				Assert.That(p, Is.InstanceOf<ContentPage>());

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(2));
			assertPage((Page)pages[0], "Foo");
			assertPage((Page)pages[1], "Bar");
		}

		[Test]
		public void SelectedItemSetAfterAdd()
		{
			var page = CreateMultiPage();
			Assert.That(page.CurrentPage, Is.Null);

			var items = new ObservableCollection<string>();

			page.ItemsSource = items;

			bool selected = false;
			bool current = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					current = true;
				else if (e.PropertyName == "SelectedItem")
					selected = true;
			};

			items.Add("foo");

			Assert.That(page.SelectedItem, Is.SameAs(items.First()));
			Assert.That(page.CurrentPage.BindingContext, Is.SameAs(page.SelectedItem));
			Assert.That(current, Is.True, "CurrentPage property change did not fire");
			Assert.That(selected, Is.True, "SelectedItem property change did not fire");
		}

		[Test]
		public void SelectedItemNullAfterRemove()
		{
			var page = CreateMultiPage();
			Assert.That(page.CurrentPage, Is.Null);

			var items = new ObservableCollection<string> { "foo" };
			page.ItemsSource = items;

			bool selected = false;
			bool current = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					current = true;
				else if (e.PropertyName == "SelectedItem")
					selected = true;
			};

			items.Remove("foo");

			Assert.That(page.SelectedItem, Is.Null, "MultiPage.SelectedItem is still set after that page was removed");
			Assert.That(page.CurrentPage, Is.Null, "MultiPage.CurrentPage is still set after that page was removed");
			Assert.That(current, Is.True, "CurrentPage property change did not fire");
			Assert.That(selected, Is.True, "SelectedItem property change did not fire");
		}

		[Test]
		[Description("When ItemsSource is set with items, the first item should automatically be selected")]
		public void SelectedItemSetAfterItemsSourceSet()
		{
			var page = CreateMultiPage();

			bool selected = false;
			bool current = false;
			page.PropertyChanged += (o, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					current = true;
				else if (e.PropertyName == "SelectedItem")
					selected = true;
			};

			page.ItemsSource = new[] { "foo" };

			Assert.That(page.SelectedItem, Is.SameAs(((string[])page.ItemsSource)[0]));
			Assert.That(page.CurrentPage.BindingContext, Is.SameAs(page.SelectedItem));
			Assert.That(current, Is.True, "CurrentPage property change did not fire");
			Assert.That(selected, Is.True, "SelectedItem property change did not fire");
		}

		[Test]
		public void SelectedItemNoLongerPresent()
		{
			var page = CreateMultiPage();

			string[] items = new[] { "foo", "bar" };
			page.ItemsSource = items;
			page.SelectedItem = items[1];

			items = new[] { "fad", "baz" };
			page.ItemsSource = items;

			Assert.That(page.SelectedItem, Is.SameAs(items[0]));
		}

		[Test]
		public void SelectedItemAfterMove()
		{
			var page = CreateMultiPage();

			var items = new ObservableCollection<string> { "foo", "bar" };
			page.ItemsSource = items;

			Assert.That(page.SelectedItem, Is.SameAs(items[0]));
			Assert.That(page.CurrentPage, Is.Not.Null);
			Assert.That(page.CurrentPage.BindingContext, Is.SameAs(items[0]));

			page.SelectedItem = items[1];
			Assert.That(page.CurrentPage.BindingContext, Is.SameAs(items[1]));

			items.Move(1, 0);

			Assert.That(page.SelectedItem, Is.SameAs(items[0]));
			Assert.That(page.CurrentPage, Is.Not.Null);
			Assert.That(page.CurrentPage.BindingContext, Is.SameAs(items[0]));
		}

		[Test]
		public void UntemplatedItemsSourcePage()
		{
			var page = CreateMultiPage();

			page.ItemsSource = new[] { "Foo", "Bar" };

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(2));
			Assert.That(((Page)pages[0]).Title, Is.EqualTo("Foo"));
			Assert.That(((Page)pages[1]).Title, Is.EqualTo("Bar"));
		}

		[Test]
		public void TemplatePagesAdded()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableCollection<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Add("Baz");

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(3), "Children should have 3 pages");
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Bar");
			assertPage(pages, 2, "Baz");
		}

		[Test]
		public void TemplatePagesRangeAdded()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableList<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			int addedCount = 0;
			page.PagesChanged += (sender, e) =>
			{
				if (e.Action != NotifyCollectionChangedAction.Add)
					return;

				addedCount++;
				Assert.That(e.NewItems.Count, Is.EqualTo(2));
			};

			items.AddRange(new[] { "Baz", "Bam" });

			Assert.That(addedCount, Is.EqualTo(1));

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(4));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Bar");
			assertPage(pages, 2, "Baz");
			assertPage(pages, 3, "Bam");
		}

		[Test]
		public void TemplatePagesInserted()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableCollection<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Insert(1, "Baz");

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(3));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Baz");
			assertPage(pages, 2, "Bar");
		}

		[Test]
		public void TemplatePagesRangeInserted()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableList<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.InsertRange(1, new[] { "Baz", "Bam" });

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(4));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Baz");
			assertPage(pages, 2, "Bam");
			assertPage(pages, 3, "Bar");
		}

		[Test]
		public void TemplatePagesRemoved()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableCollection<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Remove("Foo");

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(1));
			assertPage(pages, 0, "Bar");
		}

		[Test]
		public void TemplatePagesRangeRemoved()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableList<string> { "Foo", "Bar", "Baz", "Bam", "Who" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.RemoveAt(1, 2);

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(3));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Bam");
			assertPage(pages, 2, "Who");
		}

		[Test]
		public void TemplatePagesReordered()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableCollection<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Move(0, 1);

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(2));
			assertPage(pages, 0, "Bar");
			assertPage(pages, 1, "Foo");
		}

		[Test]
		public void TemplatePagesRangeReorderedForward()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableList<string> { "Foo", "Bar", "Baz", "Bam", "Who", "Where" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Move(1, 4, 2);

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(6));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Bam");
			assertPage(pages, 2, "Who");
			assertPage(pages, 3, "Bar");
			assertPage(pages, 4, "Baz");
			assertPage(pages, 5, "Where");
		}

		[Test]
		public void TemplatePagesRangeReorderedBackward()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableList<string> { "Foo", "Bar", "Baz", "Bam", "Who", "Where", "When" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items.Move(4, 1, 2);

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(7));
			assertPage(pages, 0, "Foo");
			assertPage(pages, 1, "Who");
			assertPage(pages, 2, "Where");
			assertPage(pages, 3, "Bar");
			assertPage(pages, 4, "Baz");
			assertPage(pages, 5, "Bam");
			assertPage(pages, 6, "When");
		}

		[Test]
		public void TemplatePagesReplaced()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			var items = new ObservableCollection<string> { "Foo", "Bar" };
			page.ItemsSource = items;

			Action<IList<Element>, int, string> assertPage = (ps, index, s) =>
			{
				Page p = (Page)ps[index];
				Assert.That(p, Is.InstanceOf<ContentPage>());
				Assert.That(GetIndex((T)p), Is.EqualTo(index));

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			items[0] = "Baz";

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(2));
			assertPage(pages, 0, "Baz");
			assertPage(pages, 1, "Bar");
		}

		[Test]
		public void TemplatedPagesSourceReplaced()
		{
			var page = CreateMultiPage();

			page.ItemTemplate = new DataTemplate(() =>
			{
				var p = new ContentPage();
				p.Content = new Label();
				p.Content.SetBinding(Label.TextProperty, new Binding("."));
				return p;
			});

			page.ItemsSource = new ObservableCollection<string> { "Foo", "Bar" };

			Action<Page, string> assertPage = (p, s) =>
			{
				Assert.That(p, Is.InstanceOf<ContentPage>());

				var cp = (ContentPage)p;
				Assert.That(cp.Content, Is.InstanceOf<Label>());
				Assert.That(((Label)cp.Content).Text, Is.EqualTo(s));
			};

			page.ItemsSource = new ObservableCollection<string> { "Baz", "Bar" };

			var pages = page.Children.ToArray();
			Assert.That(pages.Length, Is.EqualTo(2));
			assertPage((Page)pages[0], "Baz");
			assertPage((Page)pages[1], "Bar");
		}

		[Test]
		[Description("If you have a templated set of items, setting CurrentPage (usually from renderers) should update SelectedItem properly")]
		public void SettingCurrentPageWithTemplatesUpdatesSelectedItem()
		{
			var page = CreateMultiPage();

			var items = new[] { "Foo", "Bar" };
			page.ItemsSource = items;

			// If these aren't correct, the rest of the test is invalid
			Assert.That(page.CurrentPage, Is.SameAs(page.Children[0]));
			Assert.That(page.SelectedItem, Is.SameAs(items[0]));

			page.CurrentPage = (T)page.Children[1];

			Assert.That(page.SelectedItem, Is.SameAs(items[1]));
		}

		[Test]
		public void PagesChangedOnItemsSourceChange()
		{
			var page = CreateMultiPage();

			page.ItemsSource = new[] { "Baz", "Bam" };

			int fail = 0;
			int reset = 0;
			page.PagesChanged += (sender, args) =>
			{
				if (args.Action == NotifyCollectionChangedAction.Reset)
					reset++;
				else
					fail++;
			};

			page.ItemsSource = new[] { "Foo", "Bar" };

			Assert.That(reset, Is.EqualTo(1), "PagesChanged wasn't raised or was raised too many times for Reset");
			Assert.That(fail, Is.EqualTo(0), "PagesChanged was raised with an unexpected action");
		}

		[Test]
		public void PagesChangedOnTemplateChange()
		{
			var page = CreateMultiPage();

			page.ItemsSource = new[] { "Foo", "Bar" };

			int fail = 0;
			int reset = 0;
			page.PagesChanged += (sender, args) =>
			{
				if (args.Action == NotifyCollectionChangedAction.Reset)
					reset++;
				else
					fail++;
			};

			page.ItemTemplate = new DataTemplate(() => new ContentPage
			{
				Content = new Label { Text = "Content" }
			});

			Assert.That(reset, Is.EqualTo(1), "PagesChanged wasn't raised or was raised too many times for Reset");
			Assert.That(fail, Is.EqualTo(0), "PagesChanged was raised with an unexpected action");
		}

		[Test]
		public void SelectedItemSetBeforeTemplate()
		{
			var page = CreateMultiPage();

			string[] items = new[] { "foo", "bar" };
			page.ItemsSource = items;
			page.SelectedItem = items[1];

			var template = new DataTemplate(typeof(ContentPage));
			template.SetBinding(ContentPage.TitleProperty, ".");
			page.ItemTemplate = template;

			Assert.That(page.SelectedItem, Is.SameAs(items[1]));
		}

		[Test]
		public void CurrentPageUpdatedWithTemplate()
		{
			var page = CreateMultiPage();
			string[] items = new[] { "foo", "bar" };
			page.ItemsSource = items;

			var untemplated = page.CurrentPage;

			bool raised = false;
			page.PropertyChanged += (sender, e) =>
			{
				if (e.PropertyName == "CurrentPage")
					raised = true;
			};

			var template = new DataTemplate(() =>
			{
				var p = new ContentPage { Content = new Label() };
				p.Content.SetBinding(Label.TextProperty, ".");
				return p;
			});

			page.ItemTemplate = template;

			Assert.That(raised, Is.True, "CurrentPage did not change with the template");
			Assert.That(page.CurrentPage, Is.Not.SameAs(untemplated));
		}

		[Test]
		public void CurrentPageChanged()
		{
			var page = CreateMultiPage();
			page.Children.Add(CreateContainedPage());
			page.Children.Add(CreateContainedPage());

			bool raised = false;
			page.CurrentPageChanged += (sender, e) =>
			{
				raised = true;
			};

			page.CurrentPage = page.Children[0];

			Assert.That(raised, Is.False);

			page.CurrentPage = page.Children[1];

			Assert.That(raised, Is.True);
		}
	}
}