Example #1
0
        public void Display(TreeNode treeNode)
        {
            if (treeNode == null)
            {
                throw new ArgumentNullException(nameof(treeNode));
            }

            _treeNode        = treeNode;
            _testNode        = (TestNode)treeNode.Tag;
            _resultNode      = _model.GetResultForTest(_testNode.Id);
            _packageSettings = _model.GetPackageSettingsForTest(_testNode.Id);

            testResult.Text = _resultNode?.Outcome.ToString() ?? _testNode.RunState.ToString();
            testResult.Font = new Font(this.Font, FontStyle.Bold);
            if (_testNode.Type == "Project" || _testNode.Type == "Assembly")
            {
                TestName = Path.GetFileName(_testNode.Name);
            }
            else
            {
                TestName = _testNode.Name;
            }

            // Display each groupBox, for which there is data.
            // Boxes are displayed top-down at the vertical
            // offset
            int verticalOffset = packageGroupBox.Top;

            if (_packageSettings != null)
            {
                verticalOffset = DisplayPackageGroupBox(verticalOffset) + 4;
            }
            else
            {
                packageGroupBox.Hide();
            }

            // Test details are always shown
            verticalOffset = DisplayTestGroupBox(verticalOffset) + 4;

            if (_resultNode != null)
            {
                verticalOffset = DisplayResultGroupBox(verticalOffset) + 4;
            }
            else
            {
                resultGroupBox.Hide();
            }

            ClientSize = new Size(
                ClientSize.Width, verticalOffset);

            Rectangle screenArea = Screen.GetWorkingArea(this);

            Location = new Point(
                Location.X,
                Math.Max(0, Math.Min(Location.Y, screenArea.Bottom - Height)));

            Show();
        }
Example #2
0
 /// <summary>
 /// UpdateResultNode method
 /// </summary>
 internal void UpdateResultNode(MMCRegistration registration, ResultNode resultnode)
 {
     if (registration == null)
     {
         return;
     }
     else
     {
         resultnode.SubItemDisplayNames.Clear();
         resultnode.DisplayName = registration.UPN;
         resultnode.SubItemDisplayNames.Add(registration.MailAddress);
         resultnode.SubItemDisplayNames.Add(registration.PhoneNumber);
         resultnode.SubItemDisplayNames.Add(registration.CreationDate.ToString());
         resultnode.SubItemDisplayNames.Add(registration.Enabled.ToString());
         resultnode.SubItemDisplayNames.Add(((int)registration.PreferredMethod).ToString());
         resultnode.SubItemDisplayNames.Add(registration.ID);
         resultnode.SubItemDisplayNames.Add(registration.SecretKey);
         if (registration.Enabled)
         {
             resultnode.ImageIndex = 1;
         }
         else
         {
             resultnode.ImageIndex = 2;
         }
     }
 }
Example #3
0
        public override void Refresh()
        {
            ResultNodes.Clear();

            var entriesNode = this.ScopeNode as VecsStoreEntriesNode;
            var dto         = entriesNode.ServerDTO;
            var storeName   = entriesNode.StoreName;
            var storePass   = "";

            MMCActionHelper.CheckedExec(delegate()
            {
                using (var session = new VecsStoreSession(dto.VecsClient, storeName, storePass))
                {
                    var lst = session.GetSecretKeys();
                    if (lst == null)
                    {
                        return;
                    }

                    foreach (var certDTO in lst)
                    {
                        var resultNode = new ResultNode {
                            DisplayName = certDTO.Alias
                        };
                        resultNode.ImageIndex = (int)VMCertStoreImageIndex.SecretKeys;
                        resultNode.Tag        = certDTO;
                        this.ResultNodes.Add(resultNode);
                    }
                }
            });
            this.Sort(0);
            this.DescriptionBarText = this.ResultNodes.Count.ToString();
        }
Example #4
0
 public void OnTestFinished(ResultNode result)
 {
     if (result.Id == _testNode.Id)
     {
         Invoke(new Action(() => Display(_treeNode)));
     }
 }
