Esempio n. 1
0
        public async Task TestPop(bool useMaui)
        {
            NavigationPage nav = new TestNavigationPage(useMaui);

            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);
        }
Esempio n. 2
0
        public async Task PopLifeCycle(bool useMaui)
        {
            ContentPage initialPage = new ContentPage();
            ContentPage pushedPage  = new ContentPage();

            ContentPage rootPageFiresAppearingAfterPop = null;
            ContentPage pageDisappeared = null;

            NavigationPage nav = new TestNavigationPage(useMaui, initialPage);

            _ = new Window(nav);
            nav.SendAppearing();

            initialPage.Appearing += (sender, _)
                                     => rootPageFiresAppearingAfterPop = (ContentPage)sender;

            pushedPage.Disappearing += (sender, _)
                                       => pageDisappeared = (ContentPage)sender;

            await nav.PushAsync(pushedPage);

            Assert.IsNull(rootPageFiresAppearingAfterPop);
            Assert.IsNull(pageDisappeared);

            await nav.PopAsync();

            Assert.AreEqual(initialPage, rootPageFiresAppearingAfterPop);
            Assert.AreEqual(pushedPage, pageDisappeared);
        }
Esempio n. 3
0
        public async Task CurrentPageNotNullPoppingRoot(bool useMaui)
        {
            var root = new ContentPage {
                Title = "Root"
            };
            var navPage = new TestNavigationPage(useMaui, root);
            var popped  = await navPage.PopAsync();

            Assert.That(popped, Is.Null);
            Assert.That(navPage.CurrentPage, Is.SameAs(root));
        }
Esempio n. 4
0
        public async Task NavigationPagePopPage(bool useMaui)
        {
            var firstPage  = new LCPage();
            var poppedPage = new LCPage();

            NavigationPage navigationPage = new TestNavigationPage(useMaui, firstPage);
            await navigationPage.PushAsync(poppedPage);

            await navigationPage.PopAsync();

            Assert.IsNotNull(poppedPage.NavigatingFromArgs);
            Assert.AreEqual(poppedPage, firstPage.NavigatedToArgs.PreviousPage);
            Assert.AreEqual(firstPage, poppedPage.NavigatedFromArgs.DestinationPage);
        }
Esempio n. 5
0
        public async Task CurrentPageUpdatesOnPopBeforeAsyncCompletes()
        {
            var root = new ContentPage {
                Title = "Root"
            };
            var navPage = new TestNavigationPage(true, root);
            await navPage.PushAsync(new ContentPage());

            var popped = navPage.PopAsync();

            Assert.AreEqual(navPage.CurrentPage, root);
            await popped;

            Assert.AreEqual(navPage.CurrentPage, root);
        }
Esempio n. 6
0
        public async Task ReleasesPoppedPage(bool useMaui)
        {
            var root = new ContentPage {
                Title = "Root"
            };
            var navPage = new TestNavigationPage(useMaui, 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);
        }