Пример #1
0
 // NOTE: We have to keep a default constructor for design mode
 public SettingsDialogBase(TestCentricPresenter presenter, ITestModel model) : this()
 {
     Presenter             = presenter;
     Model                 = model;
     Settings              = model.Settings;
     PackageSettingChanges = new Dictionary <string, object>();
 }
        public TreeBasedSettingsDialog(TestCentricPresenter presenter, ITestModel model) : base(presenter, model)
        {
            // This call is required by the Windows Form Designer.
            InitializeComponent();

            // TODO: Add any initialization after the InitializeComponent call
        }
Пример #3
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            Settings = model.Services.UserSettings;

            tabControl.SelectedIndex = Settings.Gui.SelectedTab;

            model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                Clear();
            };

            model.Events.TestUnloaded += (TestEventArgs e) =>
            {
                Clear();
            };

            model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                if (Settings.Gui.ClearResultsOnReload)
                {
                    this.Clear();
                }
            };

            model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                Clear();
            };
        }
 public static void Display(TestCentricPresenter presenter, ITestModel model, params SettingsPage[] pages)
 {
     using (TreeBasedSettingsDialog dialog = new TreeBasedSettingsDialog(presenter, model))
     {
         dialog.Font = model.Settings.Gui.Font;
         dialog.SettingsPages.AddRange(pages);
         dialog.ShowDialog();
     }
 }
Пример #5
0
 public static void Display(TestCentricPresenter presenter, ITestModel model)
 {
     TreeBasedSettingsDialog.Display(presenter, model,
                                     new GuiSettingsPage("Gui.General"),
                                     new TreeSettingsPage("Gui.Tree Display"),
                                     new AssemblyReloadSettingsPage("Gui.Assembly Reload"),
                                     new TextOutputSettingsPage("Gui.Text Output"),
                                     new ProjectEditorSettingsPage("Gui.Project Editor"),
                                     new AdvancedLoaderSettingsPage("Engine.Advanced"));
 }
Пример #6
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                Nodes.Clear();
            };

            model.Events.TestUnloaded += (TestEventArgs e) =>
            {
                Nodes.Clear();
            };

            model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                if (model.Services.UserSettings.Gui.ClearResultsOnReload)
                {
                    Nodes.Clear();
                }
            };

            model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                Nodes.Clear();
            };

            model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                if (e.Result.Status == TestStatus.Skipped &&
                    e.Result.Site != FailureSite.Parent)
                {
                    this.AddNode(e.Result);
                }
            };

            model.Events.SuiteFinished += (TestResultEventArgs e) =>
            {
                // NOTE: Adhoc message test is needed due to an error in
                // the framework, whereby suites are not getting the
                // FailureSite set correctly.
                if (e.Result.Status == TestStatus.Skipped &&
                    e.Result.Site != FailureSite.Parent &&
                    e.Result.Site != FailureSite.Child &&
                    e.Result.Message != CHILD_IGNORED_MESSAGE)
                {
                    this.AddNode(e.Result);
                }
            };
        }