Example #5
0
 /// <summary>
 /// Loads the list view with data.
 /// </summary>
 public void Refresh()
 {
     //+ Clear existing information.
     ResultNodes.Clear();
     //+ Use fictitious data to populate the lists.
     string[][] users =
     {
         new string[] { "Karen", "February 14th" },
         new string[] { "Sue",   "May 5th"       },
         new string[] { "Tina",  "April 15th"    },
         new string[] { "Lisa",  "March 27th"    },
         new string[] { "Tom",   "December 25th" },
         new string[] { "John",  "January 1st"   },
         new string[] { "Harry", "October 31st"  },
         new string[] { "Bob",   "July 4th"      }
     };
     //+ Populate the list.
     foreach (string[] user in users)
     {
         ResultNode node = new ResultNode();
         node.DisplayName = user[0];
         node.SubItemDisplayNames.Add(user[1]);
         ResultNodes.Add(node);
     }
 }
Example #6
0
        public void Refresh()

        {
            ResultNodes.Clear();

            int nodeCounter = 0;

            this.Entries = this.ScopeNode.Children.OfType <VMDNSZoneEntryNode>().ToList();

            foreach (var item in this.Entries)

            {
                var resultNode = new ResultNode {
                    DisplayName = item.CurrentZone.Name
                };

                resultNode.ImageIndex = (int)VMDNSTreeImageIndex.Zone;

                resultNode.Tag = nodeCounter++;

                resultNode.SubItemDisplayNames.Add(item.CurrentZone.DNSName);

                resultNode.SubItemDisplayNames.Add(item.CurrentZone.AdminEmail);



                this.ResultNodes.Add(resultNode);
            }

            this.Sort(0);

            this.DescriptionBarText = this.ResultNodes.Count.ToString();
        }
    public ResultNode[] getDivideTree(string workflow_id)
    {
        CrowdTask ct = findCrowdTaskByWorkflowId(workflow_id);

        ArrayList al = new ArrayList();

        al = findCrowdTaskByParentWorkflowIdAndTaskType(ct.taskWorkflowId, TaskType.decomposeTask, ct.mainTaskId);

        int count = findallDecomposeResultByVoted(ct.mainTaskId).Count;

        ResultNode[] rn = new ResultNode[count + 1];

        for (int j = 0; j < rn.Length; j++)
        {
            rn[j] = new ResultNode(null, null);
        }

        rn[0].taskName = ct.taskName;
        rn[0].parentId = rn.Length;

        //根据al里面的每个分解,去decomposeResult里面去寻找vote的东西。

        buildTree(al, rn, 0, 0);

        return(rn);
    }
Example #8
0
        public void RefreshApps()
        {
            try
            {
                // load apps
                List <SSOAppInfo> applications = SSOManager.GetApplications();

                this.ResultNodes.Clear();
                foreach (SSOAppInfo app in applications)
                {
                    ResultNode resultNode = new ResultNode();
                    resultNode.DisplayName = app.Name;
                    resultNode.SubItemDisplayNames.AddRange(new string[5]
                    {
                        app.Status,
                        app.Description,
                        app.AdminAccounts,
                        app.UserAccounts,
                        app.Contact
                    });
                    this.ResultNodes.Add(resultNode);
                }
            }
            catch (Exception ex)
            {
                MsgBoxUtil.Show(this.SnapIn, ex);
            }
        }
        /// <summary>
        /// Post a test result to the tree, changing the treeNode
        /// color to reflect success or failure. Overridden here
        /// to allow for moving nodes from one group to another
        /// based on the result of running the test.
        /// </summary>
        public override void OnTestFinished(ResultNode result)
        {
            base.OnTestFinished(result);

            if (_grouping != null)
                _grouping.OnTestFinished(result);
        }
Example #10
0
        /// <summary>
        /// Loads the ListView with data
        /// </summary>
        internal void Refresh()
        {
            // Clear existing information
            this.ResultNodes.Clear();

            // Load current information
            List <DataBase> certs = context.caInfo.GetCerts(context.certStatus);

            foreach (var cert in certs)
            {
                ResultNode node = new ResultNode();

                node.DisplayName = cert.dn;
                if (context.certStatus == CertStatus.Revoked)
                {
                    node.ImageIndex = 5;
                    node.SubItemDisplayNames.Add(cert.revDate);
                    node.SubItemDisplayNames.Add(cert.revReason);
                    node.SubItemDisplayNames.Add(cert.profile);
                    node.SubItemDisplayNames.Add(cert.serialNumber);
                    node.Tag = cert.certificate;
                }
                else      // Current or Expired
                {
                    node.ImageIndex = 4;
                    node.SubItemDisplayNames.Add(cert.created);
                    node.SubItemDisplayNames.Add(cert.expiry);
                    node.SubItemDisplayNames.Add(cert.profile);
                    node.SubItemDisplayNames.Add(cert.serialNumber);
                    node.Tag = cert.certificate;
                }
                this.ResultNodes.Add(node);
            }
        }
