using Annulus;
using Azimuth;
using Clave;
using System;
using System.Collections.Generic;
using UnitTestSharp;
using Listener = Glass.UnitTests.FileDialogModelTests.Listener;

namespace Glass.UnitTests
{
    public class FileDialogTests : TestFixture
    {
        public static readonly FileFilter TextFiles = new FileFilter("Text files", new[] { ".txt" });

        public static readonly FileFilter MarkdownFiles = new FileFilter("Markdown files", new[] { ".md" });

        public static readonly ButtonMaterial Row = DropdownTests.Arrow(1, 1);

        public static readonly ButtonMaterial SelectedRow = DropdownTests.Arrow(2, 2);

        /// <summary>
        /// One line of this is 20 high.
        /// </summary>
        public static readonly TextStyle LabelStyle = TextStyleTests.WithFont() with { VerticalMargin = 8 };

        /// <summary>
        /// Buttons of 50 by 20, each a 46 by 16 body inside a 2 thick border.
        /// </summary>
        public static readonly FileDialogMaterial Measurements = new FileDialogMaterial
        {
            Spacing = 4,
            UpButton = ButtonOf(46, 16),
            NewFolderButton = ButtonOf(46, 16),
            AcceptButton = ButtonOf(46, 16),
            CancelButton = ButtonOf(46, 16),
            EntryRow = Row,
            SelectedEntryRow = SelectedRow,
            TextStyle = LabelStyle,
            OverwriteQuestionFormat = "'{0}' already exists.  Replace it?",
            OverwriteBox = new MessageBoxMaterial { TextStyle = LabelStyle, Spacing = 4 }
                .WithButton(FileDialog.OverwriteAnswer.Replace, ButtonOf(46, 16))
                .WithButton(FileDialog.OverwriteAnswer.Cancel, ButtonOf(46, 16)),
            MinimumEntryRows = 3,
        };

        /// <summary>
        /// Everything that gets built for a dialog, in the order it was asked for.
        /// </summary>
        public class Built
        {
            public readonly List<string> Entries = new List<string>();
        }

        /// <summary>
        /// The size the dialog's text controls give <paramref name="text"/> in the label style.
        /// </summary>
        public static Vector TextSize(string text)
        {
            return new TextMaterial { Text = text, Style = LabelStyle }.PreferredSize(Constraints.Unbounded);
        }

        public static string QuestionText(string name)
        {
            return $"'{name}' already exists.  Replace it?";
        }

        [IgnoreTest]
        public static string AskedText(FileDialog dialog)
        {
            return ((Label)MessageBoxTests.MessageOf(dialog.OverwriteBox)).Text.ToString();
        }

        [IgnoreTest]
        public static Button AnswerButton(FileDialog dialog, FileDialog.OverwriteAnswer answer)
        {
            return dialog.OverwriteBox.ButtonFor(answer);
        }

        [IgnoreTest]
        public static string[] TextsOf(Dropdown dropdown)
        {
            var returnMe = new List<string>();
            foreach (Control row in DropdownTests.Rows(dropdown))
            {
                returnMe.Add(((TextMaterial)DropdownTests.ItemOf(row).Material).Text.ToString());
            }

            return returnMe.ToArray();
        }

        public static Control Sized(Scalar width, Scalar height)
        {
            return new Panel { Bounds = Box(0, 0, width, height) };
        }

        /// <summary>
        /// A button whose body wants exactly this much room, inside a border of the given thickness.
        /// </summary>
        public static ButtonMaterial ButtonOf(Scalar width, Scalar height, int border = 2)
        {
            Material body = new ScrollViewTests.SizedSolidMaterial(new Vector(width, height));

            return new ButtonMaterial(ScrollViewTests.Bordered(border, "button").Framing(body));
        }

        public static FileDialogMaterial WithEveryButton(FileDialogMaterial material, ButtonMaterial button)
        {
            return material with
            {
                UpButton = button,
                NewFolderButton = button,
                AcceptButton = button,
                CancelButton = button,
            };
        }

        /// <summary>
        /// Builds a dialog whose entries are 10 by 20, unless told otherwise.
        /// </summary>
        public static FileDialog NewDialog(
            FileDialogMode mode = FileDialogMode.Open, IReadOnlyList<FileFilter> filters = null,
            Built built = null, string startDirectory = null, FileDialogMaterial? material = null,
            Func<string, Vector> entrySize = null)
        {
            built = built ?? new Built();

            FileDialogModel model =
                FileDialogModel.Create(InMemoryFileSystemTests.Sample(), mode, filters, startDirectory).Value;
            var dialog = new FileDialog(
                model,
                entry =>
                {
                    built.Entries.Add(entry.Name);
                    return Sized(entrySize?.Invoke(entry.Name) ?? new Vector(10, 20));
                },
                DialogBehavior.Default);

            dialog.FileDialogMaterial = material ?? Measurements;
            dialog.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(300, 300));

            return dialog;
        }

        public static Control Sized(Vector size)
        {
            return Sized(size.X, size.Y);
        }

        public static Rect Box(Scalar x, Scalar y, Scalar width, Scalar height)
        {
            return Rect.FromPositionAndSize(new Vector(x, y), new Vector(width, height));
        }

        public static void Click(Button button, int clickCount = 1)
        {
            button.Click(default, MouseButtonFlags.Left, clickCount);
        }

        [IgnoreTest]
        public static Button[] RowsOf(FileDialog dialog)
        {
            var returnMe = new List<Button>();
            foreach (Control row in dialog.EntryList.CanvasChildren.BackToFront())
            {
                returnMe.Add((Button)row);
            }

            return returnMe.ToArray();
        }

        [IgnoreTest]
        public static int ChildCount(Control parent)
        {
            int returnMe = 0;
            foreach (Control child in parent.CanvasChildren.BackToFront())
            {
                ++returnMe;
            }

            return returnMe;
        }

        public class CtorTests : TestFixture
        {
            [IgnoreTest]
            public static FileDialog Construct(
                FileDialogModel model = null, Func<FileEntry, Control> buildEntry = null)
            {
                return new FileDialog(
                    model ?? FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open).Value,
                    buildEntry ?? (_ => new Panel()),
                    DialogBehavior.Default);
            }

            public void Always_KeepsTheModel()
            {
                FileDialogModel model =
                    FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open).Value;