Пример #7
0
        //private void OnTestException(object sender, TestEventArgs args)
        //{
        //	string msg = string.Format( "An unhandled {0} was thrown while executing this test : {1}",
        //		args.Exception.GetType().FullName, args.Exception.Message );
        //	TestResultItem item = new TestResultItem( args.Name, msg, args.Exception.StackTrace );

        //	InsertTestResultItem( item );
        //}

        #endregion

        #region IViewControl Implentation

        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            UserSettings = model.Services.UserSettings;

            //settings.Changed += new SettingsEventHandler(UserSettings_Changed);

            int splitPosition = UserSettings.Gui.ErrorDisplay.SplitterPosition;

            if (splitPosition >= tabSplitter.MinSize && splitPosition < ClientSize.Height)
            {
                this.tabSplitter.SplitPosition = splitPosition;
            }

            WordWrap = UserSettings.Gui.ErrorDisplay.WordWrapEnabled;

            detailList.Font = stackTraceDisplay.Font = UserSettings.Gui.FixedFont;

            Orientation splitOrientation = UserSettings.Gui.ErrorDisplay.SplitterOrientation;
            float       splitterDistance = splitOrientation == Orientation.Vertical
                ? UserSettings.Gui.ErrorDisplay.VerticalPosition
                : UserSettings.Gui.ErrorDisplay.HorizontalPosition;

            sourceCode.SplitOrientation = splitOrientation;
            sourceCode.SplitterDistance = splitterDistance;

            sourceCode.SplitOrientationChanged += new EventHandler(sourceCode_SplitOrientationChanged);
            sourceCode.SplitterDistanceChanged += new EventHandler(sourceCode_SplitterDistanceChanged);

            if (UserSettings.Gui.ErrorDisplay.SourceCodeDisplay)
            {
                errorBrowser.SelectedDisplay = sourceCode;
            }
            else
            {
                errorBrowser.SelectedDisplay = stackTraceDisplay;
            }

            model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                if (e.Result.Status == TestStatus.Failed || e.Result.Status == TestStatus.Warning)
                {
                    if (e.Result.Site != FailureSite.Parent)
                    {
                        InsertTestResultItem(e.Result);
                    }
                }
            };

            model.Events.SuiteFinished += (TestResultEventArgs e) =>
            {
                if (e.Result.Status == TestStatus.Failed || e.Result.Status == TestStatus.Warning)
                {
                    if (e.Result.Site == FailureSite.SetUp || e.Result.Site == FailureSite.Test || e.Result.Site == FailureSite.TearDown)
                    {
                        InsertTestResultItem(e.Result);
                    }
                }
            };

            errorBrowser.StackTraceDisplayChanged += (s, e) =>
            {
                UserSettings.Gui.ErrorDisplay.SourceCodeDisplay = errorBrowser.SelectedDisplay == sourceCode;
            };
        }
Пример #8
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            _settings = model.Services.UserSettings;
            WordWrap  = _settings.Gui.TextOutput.WordWrapEnabled;
            Font      = _settings.Gui.FixedFont;

            model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                _labels              = _settings.Gui.TextOutput.Labels;
                _displayBeforeTest   = _labels == "ALL" || _labels == "BEFORE";
                _displayAfterTest    = _labels == "AFTER";
                _displayBeforeOutput = _displayBeforeTest || _displayAfterTest || _labels == "ON";

                _currentLabel = _lastTestOutput = null;
                _wantNewLine  = false;
            };

            model.Events.TestStarting += (TestNodeEventArgs e) =>
            {
                if (_displayBeforeTest)
                {
                    WriteLabelLine(e.Test.FullName);
                }
            };

            model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                if (e.Result.Output != null)
                {
                    if (_displayBeforeOutput)
                    {
                        WriteLabelLine(e.Result.FullName);
                    }

                    WriteOutputLine(e.Result.Name, e.Result.Output, OutputColor);
                }
            };

            model.Events.SuiteFinished += (TestResultEventArgs e) =>
            {
                if (e.Result.Output != null)
                {
                    if (_displayBeforeOutput)
                    {
                        WriteLabelLine(e.Result.FullName);
                    }

                    FlushNewLineIfNeeded();
                    WriteOutputLine(e.Result.Name, e.Result.Output, OutputColor);
                }
            };

            model.Events.TestOutput += (TestOutputEventArgs e) =>
            {
                if (_displayBeforeOutput && e.TestName != null)
                {
                    WriteLabelLine(e.TestName);
                }

                WriteOutputLine(e.TestName, e.Text,
                                e.Stream == "Error" ? ErrorColor : OutputColor);
            };
        }
 public void RemovePresenter()
 {
     Presenter = null;
 }
 public void CreatePresenter()
 {
     Presenter = new TestCentricPresenter(_view, _model, new CommandLineOptions());
 }