Example #11
0
        public void Refresh()

        {
            ResultNodes.Clear();

            int nodeCounter = 0;

            this.Entries = (this.ScopeNode as VMDirSchemaAttributeBaseNode).Attributes;

            foreach (var item in this.Entries)

            {
                var resultNode = new ResultNode {
                    DisplayName = item.DisplayName
                };

                resultNode.ImageIndex = (int)VMDirSchemaTreeImageIndex.Attribute;

                resultNode.Tag = nodeCounter++;

                resultNode.SubItemDisplayNames.Add(item.attrType.Type);

                resultNode.SubItemDisplayNames.Add(item.attrType.Description);



                this.ResultNodes.Add(resultNode);
            }

            this.Sort(0);

            this.DescriptionBarText = this.ResultNodes.Count.ToString();
        }
        public void Refresh()

        {
            ResultNodes.Clear();

            int nodeCounter = 0;

            this.Entries = this.ScopeNode.Children.OfType <VMDirSchemaClassEntryNode>().ToList();

            foreach (var item in this.Entries)

            {
                var resultNode = new ResultNode {
                    DisplayName = item.DisplayName
                };

                resultNode.ImageIndex = (int)VMDirSchemaTreeImageIndex.ObjectClass;

                resultNode.Tag = nodeCounter++;

                resultNode.SubItemDisplayNames.Add(item.ObjectClassDto.GetObjectClassTypeAsString());

                resultNode.SubItemDisplayNames.Add(item.ObjectClassDto.Description);



                this.ResultNodes.Add(resultNode);
            }

            this.Sort(0);

            this.DescriptionBarText = this.ResultNodes.Count.ToString();
        }
Example #13
0
        public void Refresh()

        {
            ResultNodes.Clear();

            int nodeCounter = 0;

            this.Entries = (this.ScopeNode as VMDNSZoneEntryNode).CurrentZone.ListRecords();

            foreach (var record in this.Entries)

            {
                var resultNode = new ResultNode {
                    DisplayName = record.Name
                };

                resultNode.ImageIndex = (int)VMDNSTreeImageIndex.Record;

                resultNode.Tag = nodeCounter++;

                resultNode.SubItemDisplayNames.Add(VMDNSUtilityService.GetRecordNameFromType((RecordType)record.Type));



                this.ResultNodes.Add(resultNode);
            }

            this.Sort(0);

            this.DescriptionBarText = this.ResultNodes.Count.ToString();
        }
        /// <summary>
        /// Loads the ListView with data
        /// </summary>
        public void Refresh()
        {
            // Clear existing information
            this.ResultNodes.Clear();

            // Get some fictitious data to populate the lists with
            string[][] users = { new string[] {"Karen", "February 14th"},
                                        new string[] {"Sue", "May 5th"},
                                        new string[] {"Tina", "April 15th"},
                                        new string[] {"Lisa", "March 27th"},
                                        new string[] {"Tom", "December 25th"},
                                        new string[] {"John", "January 1st"},
                                        new string[] {"Harry", "October 31st"},
                                        new string[] {"Bob", "July 4th"}
                                    };

            // Populate the list.
            foreach (string[] user in users)
            {
                ResultNode node = new ResultNode();
                node.DisplayName = user[0];
                node.SubItemDisplayNames.Add(user[1]);

                this.ResultNodes.Add(node);
            }
        }
 public ConnectionsRegisterer(ConnectionsTracker connTracker, InputCanvas inputCanvas, LineDrawer drawer, ResultNode resultNode)
 {
     this.connTracker = connTracker;
     this.inputCanvas = inputCanvas;
     this.drawer      = drawer;
     this.resultNode  = resultNode;
 }
        void Refresh()
        {
            this.ResultNodes.Clear();

            // Retrieve data to populate the list with.
            ManagementObjectSearcher   searcher = new ManagementObjectSearcher("select * from Win32_service");
            ManagementObjectCollection results  = searcher.Get();

            // Populate the list.
            foreach (ManagementObject result in results)
            {
                ResultNode node = new ResultNode();
                node.DisplayName = (string)result.GetPropertyValue("DisplayName");

                string description = (string)result.GetPropertyValue("Description");
                string state       = (string)result.GetPropertyValue("State");
                string startMode   = (string)result.GetPropertyValue("StartMode");
                string startName   = (string)result.GetPropertyValue("StartName");

                description = (description == null) ? String.Empty : description;
                state       = (state == null) ? String.Empty : state;
                startMode   = (startMode == null) ? String.Empty : startMode;
                startName   = (startName == null) ? String.Empty : startName;

                node.SubItemDisplayNames.AddRange(new string[]
                                                  { description,
                                                    state,
                                                    startMode,
                                                    startName });

                ResultNodes.Add(node);
            }
        }
        private void DisplaySelectedItem()
        {
            TestNode   testNode   = _selectedItem as TestNode;
            ResultNode resultNode = null;

            // TODO: Insert checks for errors in the XML
            if (_selectedItem != null)
            {
                _view.Header = _selectedItem.Name;

                if (testNode != null)
                {
                    _view.TestPanel.Visible = true;
                    _view.SuspendLayout();

                    DisplayTestInfo(testNode);

                    resultNode = _model.GetResultForTest(testNode.Id);
                    if (resultNode != null)
                    {
                        DisplayResultInfo(resultNode);
                    }

                    _view.ResumeLayout();
                }
            }

            _view.TestPanel.Visible   = testNode != null;
            _view.ResultPanel.Visible = resultNode != null;

            // TODO: We should actually try to set the font for bold items
            // dynamically, since the global application font may be changed.
        }