                CheckEqual(model, Construct(model: model).Model);
            }

            public void Always_ShowsTheModelsDirectoryAndNoStatus()
            {
                FileDialog dialog = NewDialog();

                CheckEqual("/", dialog.DirectoryLabel.Text.ToString());
                CheckEqual("", dialog.FileNameLabel.Text.ToString());
                CheckEqual("", dialog.StatusLabel.Text.ToString());
            }

            public void Always_BuildsARowPerEntryDirectoriesFirst()
            {
                var built = new Built();

                NewDialog(built: built);

                CheckEqual(new[] { "docs", "music", "top.txt" }, built.Entries.ToArray());
            }

            public void Always_BuildsAFilterRowPerFilterFromItsDescription()
            {
                FileDialog dialog = NewDialog(filters: new[] { TextFiles, MarkdownFiles });

                CheckEqual(new[] { "Text files", "Markdown files" }, TextsOf(dialog.FilterDropdown));
            }

            public void Always_StartsWithTheOverwriteQuestionClosedAndUnskippable()
            {
                FileDialog dialog = NewDialog();

                CheckFalse(dialog.OverwriteBox.IsOpen);
                CheckFalse(dialog.OverwriteBox.DismissOnOutsidePress);
            }

            public void Always_StartsWithNoSuggestedNames()
            {
                FileDialog dialog = NewDialog();

                CheckEqual(0, dialog.SuggestedNames.Count);
                CheckFalse(dialog.NameSuggestions.Visible);
            }

            public void NullModel_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new FileDialog(null, _ => new Panel(), DialogBehavior.Default);
            }

            public void NullEntryBuilder_Throws()
            {
                FileDialogModel model =
                    FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open).Value;

                CheckThrow(typeof(ArgumentNullException));
                new FileDialog(model, null, DialogBehavior.Default);
            }


        }

        public class ArrangementTests : TestFixture
        {
            public void Toolbar_HoldsUpAndNewFolderAtTheEndsAndTheDirectoryBetween()
            {
                FileDialog dialog = NewDialog();

                CheckEqual(Box(4, 4, 50, 20), dialog.UpButton.Bounds);
                CheckEqual(Box(246, 4, 50, 20), dialog.NewFolderButton.Bounds);
                CheckEqual(Box(58, 4, 184, 20), dialog.DirectoryLabel.Bounds);
            }

            public void BottomRows_StackUpFromTheBottomEdge()
            {
                FileDialog dialog = NewDialog();

                CheckEqual(Box(246, 252, 50, 20), dialog.CancelButton.Bounds);
                CheckEqual(Box(192, 252, 50, 20), dialog.AcceptButton.Bounds);
                CheckEqual(Box(4, 252, 184, 20), dialog.FilterDropdown.Bounds);
                CheckEqual(Box(4, 228, 292, 20), dialog.StatusLabel.Bounds);
                CheckEqual(Box(4, 204, 292, 20), dialog.FileNameLabel.Bounds);
            }

            public void TheEntryList_TakesWhatTheRowsLeave()
            {
                CheckEqual(Box(4, 28, 292, 172), NewDialog().EntryList.Bounds);
            }

            public void Rows_StackAtTheListsWidth()
            {
                Button[] rows = RowsOf(NewDialog());

                CheckEqual(Box(0, 0, 292, 20), rows[0].Bounds);
                CheckEqual(Box(0, 20, 292, 20), rows[1].Bounds);
                CheckEqual(Box(0, 40, 292, 20), rows[2].Bounds);
            }

            public void Rows_SetTheListsContentSize()
            {
                CheckEqual(new Vector(292, 60), NewDialog().EntryList.ContentSize);
            }

            public void Resizing_RearrangesTheParts()
            {
                FileDialog dialog = NewDialog();

                dialog.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(400, 300));

                CheckEqual(Box(346, 4, 50, 20), dialog.NewFolderButton.Bounds);
                CheckEqual(Box(0, 0, 392, 20), RowsOf(dialog)[0].Bounds);
            }

            public void WhenTooSmall_EachPartTakesOnlyWhatIsLeftAndTheListNothing()
            {
                FileDialog dialog = NewDialog();

                dialog.Bounds = Rect.FromPositionAndSize(Vector.Zero, new Vector(40, 50));

                CheckEqual(Box(4, 4, 32, 18), dialog.UpButton.Bounds);
                CheckEqual(0, dialog.NewFolderButton.Bounds.Width);
                CheckEqual(0, dialog.EntryList.Bounds.Height);
            }


        }

        public class SizingTests : TestFixture
        {
            public void EveryButton_IsAsWideAsTheWidestButton()
            {
                FileDialog dialog = NewDialog(material: Measurements with { AcceptButton = ButtonOf(60, 16) });

                CheckEqual(64, dialog.UpButton.Bounds.Width);
                CheckEqual(64, dialog.NewFolderButton.Bounds.Width);
                CheckEqual(64, dialog.AcceptButton.Bounds.Width);
                CheckEqual(64, dialog.CancelButton.Bounds.Width);
            }

            public void ARowOfButtons_IsAsTallAsItsTallestButton()
            {
                FileDialog dialog = NewDialog(material: Measurements with { UpButton = ButtonOf(46, 30) });

                CheckEqual(34, dialog.UpButton.Bounds.Height);
                CheckEqual(34, dialog.NewFolderButton.Bounds.Height);
                CheckEqual(34, dialog.DirectoryLabel.Bounds.Height);
                CheckEqual(20, dialog.AcceptButton.Bounds.Height);
            }

            public void ButtonsThatWantNothing_TakeNoRoom()
            {
                FileDialog dialog = NewDialog(material: WithEveryButton(Measurements, default));

                CheckEqual(0, dialog.UpButton.Bounds.Width);
                CheckEqual(0, dialog.CancelButton.Bounds.Width);
            }

            public void ChangingAButtonsMaterial_ResizesEveryButton()
            {
                FileDialog dialog = NewDialog();

                dialog.FileDialogMaterial = Measurements with { CancelButton = ButtonOf(70, 16) };

                CheckEqual(74, dialog.UpButton.Bounds.Width);
            }

            public void ALabelRow_IsAsTallAsOneLineOfTheStyle()
            {
                FileDialog dialog = NewDialog(material: Measurements with
                {
                    TextStyle = LabelStyle with { VerticalMargin = 20 },
                });

                CheckEqual(44, dialog.DirectoryLabel.Bounds.Height);
                CheckEqual(44, dialog.StatusLabel.Bounds.Height);
                CheckEqual(44, dialog.FileNameLabel.Bounds.Height);
                CheckEqual(44, dialog.UpButton.Bounds.Height);
                CheckEqual(44, dialog.FilterDropdown.Bounds.Height);
            }

            public void ALabelRow_KeepsItsHeightWhileItsTextIsEmpty()
            {
                FileDialog dialog = NewDialog();

                CheckEqual("", dialog.StatusLabel.Text.ToString());
                CheckEqual(20, dialog.StatusLabel.Bounds.Height);
            }

            public void ALabelRowWithoutATextStyle_IsAsTallAsItsOtherParts()
            {
                FileDialog dialog = NewDialog(material: Measurements with { TextStyle = null });

                CheckEqual(0, dialog.StatusLabel.Bounds.Height);
                CheckEqual(0, dialog.FileNameLabel.Bounds.Height);
                CheckEqual(20, dialog.DirectoryLabel.Bounds.Height);
            }

            public void SuggestedNames_TakeTheRightOfTheFileNameRowAtTheirWidth()
            {
                FileDialog dialog = NewDialog();

                dialog.SuggestedNames = new[] { "one" };

                Scalar width = TextSize("one").X;
                CheckEqual(Box(296 - width, 204, width, 20), dialog.NameSuggestions.Bounds);
                CheckEqual(Box(4, 204, 288 - width, 20), dialog.FileNameLabel.Bounds);
            }

            public void SuggestedNames_FitTheWidestNameInTheDropdownsChrome()
            {
                FileDialog dialog = NewDialog(material: Measurements with
                {
                    Dropdown = new DropdownMaterial { Background = DropdownTests.Bordered3 },
                });

                dialog.SuggestedNames = new[] { "ab", "abcde", "abc" };

                CheckEqual(TextSize("abcde").X + 6, dialog.NameSuggestions.Bounds.Width);
                CheckEqual(26, dialog.NameSuggestions.Bounds.Height);
            }

            public void NoLongerHavingSuggestedNames_GivesTheFileNameLabelItsWidthBack()
            {
                FileDialog dialog = NewDialog();
                dialog.SuggestedNames = new[] { "one" };

                dialog.SuggestedNames = new string[0];

                CheckEqual(Box(4, 204, 292, 20), dialog.FileNameLabel.Bounds);
            }

            public void EveryEntryRow_IsAsTallAsTheLargestItemThroughEitherChrome()
            {
                FileDialog dialog = NewDialog(
                    material: Measurements with
                    {
                        EntryRow = ScrollViewTests.Bordered(1, "row"),
                        SelectedEntryRow = ScrollViewTests.Bordered(3, "selected row"),
                    },
                    entrySize: name => name == "music" ? new Vector(12, 30) : new Vector(10, 20));

                foreach (Button row in RowsOf(dialog))
                {
                    CheckEqual(36, row.Bounds.Height);
                }
            }

            public void SelectingARow_DoesNotResizeAnyRow()
            {
                FileDialog dialog = NewDialog(material: Measurements with
                {
                    EntryRow = ScrollViewTests.Bordered(1, "row"),
                    SelectedEntryRow = ScrollViewTests.Bordered(3, "selected row"),
                });
                Rect[] before = Array.ConvertAll(RowsOf(dialog), row => row.Bounds);

                Click(RowsOf(dialog)[1]);

                CheckEqual(before, Array.ConvertAll(RowsOf(dialog), row => row.Bounds));
            }

            public void NavigatingAway_RefitsTheRowsToTheNewEntries()
            {
                FileDialog dialog = NewDialog(
                    entrySize: name => name == "readme.txt" ? new Vector(10, 50) : new Vector(10, 20));

                dialog.Model.NavigateTo("/docs");

                CheckEqual(50, RowsOf(dialog)[0].Bounds.Height);
                CheckEqual(new Vector(292, 100), dialog.EntryList.ContentSize);
            }

            public void ADirectoryWithNoEntries_HasNoRows()
            {
                FileDialog dialog = NewDialog(startDirectory: "/music");

                CheckEqual(0, RowsOf(dialog).Length);
                CheckEqual(new Vector(292, 0), dialog.EntryList.ContentSize);
            }

            public void WithoutASelectedMaterial_RowsFitTheEntryMaterialAlone()
            {
                FileDialog dialog = NewDialog(material: Measurements with
                {
                    EntryRow = ScrollViewTests.Bordered(1, "row"),
                    SelectedEntryRow = null,
                });

                CheckEqual(22, RowsOf(dialog)[0].Bounds.Height);
            }

        }

        public class MinContentSizeTests : TestFixture
        {
            [IgnoreTest]
            public static FileDialog AtItsMinimum(FileDialog dialog)
            {
                dialog.Bounds = Rect.FromPositionAndSize(Vector.Zero, dialog.EffectiveMinSize);
                return dialog;
            }

            public void Default_IsTheFixedPartsOfTheWidestRowOverTheFourRowsAndTheListsMinimum()
            {
                CheckEqual(new Vector(116 + TextSize("All files").X, 164), NewDialog().MinContentSize);
            }

            public void ArrangedAtTheMinimum_GivesEveryPartItsMeasuredSizeWithNothingClamped()
            {
                FileDialog dialog = AtItsMinimum(NewDialog());
                Scalar filterWidth = TextSize("All files").X;
                Scalar width = 116 + filterWidth;

                CheckEqual(dialog.MinContentSize, dialog.ContentSize);
                CheckEqual(Box(4, 4, 50, 20), dialog.UpButton.Bounds);
                CheckEqual(Box(width - 54, 4, 50, 20), dialog.NewFolderButton.Bounds);
                CheckEqual(Box(58, 4, filterWidth, 20), dialog.DirectoryLabel.Bounds);
                CheckEqual(Box(width - 54, 140, 50, 20), dialog.CancelButton.Bounds);
                CheckEqual(Box(width - 108, 140, 50, 20), dialog.AcceptButton.Bounds);
                CheckEqual(Box(4, 140, filterWidth, 20), dialog.FilterDropdown.Bounds);
                CheckEqual(Box(4, 116, width - 8, 20), dialog.StatusLabel.Bounds);
                CheckEqual(Box(4, 92, width - 8, 20), dialog.FileNameLabel.Bounds);
                CheckEqual(Box(4, 28, width - 8, 60), dialog.EntryList.Bounds);
            }

            public void AWideFilter_WidensTheButtonRow()
            {
                string description = "Every kind of file anyone could possibly want";
                FileDialog dialog = NewDialog(filters: new[] { new FileFilter(description, null) });

                CheckEqual(116 + TextSize(description).X, dialog.MinContentSize.X);
            }

            public void TheWidestFilter_DecidesWhereverItIsInTheList()
            {
                Scalar widest = TextSize("Markdown files").X;

                CheckEqual(116 + widest,
                    NewDialog(filters: new[] { TextFiles, MarkdownFiles }).MinContentSize.X);
                CheckEqual(116 + widest,
                    NewDialog(filters: new[] { MarkdownFiles, TextFiles }).MinContentSize.X);
            }

            public void TheListsChrome_AddsToTheWidthAndHeight()
            {
                FileDialog dialog = NewDialog(material: Measurements with
                {
                    EntryList = ScrollViewTests.WithBars(200) with { Background = DropdownTests.Bordered3 },
                });

                CheckEqual(new Vector(214, 170), dialog.MinContentSize);
            }

            public void MoreEntryRows_AddTheirHeight()
            {
                FileDialog dialog = NewDialog(material: Measurements with { MinimumEntryRows = 5 });

                CheckEqual(204, dialog.MinContentSize.Y);
            }

            public void NoEntryRows_LeavesJustTheFourRows()
            {
                FileDialog dialog = NewDialog(material: Measurements with { MinimumEntryRows = 0 });

                CheckEqual(104, dialog.MinContentSize.Y);
            }

            public void ANegativeEntryRowCount_CountsAsNone()
            {
                FileDialog dialog = NewDialog(material: Measurements with { MinimumEntryRows = -4 });

                CheckEqual(104, dialog.MinContentSize.Y);
            }

            public void ArrangedAtTheMinimumWithSuggestedNames_StillClampsNothing()
            {
                string name = new string('w', 60);
                FileDialog dialog = NewDialog();
                dialog.SuggestedNames = new[] { name };
                AtItsMinimum(dialog);
                Scalar width = TextSize(name).X;

                CheckEqual(new Vector(width + 12, 164), dialog.MinContentSize);
                CheckEqual(dialog.MinContentSize, dialog.ContentSize);
                CheckEqual(Box(8, 92, width, 20), dialog.NameSuggestions.Bounds);
                CheckEqual(Box(4, 92, 0, 20), dialog.FileNameLabel.Bounds);
                CheckEqual(Box(4, 28, width + 4, 60), dialog.EntryList.Bounds);
            }

            public void ArrangedAtTheMinimumWithChromeEverywhere_StillClampsNothing()
            {
                FileDialog dialog = NewDialog(
                    material: WithEveryButton(Measurements, ButtonOf(46, 16, border: 3)) with
                    {
                        EntryList = ScrollViewTests.WithBars(10) with { Background = DropdownTests.Bordered3 },
                        Dropdown = new DropdownMaterial { Background = DropdownTests.Bordered3 },
                    });
                AtItsMinimum(dialog);

                CheckEqual(dialog.MinContentSize, dialog.ContentSize);
                CheckEqual(new Vector(52, 22), dialog.UpButton.Bounds.Size);
                CheckEqual(new Vector(TextSize("All files").X + 6, 26), dialog.FilterDropdown.Bounds.Size);
                CheckEqual(66, dialog.EntryList.Bounds.Height);
            }

            public void ASuggestionsDropdown_WidensItOnlyWhileItIsShown()
            {
                string name = new string('w', 60);
                FileDialog dialog = NewDialog();
                Scalar before = dialog.MinContentSize.X;

                dialog.SuggestedNames = new[] { name };
                CheckEqual(TextSize(name).X + 12, dialog.MinContentSize.X);

                dialog.SuggestedNames = new string[0];
                CheckEqual(before, dialog.MinContentSize.X);
            }

            public void TheRowsHeight_FollowsTheLargestEntryShown()
            {
                FileDialog dialog = NewDialog(
                    entrySize: name => name == "top.txt" ? new Vector(10, 40) : new Vector(10, 20));

                CheckEqual(224, dialog.MinContentSize.Y);
            }

            public void ADirectoryWithNoEntries_CountsEachRowAsTheChromeAlone()
            {
                FileDialog dialog = NewDialog(
                    startDirectory: "/music",
                    material: Measurements with { EntryRow = ScrollViewTests.Bordered(1, "row") });

                CheckEqual(110, dialog.MinContentSize.Y);
            }

            public void NavigatingAway_FollowsTheNewDirectorysEntries()
            {
                FileDialog dialog = NewDialog(
                    entrySize: name => name == "readme.txt" ? new Vector(10, 50) : new Vector(10, 20));

                dialog.Model.NavigateTo("/docs");

                CheckEqual(254, dialog.MinContentSize.Y);
            }

            public void Setting_ReplacesAMinimumSetByTheCaller()
            {
                FileDialog dialog = NewDialog();
                dialog.MinContentSize = new Vector(1000, 1000);

                dialog.FileDialogMaterial = Measurements;

                CheckEqual(new Vector(116 + TextSize("All files").X, 164), dialog.MinContentSize);
            }


        }

        public class EntryRowTests : TestFixture
        {
            public void ClickingOnce_SelectsTheEntry()
            {
                FileDialog dialog = NewDialog();

                Click(RowsOf(dialog)[2]);

                CheckEqual(2, dialog.Model.SelectedIndex);
                CheckEqual("top.txt", dialog.Model.FileName);
                CheckEqual("top.txt", dialog.FileNameLabel.Text.ToString());
            }

            public void Selecting_ChromesOnlyTheSelectedRowDifferently()
            {
                FileDialog dialog = NewDialog();

                Click(RowsOf(dialog)[1]);

                Button[] rows = RowsOf(dialog);
                CheckEqual(Row, rows[0].ButtonMaterial);
                CheckEqual(SelectedRow, rows[1].ButtonMaterial);
                CheckEqual(Row, rows[2].ButtonMaterial);
            }

            public void Selecting_KeepsTheSameRows()
            {
                FileDialog dialog = NewDialog();
                Button first = RowsOf(dialog)[0];

                Click(RowsOf(dialog)[1]);

                CheckEqual(first, RowsOf(dialog)[0]);
            }

            public void ClickingTwiceOnADirectory_OpensIt()
            {
                FileDialog dialog = NewDialog();

                Click(RowsOf(dialog)[0], clickCount: 2);

                CheckEqual("/docs", dialog.Model.Directory);
                CheckEqual("/docs", dialog.DirectoryLabel.Text.ToString());
            }

            public void OpeningADirectory_BuildsRowsForItsEntries()
            {
                var built = new Built();
                FileDialog dialog = NewDialog(built: built);
                built.Entries.Clear();

                Click(RowsOf(dialog)[0], clickCount: 2);

                CheckEqual(new[] { "notes", "readme.txt" }, built.Entries.ToArray());
                CheckEqual(2, RowsOf(dialog).Length);
            }

            public void ClickingTwiceOnAFile_AcceptsItAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);

                Click(RowsOf(dialog)[2], clickCount: 2);

                CheckEqual(1, listener.Accepted.Count);
                CheckFalse(dialog.Visible);
            }

            public void ClickingThriceOnAFile_AlsoOpensIt()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);

                Click(RowsOf(dialog)[2], clickCount: 3);

                CheckEqual(1, listener.Accepted.Count);
            }

            public void NavigatingAway_ResizesTheListsContentToTheNewRows()
            {
                FileDialog dialog = NewDialog();

                dialog.Model.NavigateTo("/docs");

                CheckEqual(new Vector(292, 40), dialog.EntryList.ContentSize);
            }

            public void ChangingTheFilter_RebuildsTheRows()
            {
                FileDialog dialog = NewDialog(filters: new[] { TextFiles, MarkdownFiles });

                dialog.Model.SelectFilter(1);

                CheckEqual(2, RowsOf(dialog).Length);
            }

            public void ChangingTheSelectedMaterialAfterwards_RestylesTheSelectedRow()
            {
                FileDialog dialog = NewDialog();
                Click(RowsOf(dialog)[1]);
                ButtonMaterial replacement = DropdownTests.Arrow(3, 3);

                dialog.FileDialogMaterial = Measurements with { SelectedEntryRow = replacement };

                CheckEqual(replacement, RowsOf(dialog)[1].ButtonMaterial);
            }

            public void NoSelectedMaterial_LeavesTheSelectedRowInTheEntryMaterial()
            {
                FileDialog dialog = NewDialog();
                dialog.FileDialogMaterial = Measurements with { SelectedEntryRow = null };

                Click(RowsOf(dialog)[1]);

                CheckEqual(Row, RowsOf(dialog)[1].ButtonMaterial);
            }
        }

        public class ButtonTests : TestFixture
        {
            public void Up_ShowsTheParentDirectory()
            {
                FileDialog dialog = NewDialog(startDirectory: "/docs");

                Click(dialog.UpButton);

                CheckEqual("/", dialog.Model.Directory);
                CheckEqual("/", dialog.DirectoryLabel.Text.ToString());
            }

            public void NewFolder_MakesOneAndShowsItsRow()
            {
                FileDialog dialog = NewDialog();

                Click(dialog.NewFolderButton);

                CheckEqual(4, RowsOf(dialog).Length);
                CheckEqual(2, dialog.Model.SelectedIndex);
                CheckEqual(SelectedRow, RowsOf(dialog)[2].ButtonMaterial);
            }

            public void Accept_WithNothingPicked_ShowsWhyInTheStatus()
            {
                FileDialog dialog = NewDialog();

                Click(dialog.AcceptButton);

                CheckEqual(FileDialogFailures.NothingPicked.Fail(dialog.Model.Mode).Describe(),
                    dialog.StatusLabel.Text.ToString());
                CheckTrue(dialog.Visible);
            }

            public void AFailureShown_IsClearedByTheModelsNextChange()
            {
                FileDialog dialog = NewDialog();
                Click(dialog.AcceptButton);

                dialog.Model.Select(0);

                CheckEqual("", dialog.StatusLabel.Text.ToString());
            }

            public void AFailureShown_OutlastsAMaterialChange()
            {
                FileDialog dialog = NewDialog();
                Click(dialog.AcceptButton);

                dialog.FileDialogMaterial = dialog.FileDialogMaterial;

                CheckEqual(FileDialogFailures.NothingPicked.Fail(dialog.Model.Mode).Describe(),
                    dialog.StatusLabel.Text.ToString());
            }

            public void Accept_WithAFilePicked_AcceptsItAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                Click(RowsOf(dialog)[2]);

                Click(dialog.AcceptButton);

                CheckEqual(1, listener.Accepted.Count);
                CheckEqual(0, listener.Cancellations);
                CheckFalse(dialog.Visible);
            }

            public void Cancel_CancelsTheModelOnceAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);

                Click(dialog.CancelButton);

                CheckEqual(1, listener.Cancellations);
                CheckFalse(dialog.Visible);
            }

            public void TheWindowsCloseButton_CancelsTheModelOnceAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);

                Click(dialog.CloseButton);

                CheckEqual(1, listener.Cancellations);
                CheckFalse(dialog.Visible);
            }
        }

        public class KeyboardTests : TestFixture
        {
            public static void Activate(FileDialog dialog, Button button, KeyCode key = KeyCode.Space)
            {
                var keys = new FocusedKeys(dialog, button);
                keys.Press(key);
                keys.Release(key);
            }

            public void Up_ShowsTheParentDirectory()
            {
                FileDialog dialog = NewDialog(startDirectory: "/docs");

                Activate(dialog, dialog.UpButton);

                CheckEqual("/", dialog.Model.Directory);
            }

            public void NewFolder_MakesOneAndSelectsIt()
            {
                FileDialog dialog = NewDialog();

                Activate(dialog, dialog.NewFolderButton);

                CheckEqual(4, RowsOf(dialog).Length);
                CheckEqual(2, dialog.Model.SelectedIndex);
            }

            public void Accept_WithAFilePicked_AcceptsItAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                Click(RowsOf(dialog)[2]);

                Activate(dialog, dialog.AcceptButton, KeyCode.MainEnter);

                CheckEqual(1, listener.Accepted.Count);
                CheckFalse(dialog.Visible);
            }

            public void Accept_WithNothingPicked_ShowsWhyInTheStatus()
            {
                FileDialog dialog = NewDialog();

                Activate(dialog, dialog.AcceptButton);

                CheckEqual(FileDialogFailures.NothingPicked.Fail(dialog.Model.Mode).Describe(),
                    dialog.StatusLabel.Text.ToString());
            }

            public void Cancel_CancelsTheModelOnceAndHidesTheDialog()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);

                Activate(dialog, dialog.CancelButton);

                CheckEqual(1, listener.Cancellations);
                CheckFalse(dialog.Visible);
            }

            public void PressingWithoutReleasing_DoesNothingYet()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                var keys = new FocusedKeys(dialog, dialog.CancelButton);

                keys.Press(KeyCode.Space);

                CheckEqual(0, listener.Cancellations);
                CheckTrue(dialog.Visible);
            }

            public void TheEntryRows_AreNotTabStops()
            {
                FileDialog dialog = NewDialog();
                var keys = new FocusedKeys(dialog, RowsOf(dialog)[0]);

                CheckNull(keys.Manager.Focused);
            }
        }

        public class DialogKeyTests : TestFixture
        {
            [IgnoreTest]
            public static FocusedKeys Entered(FileDialog dialog)
            {
                return FocusedKeys.Enter(dialog);
            }

            public void EnteringTheDialog_FocusesTheAcceptButton()
            {
                FileDialog dialog = NewDialog();

                FocusedKeys keys = Entered(dialog);

                CheckEqual(dialog.AcceptButton, keys.Manager.Focused);
            }

            public void Enter_WithFocusOnAnotherButton_ActivatesThatButtonNotAccept()
            {
                FileDialog dialog = NewDialog(startDirectory: "/docs");
                FocusedKeys keys = Entered(dialog);
                keys.Manager.TrySetFocus(dialog.UpButton);

                keys.Press(KeyCode.MainEnter);
                keys.Release(KeyCode.MainEnter);

                CheckEqual("/", dialog.Model.Directory);
            }

            public void Enter_WithNothingFocused_Accepts()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                Click(RowsOf(dialog)[2]);
                FocusedKeys keys = Entered(dialog);
                keys.Manager.ClearFocus();

                CheckTrue(keys.Press(KeyCode.MainEnter));

                CheckEqual(1, listener.Accepted.Count);
                CheckFalse(dialog.Visible);
            }

            public void Enter_WithNothingPicked_ShowsWhyAndStaysOpen()
            {
                FileDialog dialog = NewDialog();
                FocusedKeys keys = Entered(dialog);
                keys.Manager.ClearFocus();

                keys.Press(KeyCode.MainEnter);

                CheckEqual(FileDialogFailures.NothingPicked.Fail(dialog.Model.Mode).Describe(),
                    dialog.StatusLabel.Text.ToString());
                CheckTrue(dialog.Visible);
            }

            public void Escape_FromAnyButton_Cancels()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                FocusedKeys keys = Entered(dialog);
                keys.Manager.TrySetFocus(dialog.UpButton);

                CheckTrue(keys.Press(KeyCode.Escape));

                CheckEqual(1, listener.Cancellations);
                CheckFalse(dialog.Visible);
            }

            public void Escape_WithNothingFocused_Cancels()
            {
                FileDialog dialog = NewDialog();
                var listener = new FileDialogModelTests.Listener(dialog.Model);
                FocusedKeys keys = Entered(dialog);
                keys.Manager.ClearFocus();

                keys.Press(KeyCode.Escape);

                CheckEqual(1, listener.Cancellations);
            }

            public void NoKeysBehavior_IgnoresEnterAndEscape()
            {
                FileDialogModel model = FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open)
                    .Value;
                var dialog = new FileDialog(model, _ => new Panel(), DialogBehavior.NoKeys);
                dialog.FileDialogMaterial = Measurements;
                var listener = new FileDialogModelTests.Listener(model);
                FocusedKeys keys = Entered(dialog);
                keys.Manager.ClearFocus();

                keys.Press(KeyCode.MainEnter);
                keys.Press(KeyCode.Escape);

                CheckEqual(0, listener.Cancellations);
                CheckEqual(0, listener.Accepted.Count);
            }

            public void Tab_StaysInsideTheDialog()
            {
                FileDialog dialog = NewDialog();
                var outside = new Control { Focusable = true };
                FocusedKeys keys = Entered(dialog);
                keys.Manager.Controls.Add(outside);

                for (int i = 0; i < 12; ++i)
                {
                    keys.Press(KeyCode.Tab);
                    CheckNotNull(keys.Manager.Focused);
                    CheckFalse(keys.Manager.Focused == outside);
                }
            }

            public void TheOverwriteQuestion_TakesDismissOnOutsidePressFromTheBehavior()
            {
                FileDialogModel model = FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open)
                    .Value;
                var dismissing = new DialogBehavior(default, default, dismissOnOutsidePress: true);

                var dialog = new FileDialog(model, _ => new Panel(), dismissing);

                CheckTrue(dialog.OverwriteBox.DismissOnOutsidePress);
            }

            public void Behavior_IsKept()
            {
                CheckEqual(DialogBehavior.Default, NewDialog().Behavior);
            }

            public void NullBehavior_Throws()
            {
                FileDialogModel model = FileDialogModel.Create(InMemoryFileSystemTests.Sample(), FileDialogMode.Open)
                    .Value;

                CheckThrow(typeof(ArgumentNullException));
                new FileDialog(model, _ => new Panel(), null);
            }
        }

        public class OverwriteKeyTests : TestFixture
        {
            [IgnoreTest]
            public static FocusedKeys EnteredAtTheQuestion(out FileDialog dialog, out Listener listener)
            {
                dialog = OverwriteTests.AwaitingAnswer(out listener);
                DropdownTests.Walk(dialog);
                dialog.OverwriteBox.Visible = true;

                FocusedKeys keys = FocusedKeys.Enter(dialog);
                keys.Manager.EnterScope(dialog.OverwriteBox);

                return keys;
            }

            public void EnteringTheQuestion_FocusesTheKeepButton()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out _);

                CheckEqual(dialog.OverwriteBox.ButtonFor(FileDialog.OverwriteAnswer.Cancel), keys.Manager.Focused);
            }

            public void Enter_KeepsTheFileAndTheDialogStaysOpen()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out Listener listener);
                keys.Manager.ClearFocus();

                keys.Press(KeyCode.MainEnter);

                CheckEqual(0, listener.Accepted.Count);
                CheckFalse(dialog.OverwriteBox.IsOpen);
                CheckTrue(dialog.Visible);
            }

            public void Escape_KeepsTheFileAndTheDialogStaysOpen()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out Listener listener);

                keys.Press(KeyCode.Escape);

                CheckEqual(0, listener.Accepted.Count);
                CheckFalse(dialog.OverwriteBox.IsOpen);
                CheckTrue(dialog.Visible);
            }

            public void ReplacingFromTheKeyboard_AcceptsTheFile()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out Listener listener);
                keys.Manager.TrySetFocus(dialog.OverwriteBox.ButtonFor(FileDialog.OverwriteAnswer.Replace));

                keys.Press(KeyCode.Space);
                keys.Release(KeyCode.Space);

                CheckEqual(1, listener.Accepted.Count);
                CheckFalse(dialog.Visible);
            }

            public void Enter_DoesNotReachTheDialogsAcceptWhileTheQuestionIsUp()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out Listener listener);
                keys.Manager.ClearFocus();

                keys.Press(KeyCode.MainEnter);

                CheckEqual(0, listener.Accepted.Count);
            }

            public void Tab_StaysInsideTheQuestion()
            {
                FocusedKeys keys = EnteredAtTheQuestion(out FileDialog dialog, out _);
                Control replace = dialog.OverwriteBox.ButtonFor(FileDialog.OverwriteAnswer.Replace);
                Control cancel = dialog.OverwriteBox.ButtonFor(FileDialog.OverwriteAnswer.Cancel);

                for (int i = 0; i < 6; ++i)
                {
                    keys.Press(KeyCode.Tab);
                    Control focused = keys.Manager.Focused;
                    Check(focused == replace || focused == cancel);
                }
            }
        }

        public class OverwriteTests : TestFixture
        {
            [IgnoreTest]
            public static FileDialog AwaitingAnswer(
                out Listener listener, FileDialogMaterial? material = null)
            {
                FileDialog dialog = NewDialog(
                    FileDialogMode.Save, material: material);
                listener = new Listener(dialog.Model);
                dialog.Model.SetFileName("top.txt");
                Click(dialog.AcceptButton);
                return dialog;
            }

            public void SavingOverAFile_OpensTheQuestionNamingTheFile()
            {
                FileDialog dialog = AwaitingAnswer(out _);

                CheckTrue(dialog.OverwriteBox.IsOpen);
                CheckEqual(QuestionText("top.txt"), AskedText(dialog));
            }

            public void WhileAwaiting_CentersOverTheDialogsContent()
            {
                FileDialog dialog = AwaitingAnswer(out _);

                DropdownTests.Walk(dialog);

                Scalar width = dialog.OverwriteBox.Bounds.Width;
                CheckEqual(Box(150 - width / 2, 136, width, 52), dialog.OverwriteBox.Bounds);
            }

            public void RefreshingWhileAwaiting_KeepsTheQuestionUp()
            {
                FileDialog dialog = AwaitingAnswer(out _);

                dialog.SuggestedNames = new[] { "one" };

                CheckEqual(QuestionText("top.txt"), AskedText(dialog));
                CheckTrue(dialog.OverwriteBox.IsOpen);
            }

            public void AskingAboutAnotherFile_RewordsTheQuestion()
            {
                FileDialog dialog = AwaitingAnswer(out _);
                Click(AnswerButton(dialog, FileDialog.OverwriteAnswer.Cancel));

                dialog.Model.NavigateTo("/docs");
                dialog.Model.SetFileName("readme.txt");
                Click(dialog.AcceptButton);

                CheckEqual(QuestionText("readme.txt"), AskedText(dialog));
            }

            public void Replacing_AcceptsAndClosesTheQuestionAndTheDialog()
            {
                FileDialog dialog = AwaitingAnswer(out Listener listener);

                Click(AnswerButton(dialog, FileDialog.OverwriteAnswer.Replace));

                CheckEqual(1, listener.Accepted.Count);
                CheckFalse(dialog.OverwriteBox.IsOpen);
                CheckFalse(dialog.Visible);
            }

            public void Keeping_ClosesTheQuestionAndLeavesTheDialogUp()
            {
                FileDialog dialog = AwaitingAnswer(out Listener listener);

                Click(AnswerButton(dialog, FileDialog.OverwriteAnswer.Cancel));

                CheckEqual(0, listener.Accepted.Count);
                CheckFalse(dialog.OverwriteBox.IsOpen);
                CheckFalse(dialog.Model.AwaitingOverwriteConfirmation);
                CheckTrue(dialog.Visible);
            }

            public void TheQuestionClosingByItself_ReleasesTheModelsWait()
            {
                FileDialog dialog = AwaitingAnswer(out _);

                dialog.OverwriteBox.Close();

                CheckFalse(dialog.Model.AwaitingOverwriteConfirmation);
            }

            public void AnythingElseHappening_ClosesTheQuestion()
            {
                FileDialog dialog = AwaitingAnswer(out _);

                dialog.Model.SetFileName("other.txt");

                CheckFalse(dialog.OverwriteBox.IsOpen);
            }
        }

        public class FilterDropdownTests : TestFixture
        {
            public void Picking_NarrowsTheModel()
            {
                FileDialog dialog = NewDialog(filters: new[] { TextFiles, MarkdownFiles });

                dialog.FilterDropdown.Select(1);

                CheckEqual(1, dialog.Model.SelectedFilterIndex);
            }

            public void TheModelChoosingAFilter_ShowsItInTheDropdown()
            {
                FileDialog dialog = NewDialog(filters: new[] { TextFiles, MarkdownFiles });

                dialog.Model.SelectFilter(1);

                CheckEqual(1, dialog.FilterDropdown.SelectedIndex);
            }

            public void Initially_ShowsTheFirstFilter()
            {
                CheckEqual(0, NewDialog(filters: new[] { TextFiles, MarkdownFiles }).FilterDropdown.SelectedIndex);
            }
        }

        public class SuggestedNamesTests : TestFixture
        {
            public void Setting_BuildsARowPerNameAndShowsTheDropdown()
            {
                FileDialog dialog = NewDialog();

                dialog.SuggestedNames = new[] { "one", "two" };

                CheckEqual(new[] { "one", "two" }, TextsOf(dialog.NameSuggestions));
                CheckTrue(dialog.NameSuggestions.Visible);
            }

            public void SettingNone_HidesTheDropdownAgain()
            {
                FileDialog dialog = NewDialog();
                dialog.SuggestedNames = new[] { "one" };

                dialog.SuggestedNames = new string[0];

                CheckFalse(dialog.NameSuggestions.Visible);
            }

            public void Getting_ReturnsWhatWasSet()
            {
                FileDialog dialog = NewDialog();
                var names = new[] { "one" };

                dialog.SuggestedNames = names;

                CheckEqual(names, dialog.SuggestedNames);
            }

            public void Null_Throws()
            {
                FileDialog dialog = NewDialog();

                CheckThrow(typeof(ArgumentNullException));
                dialog.SuggestedNames = null;
            }

            public void Picking_SetsTheFileName()
            {
                FileDialog dialog = NewDialog(FileDialogMode.Save);
                dialog.SuggestedNames = new[] { "one.txt", "two.txt" };

                dialog.NameSuggestions.Select(1);

                CheckEqual("two.txt", dialog.Model.FileName);
                CheckEqual("two.txt", dialog.FileNameLabel.Text.ToString());
            }

            public void ANameTheModelHolds_IsShownAsPicked()
            {
                FileDialog dialog = NewDialog(FileDialogMode.Save);
                dialog.SuggestedNames = new[] { "one.txt", "two.txt" };

                dialog.Model.SetFileName("two.txt");

                CheckEqual(1, dialog.NameSuggestions.SelectedIndex);
            }

            public void ANameNoSuggestionMatches_ShowsNothingPicked()
            {
                FileDialog dialog = NewDialog(FileDialogMode.Save);
                dialog.SuggestedNames = new[] { "one.txt", "two.txt" };
                dialog.NameSuggestions.Select(0);

                dialog.Model.SetFileName("other.txt");

                CheckNull(dialog.NameSuggestions.SelectedIndex);
            }
        }

        public class MaterialTests : TestFixture
        {
            public void Getting_ReturnsWhatWasSet()
            {
                FileDialog dialog = NewDialog();
                var material = Measurements with
                {
                    UpButton = DropdownTests.Arrow(5, 5),
                    Spacing = 6,
                    MinimumEntryRows = 8,
                    OverwriteQuestionFormat = "{0}?",
                    TextStyle = TextStyleTests.WithFont(),
                };

                dialog.FileDialogMaterial = material;

                CheckEqual(material.UpButton, dialog.FileDialogMaterial.UpButton);
                CheckEqual(6, dialog.FileDialogMaterial.Spacing);
                CheckEqual(8, dialog.FileDialogMaterial.MinimumEntryRows);
                CheckEqual("{0}?", dialog.FileDialogMaterial.OverwriteQuestionFormat);
                CheckEqual(Row, dialog.FileDialogMaterial.EntryRow);
                CheckEqual(SelectedRow, dialog.FileDialogMaterial.SelectedEntryRow);
                CheckTrue(ReferenceEquals(material.TextStyle, dialog.FileDialogMaterial.TextStyle));
            }

            public void Setting_GivesEachButtonItsOwnMaterial()
            {
                FileDialog dialog = NewDialog();
                FileDialogMaterial material = Measurements with
                {
                    UpButton = DropdownTests.Arrow(1, 1),
                    NewFolderButton = DropdownTests.Arrow(2, 2),
                    AcceptButton = DropdownTests.Arrow(3, 3),
                    CancelButton = DropdownTests.Arrow(4, 4),
                };

                dialog.FileDialogMaterial = material;

                CheckEqual(material.UpButton, dialog.UpButton.ButtonMaterial);
                CheckEqual(material.NewFolderButton, dialog.NewFolderButton.ButtonMaterial);
                CheckEqual(material.AcceptButton, dialog.AcceptButton.ButtonMaterial);
                CheckEqual(material.CancelButton, dialog.CancelButton.ButtonMaterial);
            }

            public void Setting_GivesEveryLabelTheTextStyle()
            {
                FileDialog dialog = NewDialog();
                TextStyle style = TextStyleTests.WithFont();

                dialog.FileDialogMaterial = Measurements with { TextStyle = style };

                CheckTrue(ReferenceEquals(style, dialog.DirectoryLabel.Style));
                CheckTrue(ReferenceEquals(style, dialog.FileNameLabel.Style));
                CheckTrue(ReferenceEquals(style, dialog.StatusLabel.Style));
            }

            public void NoTextStyle_LeavesTheLabelsStyles()
            {
                FileDialog dialog = NewDialog();
                TextStyle before = dialog.DirectoryLabel.Style;

                dialog.FileDialogMaterial = Measurements with { TextStyle = null };

                CheckTrue(ReferenceEquals(before, dialog.DirectoryLabel.Style));
                CheckNull(dialog.FileDialogMaterial.TextStyle);
            }

            public void Setting_GivesTheDropdownsTheirMaterial()
            {
                FileDialog dialog = NewDialog();
                var dropdown = new DropdownMaterial { ArrowGap = 7 };

                dialog.FileDialogMaterial = Measurements with { Dropdown = dropdown };

                CheckEqual(7, dialog.FilterDropdown.DropdownMaterial.ArrowGap);
                CheckEqual(7, dialog.NameSuggestions.DropdownMaterial.ArrowGap);
            }

            public void Setting_GivesTheOverwriteBoxItsMaterial()
            {
                FileDialog dialog = NewDialog();
                Material background = DropdownTests.Bordered3;
                MessageBoxMaterial box = Measurements.OverwriteBox with { Background = background, Spacing = 7 };

                dialog.FileDialogMaterial = Measurements with { OverwriteBox = box };

                CheckEqual(background, dialog.OverwriteBox.Material);
                CheckEqual(7, dialog.FileDialogMaterial.OverwriteBox.Spacing);
                CheckEqual(
                    box.Buttons[1], dialog.OverwriteBox.ButtonFor(FileDialog.OverwriteAnswer.Cancel).ButtonMaterial);
            }

            public void ChangingTheSpacing_RearrangesTheParts()
            {
                FileDialog dialog = NewDialog();

                dialog.FileDialogMaterial = Measurements with { Spacing = 10 };

                CheckEqual(Box(10, 10, 50, 20), dialog.UpButton.Bounds);
            }

            public void ChangingTheButtonMaterials_ResizesTheButtons()
            {
                FileDialog dialog = NewDialog();

                dialog.FileDialogMaterial = WithEveryButton(Measurements, ButtonOf(46, 16, border: 5));

                CheckEqual(new Vector(56, 26), dialog.UpButton.Bounds.Size);
                CheckEqual(new Vector(56, 26), dialog.CancelButton.Bounds.Size);
            }

            public void ChangingTheTextStyle_ResizesTheLabelRows()
            {
                FileDialog dialog = NewDialog();

                dialog.FileDialogMaterial = Measurements with
                {
                    TextStyle = LabelStyle with { VerticalMargin = 20 },
                };

                CheckEqual(44, dialog.StatusLabel.Bounds.Height);
            }

            public void ChangingTheTextStyle_RestylesTheDropdownRowsAndKeepsThePick()
            {
                FileDialog dialog = NewDialog(filters: new[] { TextFiles, MarkdownFiles });
                dialog.Model.SelectFilter(1);

                dialog.FileDialogMaterial = Measurements with { TextStyle = LabelStyle with { VerticalMargin = 20 } };

                CheckEqual(44, dialog.FilterDropdown.Bounds.Height);
                CheckEqual(1, dialog.FilterDropdown.SelectedIndex);
            }

            public void ChangingTheQuestionFormatWhileAsking_RewordsTheQuestion()
            {
                FileDialog dialog = OverwriteTests.AwaitingAnswer(out _);

                dialog.FileDialogMaterial = Measurements with { OverwriteQuestionFormat = "{0}?" };

                CheckEqual("top.txt?", AskedText(dialog));
                CheckTrue(dialog.OverwriteBox.IsOpen);
            }

            public void NoQuestionFormat_AsksWithNoWords()
            {
                FileDialog dialog = OverwriteTests.AwaitingAnswer(
                    out _, material: Measurements with { OverwriteQuestionFormat = null });

                CheckEqual("", AskedText(dialog));
            }


        }
    }
}