Пример #11
0
        //private void UserSettings_Changed(object sender, SettingsEventArgs args)
        //{
        //	//if ( args.SettingName == "Options.ShowCheckBoxes" )
        //	//	this.ShowCheckBoxes = Services.UserSettings.GetSetting( args.SettingName, false );
        //}

        #region IViewControl Implementation

        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            Model = model;

            ShowCheckBoxes = Model.Services.UserSettings.Gui.TestTree.ShowCheckBoxes;

            Model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                treeMenu.Visible = true;

                availableList.Items.Clear();
                selectedList.Items.Clear();

                availableList.SuspendLayout();
                foreach (string category in Model.AvailableCategories)
                {
                    availableList.Items.Add(category);
                }

                // We need to ensure the tree loads first because that's
                // where we restore visual state and possibly change the
                // selected categories.
                tests.Load(e.Test);

                // Reflect any changes in the controls
                if (Model.SelectedCategories != null && Model.SelectedCategories.Length > 0)
                {
                    selectedList.Items.AddRange(Model.SelectedCategories);
                    excludeCheckbox.Checked = Model.ExcludeSelectedCategories;

                    foreach (string cat in Model.SelectedCategories)
                    {
                        if (Model.AvailableCategories.Contains(cat))
                        {
                            availableList.Items.Remove(cat);
                            excludeCheckbox.Enabled = true;
                        }
                    }

                    UpdateCategorySelection();
                }

                availableList.ResumeLayout();
            };

            Model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                // Remove any selected items that are no longer available
                int index = selectedList.Items.Count;
                selectedList.SuspendLayout();
                while (--index >= 0)
                {
                    string category = selectedList.Items[index].ToString();
                    if (!Model.AvailableCategories.Contains(category))
                    {
                        selectedList.Items.RemoveAt(index);
                    }
                }
                selectedList.ResumeLayout();

                // Clear check box if there are no more selected items.
                if (selectedList.Items.Count == 0)
                {
                    excludeCheckbox.Checked = excludeCheckbox.Enabled = false;
                }

                // Put any unselected available items on availableList
                availableList.Items.Clear();
                availableList.SuspendLayout();
                foreach (string category in Model.AvailableCategories)
                {
                    if (selectedList.FindStringExact(category) < 0)
                    {
                        availableList.Items.Add(category);
                    }
                }
                availableList.ResumeLayout();

                // Tell the tree what is selected
                UpdateCategorySelection();
            };

            Model.Events.TestUnloaded += (TestEventArgs e) =>
            {
                availableList.Items.Clear();
                selectedList.Items.Clear();
                excludeCheckbox.Checked = false;
                excludeCheckbox.Enabled = false;
                treeMenu.Visible        = false;
            };

            //Services.UserSettings.Changed += new SettingsEventHandler(UserSettings_Changed);
        }
Пример #12
0
        public void CreatePresenter()
        {
            _view.LongRunningOperation.Returns(Substitute.For <ILongRunningOperationDisplay>());

            Presenter = new TestCentricPresenter(_view, _model, new CommandLineOptions());
        }
Пример #13
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                Initialize(e.Test.TestCount);
            };

            model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                Initialize(e.Test.TestCount, "Reloaded");
            };

            model.Events.TestUnloaded += (TestEventArgs e) =>
            {
                Initialize(0, "Unloaded");
            };

            model.Events.TestStarting += (TestNodeEventArgs e) =>
            {
                string fullText  = "Running : " + e.Test.FullName;
                string shortText = "Running : " + e.Test.Name;

                Graphics g          = Graphics.FromHwnd(Handle);
                SizeF    sizeNeeded = g.MeasureString(fullText, Font);
                if (statusPanel.Width >= (int)sizeNeeded.Width)
                {
                    statusPanel.Text        = fullText;
                    statusPanel.ToolTipText = "";
                }
                else
                {
                    sizeNeeded       = g.MeasureString(shortText, Font);
                    statusPanel.Text = statusPanel.Width >= (int)sizeNeeded.Width
                        ? shortText : e.Test.Name;
                    statusPanel.ToolTipText = e.Test.FullName;
                }
            };

            model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                if (DisplayTestProgress)
                {
                    ++testsRun;
                    DisplayTestsRun();
                    if (e.Result.Status == TestStatus.Failed)
                    {
                        if (e.Result.Label == "Error" || e.Result.Label == "Cancelled")
                        {
                            ++errors;
                            DisplayErrors();
                        }
                        else
                        {
                            ++failures;
                            DisplayFailures();
                        }
                    }
                }
            };

            model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                Initialize(e.TestCount, "Running");
                DisplayTestCount();
                DisplayTestsRun();
                DisplayErrors();
                DisplayFailures();
                DisplayTime();
            };

            model.Events.RunFinished += (TestResultEventArgs e) =>
            {
                statusPanel.Text = "Completed";
                DisplayResult(e.Result);
            };
        }