Example #18
0
        private XmlNode GetFullXml(TestNode testNode)
        {
            ResultNode resultNode = _model.GetResultForTest(testNode);
            XmlNode    currentXml;

            if (resultNode != null)
            {
                currentXml = resultNode.Xml.Clone();
                foreach (TestNode child in testNode.Children)
                {
                    XmlNode childXml         = GetFullXml(child);
                    XmlNode importedChildXml = currentXml.OwnerDocument.ImportNode(childXml, true);
                    currentXml.AppendChild(importedChildXml);
                }
            }
            else
            {
                currentXml = testNode.Xml.Clone();
                foreach (TestNode child in testNode.Children)
                {
                    XmlNode childXml         = GetFullXml(child);
                    XmlNode importedChildXml = currentXml.OwnerDocument.ImportNode(childXml, true);
                    var     oldChild         = FindXmlNode(currentXml, child);
                    if (oldChild != null)
                    {
                        currentXml.ReplaceChild(importedChildXml, oldChild);
                    }
                    else
                    {
                        currentXml.AppendChild(importedChildXml);
                    }
                }
            }
            return(currentXml);
        }
        public void WhenTestsFinish_DurationIsDisplayed()
        {
            var result = new ResultNode("<test-run duration='1.234' />");
            FireRunFinishedEvent(result);

            _view.Received().DisplayText("Completed");
            _view.Received().DisplayDuration(1.234);
        }
Example #20
0
        public void WhenTestCaseCompletes_ProgressIsIncremented()
        {
            var result = new ResultNode("<test-case id='1'/>");

            _model.Events.TestFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(result));

            _view.Received().Progress++;
        }
Example #21
0
        public void WhenTestSuiteCompletes_ProgressIsNotIncremented()
        {
            var result = new ResultNode("<test-suite id='1'/>");

            _model.Events.SuiteFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(result));

            _view.DidNotReceive().Progress++;
        }
        public void WhenTestCaseCompletes_ProgressIsIncremented()
        {
            var result = new ResultNode("<test-case id='1'/>");

            FireTestFinishedEvent(result);

            _view.Received().Progress++;
        }
        public void SimulateTestRunFinish()
        {
            Model.HasTests.Returns(true);
            Model.IsTestRunning.Returns(false);

            var resultNode = new ResultNode("<test-suite/>");
            Model.RunFinished += Raise.Event<TestResultEventHandler>(new TestResultEventArgs(TestAction.RunFinished, resultNode));
        }
Example #24
0
        public void WhenTestSuiteCompletes_ResultIsPosted()
        {
            var result = new ResultNode("<test-suite id='DUMMY' result='Passed'/>");

            _model.Events.SuiteFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(result));

            _view.Received().SetTestResult(result);
        }
Example #25
0
 private void BuildTypeList(IEnumerable <TestInfo> tests, ResultNode parent)
 {
     foreach (var group in tests.GroupBy(t => t.Type))
     {
         var node = new ResultNode(parent, group.Key);
         BuildMethodList(group, node);
     }
 }
Example #26
0
        public void WhenTestCaseCompletes_CountIsIncremented()
        {
            var result = new ResultNode(XmlHelper.CreateXmlNode("<test-case id='1'/>"));

            _model.Events.TestFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(result));

            _view.Received().OnTestPassed();
        }
        public void WhenTestSuiteCompletes_ProgressIsNotIncremented()
        {
            var result = new ResultNode("<test-suite id='1'/>");

            FireSuiteFinishedEvent(result);

            _view.DidNotReceive().Progress++;
        }
Example #28
0
        protected override void OnInitialize()
        {
            base.OnInitialize();
            ResultNode resultNode = (ResultNode)base.ParentSheet.SelectionObject;

            this._currentKeyName = resultNode.DisplayName;
            this.modifyPropertiesControl.RefreshData((ResultNode)base.ParentSheet.SelectionObject);
        }
Example #29
0
 private void BuildAssemblyList(IEnumerable <XmlElement> assemblies, ResultNode parent)
 {
     foreach (var assembly in assemblies)
     {
         var node = new ResultNode(parent, assembly.GetAttribute("name").Split('\\').Last());
         BuildNamespaceList(assembly.SelectNodes("collection/test").Cast <XmlElement>().Select(x => new TestInfo(x)), node);
     }
 }
Example #30
0
 protected static void Select(ResultNode resultNode)
 {
     Select(resultNode.Table, resultNode.Select);
     foreach (ResultNode child in resultNode.Children)
     {
         Select(child);
     }
 }
Example #31
0
        /// <summary>
        /// Post a test result to the tree, changing the treeNode
        /// color to reflect success or failure. Overridden here
        /// to allow for moving nodes from one group to another
        /// based on the result of running the test.
        /// </summary>
        public override void OnTestFinished(ResultNode result)
        {
            base.OnTestFinished(result);

            if (_grouping != null)
            {
                _grouping.OnTestFinished(result);
            }
        }
Example #32
0
        public virtual void OnTestFinished(ResultNode result)
        {
            int imageIndex = CalcImageIndex(result.Outcome);

            foreach (TreeNode treeNode in GetTreeNodesForTest(result))
            {
                Tree.SetImageIndex(treeNode, imageIndex);
            }
        }
Example #33
0
        public void WhenTestsFinish_TestResultsAreCalculated()
        {
            var result = new ResultNode(XmlHelper.CreateXmlNode("<test-run/>"));

            _model.Events.RunFinished += Raise.Event <TestResultEventHandler>(new TestResultEventArgs(result));

            _view.Received().OnRunFinished(0);
            _view.Received().OnTestRunSummaryCompiled(Arg.Any <string>());
        }
 public void Inject(object what)
 {
     var tk = new TypeKey(what.GetType());
     Node n = new Node(tk);
     n.Value = what;
     ResultNode rn = new ResultNode(tk,n);
     var bn = inspector.Inspect(n.Build);
     rn.BuildNode = bn;
     foreach (var op in bn.Injections)
     {
         var cn = context.ResolveType(new TypeKey(op.PropertyType));
         consider.Enqueue(cn);
     }
     readyToFill.Enqueue(rn);
     Build();
 }
 public override void OnTestFinished(ResultNode result)
 {
     var imageIndex = DisplayStrategy.CalcImageIndex(result.Outcome);
     if (imageIndex >= TestTreeView.SuccessIndex)
     {
         var treeNodes = _displayStrategy.GetTreeNodesForTest(result);
         foreach (var treeNode in treeNodes)
         {
             var parentNode = treeNode.Parent;
             if (parentNode != null)
             {
                 var group = parentNode.Tag as TestGroup;
                 if (group != null && imageIndex > group.ImageIndex)
                 {
                     parentNode.SelectedImageIndex = parentNode.ImageIndex = group.ImageIndex = imageIndex;
                 }
             }
         }
     }
 }