Пример #14
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                Initialize(e.Test.TestCount);
            };

            model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                if (!model.HasResults || model.Services.UserSettings.Gui.ClearResultsOnReload)
                {
                    Initialize(e.Test.TestCount);
                }
                else
                {
                    Value = Maximum = e.Test.TestCount;
                }
            };

            model.Events.TestUnloaded += (TestEventArgs e) =>
            {
                Initialize(100);
            };

            model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                Initialize(e.TestCount);
            };

            model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                PerformStep();

                switch (e.Result.Outcome.Status)
                {
                case TestStatus.Failed:
                    ForeColor = FailureColor;
                    break;

                case TestStatus.Skipped:
                    if (ForeColor == SuccessColor && e.Result.Outcome.Label == "Ignored")
                    {
                        ForeColor = IgnoredColor;
                    }
                    break;

                case TestStatus.Warning:
                    if (ForeColor == SuccessColor)
                    {
                        ForeColor = WarningColor;
                    }
                    break;

                default:
                    break;
                }
            };

            model.Events.SuiteFinished += (TestResultEventArgs e) =>
            {
                var outcome = e.Result.Outcome;
                if (outcome.Site == FailureSite.TearDown && outcome.Status == TestStatus.Failed)
                {
                    ForeColor = FailureColor;
                }
            };

            //model.TestException += (TestEventArgs e) =>
            //{
            //    ForeColor = FailureColor;
            //};
        }
Пример #15
0
        public void InitializeView(ITestModel model, TestCentricPresenter presenter)
        {
            Model        = model;
            Presenter    = presenter;
            UserSettings = model.Services.UserSettings;

            LoadAlternateImages();

            Model.Events.TestLoaded += (TestNodeEventArgs e) =>
            {
                CheckPropertiesDialog();
                Presenter.EnableRunCommand(true);
                runCommandEnabled = true;
            };

            Model.Events.TestReloaded += (TestNodeEventArgs e) =>
            {
                if (e.Test != null)
                {
                    Invoke(new LoadHandler(Reload), new object[] { e.Test });
                }
            };

            Model.Events.TestsUnloading += (TestEventArgs e) =>
            {
                ClosePropertiesDialog();

                if (UserSettings.Gui.TestTree.SaveVisualState)
                {
                    try
                    {
                        new VisualState(this).Save(VisualState.GetVisualStateFileName(Model.TestFiles[0]));
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine("Unable to save visual state.");
                        Debug.WriteLine(ex);
                    }
                }

                Clear();
                explicitlySelectedNode = null;
                runCommandEnabled      = false;
            };

            Model.Events.RunStarting += (RunStartingEventArgs e) =>
            {
                CheckPropertiesDialog();

#if ACCUMULATE_RESULTS
                if (runningTests != null)
                {
                    foreach (ITest test in runningTests)
                    {
                        this[test].ClearResults();
                    }
                }
#else
                ClearAllResults();
#endif

                runCommandEnabled = false;
            };

            Model.Events.RunFinished += (TestResultEventArgs e) =>
            {
                if (runningTests != null)
                {
                    foreach (TestNode test in runningTests)
                    {
                        this[test.Id].Expand();
                    }
                }

                if (propertiesDialog != null)
                {
                    propertiesDialog.Invoke(new PropertiesDisplayHandler(propertiesDialog.DisplayProperties));
                }

                runningTests      = null;
                runCommandEnabled = true;
            };

            Model.Events.TestFinished += (TestResultEventArgs e) =>
            {
                SetTestResult(e.Result);
            };

            Model.Events.SuiteFinished += (TestResultEventArgs e) =>
            {
                SetTestResult(e.Result);
            };

            //Services.UserSettings.Changed += (object sender, SettingsEventArgs e) =>
            //{
            //    if (args.SettingName == "Gui.TestTree.AlternateImageSet")
            //    {
            //        LoadAlternateImages();
            //        Invalidate();
            //    }
            //};

            //Model.Events.CategorySelectionChanged += (TestEventArgs e) =>
            //{
            //    TestNodeFilter filter = TestNodeFilter.Empty;

            //    if (Model.SelectedCategories.Length > 0)
            //    {
            //        filter = new CategoryFilter(Model.SelectedCategories);
            //        if (Model.ExcludeSelectedCategories)
            //            filter = new NotFilter(filter);
            //    }

            //    TreeFilter = filter;
            //};
        }