Example #36
0
        public void ChangeGroupsBasedOnTestResult(ResultNode result, bool updateImages)
        {
            var treeNodes = _displayStrategy.GetTreeNodesForTest(result);

            // Result may be for a TestNode not shown in the tree
            if (treeNodes.Count == 0)
                return;

            // This implementation ignores any but the first node
            // since changing of groups is currently only needed
            // for groupings that display each node once.
            var treeNode = treeNodes[0];
            var oldParent = treeNode.Parent;
            var oldGroup = oldParent.Tag as TestGroup;

            // We only have to proceed for tests that are direct
            // descendants of a group node.
            if (oldGroup == null)
                return;

            var newGroup = SelectGroups(result)[0];

            // If the group didn't change, we can get out of here
            if (oldGroup == newGroup)
                return;

            var newParent = newGroup.TreeNode;

            _displayStrategy.Tree.InvokeIfRequired(() =>
            {
                oldGroup.RemoveId(result.Id);
                // TODO: Insert in order
                newGroup.Add(result);

                // Remove test from tree
                treeNode.Remove();

                // If it was last test in group, remove group
                if (oldGroup.Count == 0)
                    oldParent.Remove();
                else // update old group
                {
                    oldParent.Text = _displayStrategy.GroupDisplayName(oldGroup);
                    if (updateImages)
                        oldParent.ImageIndex = oldParent.SelectedImageIndex = oldGroup.ImageIndex =
                            _displayStrategy.CalcImageIndexForGroup(oldGroup);
                }

                newParent.Nodes.Add(treeNode);
                newParent.Text = _displayStrategy.GroupDisplayName(newGroup);
                newParent.Expand();

                if (updateImages)
                {
                    var imageIndex = DisplayStrategy.CalcImageIndex(result.Outcome);
                    if (imageIndex >= TestTreeView.SuccessIndex && imageIndex > newGroup.ImageIndex)
                        newParent.ImageIndex = newParent.SelectedImageIndex = newGroup.ImageIndex = imageIndex;
                }

                if (newGroup.Count == 1)
                {
                    _displayStrategy.Tree.Clear();
                    TreeNode topNode = null;
                    foreach (var group in Groups)
                        if (group.Count > 0)
                        {
                            _displayStrategy.Tree.Add(group.TreeNode);
                            if (topNode == null)
                                topNode = group.TreeNode;
                        }

                    if (topNode != null)
                        topNode.EnsureVisible();
                }
            });
        }
 /// <summary>
 /// Populate control values from the SelectionObject (set in UserListView.SelectionOnChanged)
 /// </summary>
 public void RefreshData(ResultNode userNode)
 {
     this.UserName.Text = userNode.DisplayName;
     this.Birthday.Text = userNode.SubItemDisplayNames[0];    // first subitem
     userPropertyPage.Dirty = false;
 }
Example #38
0
 /// <summary>
 /// Post a test result to the tree, changing the treeNode
 /// color to reflect success or failure.
 /// </summary>
 public virtual void OnTestFinished(ResultNode result)
 {
     // Override to take any necessary action
 }
        public void WhenTestCaseCompletes_CountIsIncremented()
        {
            var result = new ResultNode(XmlHelper.CreateXmlNode("<test-case id='1'/>"));

            _model.TestFinished += Raise.Event<TestResultEventHandler>(new TestResultEventArgs(TestAction.TestFinished, result));

            _view.Received().RecordSuccess();
        }
Example #40
0
            internal Expression ComplexResult(Dictionary<string, ParameterExpression> parameters)
            {
                ResultNode rn = new ResultNode();
                rn.Output = Output;
                rn.Confidence = Confidence;
                rn.Count = Count;

                var result = System.Linq.Expressions.Expression.Constant(rn) as Expression;

                return Children.Aggregate(result,
                                          (current, child) =>
                                          System.Linq.Expressions.Expression.Condition(
                                              child.Predicate.Expression(parameters), child.ComplexResult(parameters),
                                              current));
            }
 private void CallInjectionCompleteHandler(ResultNode rn)
 {
     foreach (var methodInfo in rn.BuildNode.Handlers)
     {
         methodInfo.Invoke(rn.Value, null);
     }
 }
 /// <summary>
 /// Update the node with the controls values
 /// </summary>
 /// <param name="userNode">Node being updated by property page</param>
 public void UpdateData(ResultNode userNode)
 {
     userNode.DisplayName = this.UserName.Text;
     userNode.SubItemDisplayNames[0] = this.Birthday.Text;    // first subitem
     userPropertyPage.Dirty = false;
 }
        private ResultNode CreateResultNode(Stack<TypeKey> tried, Node n)
        {
            var tk = n.TypeKey;
            if (tried.Contains(tk))
            {
                throw new CircularConstructorDependencyException(tried);
            }
            tried.Push(tk);
            try
            {
                ResultNode rn;
                if (nodes.TryGetValue(n.TypeKey, out rn))
                {
                    return rn;
                }
                rn = new ResultNode(tk, n);
                nodes[tk] = rn;
                if (n.Value != null)
                {
                    resolvedNodes[tk] = rn;
                    return rn;
                }
                else
                {
                    var bn = inspector.Inspect(n.Build);
                    rn.BuildNode = bn;

                    ConstructorInfo ctor = bn.Constructor;
                    if (ctor == null)
                        throw new NoSuiteableInjectionConstructorException(bn.Type);
                    var argts = ctor.GetParameters();

                    if (argts.Length > 0)
                    {
                        var argns = new ResultNode[argts.Length];
                        int i = 0;
                        foreach (var parameterInfo in argts)
                        {
                            var pn = context.ResolveType(new TypeKey(parameterInfo.ParameterType));
                            var arn = CreateResultNode(tried, pn);
                            argns[i] = arn;
                            ++i;
                        }
                        rn.CtorArgs = argns;
                    }
                    readyToConstruct.Enqueue(rn);
                    nodes[tk] = rn;
                    foreach (var op in bn.Injections)
                    {
                        var cn = context.ResolveType(new TypeKey(op.PropertyType));
                        consider.Enqueue(cn);
                    }

                    return rn;
                }
            }
            finally
            {
                tried.Pop();
            }
        }
 private void Fill(ResultNode rn)
 {
     var bn = rn.BuildNode;
     foreach (var op in bn.Injections)
     {
         var cn = context.ResolveType(new TypeKey(op.PropertyType));
         op.SetValue(rn.Value,cn.Value,null);
     }
     if (rn.BuildNode.HasHandlers)
     {
         doneHandlers.Enqueue(rn);
     }
 }
Example #45
0
 public void ReportTestOutcome(ResultNode result)
 {
     UpdateProgress(result);
     UpdateStatus(result.Outcome);
 }
Example #46
0
        //private bool _resultNodeVisited;

        /// <summary>
        /// Visits the specified node.
        /// </summary>
        /// <param name="node">The node.</param>
        public void Visit(ResultNode node)
        {
            //if (_resultNodeVisited)
            //{
            //    throw new NotSupportedException("Multiple ResultNode items not supported.");
            //}
            //_resultNodeVisited = true;
            //AppendToResult(node.FieldName);
            //AppendNewLineToResult();
            //AppendFormatToResult("var result = ", node.FieldName);
            using (new DestinationNodeContext(node))
                node.Expression.AcceptVisitor(this);

            //AppendToResult(";");
        }
        public void BarShowsProperStatus(TestProgressBarStatus priorStatus, ResultState resultState, TestProgressBarStatus expectedStatus)
        {
            _view.Status = priorStatus;

            var doc = new XmlDocument();
            if (resultState.Label == string.Empty)
                doc.LoadXml(string.Format("<test-case id='1' result='{0}'/>", resultState.Status));
            else
                doc.LoadXml(string.Format("<test-case id='1' result='{0}' label='{1}'/>", resultState.Status, resultState.Label));
            var result = new ResultNode(doc.FirstChild);

            _model.HasTests.Returns(true);
            _model.Tests.Returns(result);
            _model.TestLoaded += Raise.Event<TestEventHandler>(new TestEventArgs(TestAction.TestLoaded, result));
            _model.TestFinished += Raise.Event<TestEventHandler>(new TestEventArgs(TestAction.TestFinished, result));

            Assert.That(_view.Status, Is.EqualTo(expectedStatus));
        }
Example #48
0
 /// <summary>
 /// Post a test result to the tree, changing the treeNode
 /// color to reflect success or failure. Overridden here
 /// to allow for moving nodes from one group to another
 /// based on the result of running the test.
 /// </summary>
 public override void OnTestFinished(ResultNode result)
 {
     ChangeGroupsBasedOnTestResult(result, false);
 }
Example #49
0
 public void Visit(ResultNode node)
 {
     AppendFormatToResult("\n\tresult[\"{0}\"].Value = ", node.FieldName);
     node.Expression.AcceptVisitor(this);
     AppendToResult(";");
 }
 private void Construct(ResultNode rn)
 {
     var bn = rn.BuildNode;
     if (bn == null)
     {
         throw new InjectionException("Internal failure");
     }
     ConstructorInfo ctor = bn.Constructor;
     var argts = ctor.GetParameters();
     var args = new object[argts.Length];
     for (int i = 0; i < argts.Length; ++i )
     {
         args[i] = rn.CtorArgs[i].Value;
     }
     rn.Node.Value = Activator.CreateInstance(rn.Node.TypeKey.Type, args);
     resolvedNodes[rn.Node.TypeKey] = rn;
     readyToFill.Enqueue(rn);
 }
 public virtual void OnTestFinished(ResultNode result)
 {
     int imageIndex = CalcImageIndex(result.Outcome);
     foreach(TreeNode treeNode in GetTreeNodesForTest(result))
         Tree.SetImageIndex(treeNode, imageIndex);
 }
        public void WhenTestSuiteCompletes_ProgressIsNotIncremented()
        {
            int priorValue = _view.Progress;
            var result = new ResultNode("<test-suite id='1'/>");

            _model.SuiteFinished += Raise.Event<TestResultEventHandler>(new TestResultEventArgs(TestAction.SuiteFinished, result));

            Assert.That(_view.Progress, Is.EqualTo(priorValue));
        }
        /// <summary>
        /// Post a test result to the tree, changing the treeNode
        /// color to reflect success or failure. Overridden here
        /// to allow for moving nodes from one group to another
        /// based on the result of running the test.
        /// </summary>
        protected override void OnTestFinished(ResultNode result)
        {
            base.OnTestFinished(result);

            _grouping.OnTestFinished(result);
        }
        public void WhenTestCaseCompletes_ProgressIsIncremented()
        {
            int priorValue = _view.Progress;
            var result = new ResultNode(XmlHelper.CreateXmlNode("<test-case id='1'/>"));

            _model.TestFinished += Raise.Event<TestEventHandler>(new TestEventArgs(TestAction.TestFinished, result));

            Assert.That(_view.Progress, Is.EqualTo(priorValue + 1));
        }
Example #55
0
        public void WhenTestCaseCompletes_NodeShowsProperResult(ResultState resultState, int expectedIndex)
        {
            _model.IsPackageLoaded.Returns(true);
            _model.HasTests.Returns(true);
            _view.DisplayFormat.SelectedItem.Returns("NUNIT_TREE");

            var result = resultState.Status.ToString();
            var label = resultState.Label;

            var testNode = new TestNode("<test-run id='1'><test-case id='123'/></test-run>");
            var resultNode = new ResultNode(string.IsNullOrEmpty(label)
                ? string.Format("<test-case id='123' result='{0}'/>", result)
                : string.Format("<test-case id='123' result='{0}' label='{1}'/>", result, label));
            _model.Tests.Returns(testNode);

            //var treeNode = _adapter.MakeTreeNode(result);
            //_adapter.NodeIndex[suiteResult.Id] = treeNode;
            _model.TestLoaded += Raise.Event<TestNodeEventHandler>(new TestNodeEventArgs(TestAction.TestLoaded, testNode));
            _model.TestFinished += Raise.Event<TestResultEventHandler>(new TestResultEventArgs(TestAction.TestFinished, resultNode));

            _view.Tree.Received().SetImageIndex(Arg.Any<TreeNode>(), expectedIndex);
        }