public void TestIsCollapsed() { FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); Assert.IsTrue(FPnl.IsCollapsed); FPnl.Toggle(); Assert.IsFalse(FPnl.IsCollapsed); FPnl.Toggle(); Assert.IsTrue(FPnl.IsCollapsed); FPnl.Collapse(); Assert.IsTrue(FPnl.IsCollapsed); FPnl.Expand(); Assert.IsFalse(FPnl.IsCollapsed); FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL, false); Assert.IsFalse(FPnl.IsCollapsed); FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, true); Assert.IsTrue(FPnl.IsCollapsed); FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, false); Assert.IsFalse(FPnl.IsCollapsed); FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster, true); Assert.IsTrue(FPnl.IsCollapsed); FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster, false); Assert.IsFalse(FPnl.IsCollapsed); }
public void TestEvents() { // Not just test that Events are fired, but that the RIGHT Events are fired under // the RIGHT circumstances, and that no wrong Event is fired under wrong circumstances! // (Uses EventHandlerCapture Class for that as NUnit doesn't provide Asserts for // something nifty like that!) FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); var EhcExpanded = new TNUnitEventHandlerCheck <System.EventArgs>(); var EhcCollapsed = new TNUnitEventHandlerCheck <System.EventArgs>(); FPnl.Expanded += EhcExpanded.Handler; FPnl.Collapsed += EhcCollapsed.Handler; // Assert that the Expanded Event is fired when the Control is Expanded (and that the Collapsed Event isn't) TNUnitEventAsserter.Assert(EhcExpanded, TNUnitEventAsserter.GotRaised <System.EventArgs>(), () => FPnl.Expand()); TNUnitEventAsserter.Assert(EhcCollapsed, TNUnitEventAsserter.DidNotGetRaised <System.EventArgs>(), () => FPnl.Expand()); // Assert that the Collapsed Event is fired when the Control is Expanded (and that the Expanded Event isn't) TNUnitEventAsserter.Assert(EhcCollapsed, TNUnitEventAsserter.GotRaised <System.EventArgs>(), () => FPnl.Collapse()); TNUnitEventAsserter.Assert(EhcExpanded, TNUnitEventAsserter.DidNotGetRaised <System.EventArgs>(), () => FPnl.Collapse()); FPnl.Expanded -= EhcExpanded.Handler; FPnl.Collapsed -= EhcCollapsed.Handler; // Assert that the Expanded/Collapsed Events are fired when the Control's Toggle Button is clicked // Need to resort to .NET Reflection as BtnToggleClick() is a Private Method... MethodInfo InvokedPrivateMethod = FPnl.GetType().GetMethod("BtnToggleClick", BindingFlags.NonPublic | BindingFlags.Instance); // It might look a bit weird to check Assert AreNotSame, but only this way we find out that the // .Invoke calls below do in fact do something! FPnl.Expanded += delegate(object sender, EventArgs e) { Assert.AreNotSame(FPnl, null); }; FPnl.Expanded += delegate(object sender, EventArgs e) { Assert.AreSame(FPnl, sender); }; FPnl.Collapsed += delegate(object sender, EventArgs e) { Assert.AreNotSame(FPnl, null); }; FPnl.Collapsed += delegate(object sender, EventArgs e) { Assert.AreSame(FPnl, sender); }; InvokedPrivateMethod.Invoke(FPnl, new object[] { FPnl, null }); InvokedPrivateMethod.Invoke(FPnl, new object[] { FPnl, null }); }
public void TestLazyInitialisationCumulative() { // UserControl FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); Assert.AreEqual(null, FPnl.UserControlInstance); // Lazy initialisation! Assert.AreEqual(null, FPnl.TaskListInstance); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); assertIsStable(FPnl); FPnl.Expand(); Assert.AreNotEqual(null, FPnl.UserControlInstance); // Now initialised as Expand() got called Assert.AreEqual(null, FPnl.TaskListInstance); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); FPnl.TaskListNode = TTestTaskList.GetTestXmlNode(); Assert.AreEqual(null, FPnl.TaskListInstance); // Lazy initialisation! // TaskList FPnl.HostedControlKind = THostedControlKind.hckTaskList; FPnl.Collapse(); FPnl.Expand(); Assert.AreNotEqual(null, FPnl.TaskListInstance); // Now initialised as Expand() got called Assert.AreNotEqual(null, FPnl.UserControlInstance); // This still exists from previous operation! Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); assertIsStable2(FPnl); // CollapsiblePanelHoster FPnl.HostedControlKind = THostedControlKind.hckCollapsiblePanelHoster; Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); // Lazy initialisation! Assert.AreNotEqual(null, FPnl.TaskListInstance); // This still exists from previous operation! Assert.AreNotEqual(null, FPnl.UserControlInstance); // This still exists from previous operation! FPnl.Toggle(); // same as FPnl.Collapse(); above FPnl.Toggle(); // same as FPnl.Expand(); above Assert.AreNotEqual(null, FPnl.CollapsiblePanelHosterInstance); // Now initialised as Expand() got called (trough Toggle()) Assert.AreNotEqual(null, FPnl.TaskListInstance); // This still exists from previous operation! Assert.AreNotEqual(null, FPnl.UserControlInstance); // This still exists from previous operation! assertIsStable2(FPnl); }
public void TestExpandAdditionalCodeCoverage() { // UserControl FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); FPnl.Expand(); FPnl.HostedControlKind = THostedControlKind.hckTaskList; FPnl.TaskListNode = TTestTaskList.GetTestXmlNode(); FPnl.Expand(); FPnl.HostedControlKind = THostedControlKind.hckCollapsiblePanelHoster; FPnl.Expand(); FPnl.HostedControlKind = THostedControlKind.hckTaskList; FPnl.Expand(); FPnl.HostedControlKind = THostedControlKind.hckUserControl; FPnl.Expand(); }
public void TestCollapsiblePanelHosterOtherTests() { // Ensure ENoTaskListNodeSpecifiedException is thrown if no TaskListNode got specified FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster); try { FPnl.RealiseCollapsiblePanelHoster(); } catch (Exception e) { Assert.AreEqual(typeof(ENoTaskListNodeSpecifiedException), e.GetType()); } // To ensure Unit Test code coverage only - nothing to assert here... FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster, TTestTaskList.GetTestXmlNode(), TCollapseDirection.cdHorizontalRight); FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse; FPnl.RealiseCollapsiblePanelHoster(); // To ensure Unit Test code coverage only - nothing to assert here... FPnl.Expand(); }
public void TestLazyInitialisation() { // UserControl FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); Assert.AreEqual(null, FPnl.UserControlInstance); // Lazy initialisation! Assert.AreEqual(null, FPnl.TaskListInstance); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); assertIsStable(FPnl); FPnl.Expand(); Assert.AreNotEqual(null, FPnl.UserControlInstance); // Now initialised as Expand() got called Assert.AreEqual(null, FPnl.TaskListInstance); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); assertIsStable(FPnl); FPnl.Collapse(); assertIsStable(FPnl); // TaskList FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, TTestTaskList.GetTestXmlNode()); Assert.AreEqual(null, FPnl.TaskListInstance); // Lazy initialisation! assertIsStable2(FPnl); FPnl.Expand(); Assert.AreNotEqual(null, FPnl.TaskListInstance); // Now initialised as Expand() got called Assert.AreEqual(null, FPnl.UserControlInstance); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); assertIsStable2(FPnl); FPnl.Collapse(); assertIsStable2(FPnl); // CollapsiblePanelHoster FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster, TTestTaskList.GetTestXmlNode()); Assert.AreEqual(null, FPnl.CollapsiblePanelHosterInstance); // Lazy initialisation! assertIsStable2(FPnl); FPnl.Expand(); Assert.AreNotEqual(null, FPnl.CollapsiblePanelHosterInstance); // Now initialised as Expand() got called Assert.AreEqual(null, FPnl.UserControlInstance); Assert.AreEqual(null, FPnl.TaskListInstance); assertIsStable2(FPnl); FPnl.Collapse(); assertIsStable2(FPnl); }
public void TestSetter_VisualStyleEnum() { FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, TTestTaskList.GetTestXmlNode()); Assert.AreEqual(TVisualStylesEnum.vsAccordionPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsTaskPanel; Assert.AreEqual(TVisualStylesEnum.vsTaskPanel, FPnl.VisualStyleEnum); FPnl.Collapse(); // To ensure Unit Test code coverage only - nothing to assert here... FPnl.Expand(); // To ensure Unit Test code coverage only - nothing to assert here... FPnl.RealiseTaskListNow(); // To ensure Unit Test code coverage only - nothing to assert here... FPnl.VisualStyleEnum = TVisualStylesEnum.vsAccordionPanel; Assert.AreEqual(TVisualStylesEnum.vsAccordionPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsDashboard; Assert.AreEqual(TVisualStylesEnum.vsDashboard, FPnl.VisualStyleEnum); FPnl.Expand(); // To ensure Unit Test code coverage only - nothing to assert here... // The following Tests should work with 'Assert.AreNotEqual' because the Visual Style we try to assign is only valid // for a different CollapseDirection: cdHorizontal or cdHorizontalRight FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse; Assert.AreNotEqual(TVisualStylesEnum.vsHorizontalCollapse, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsShepherd; Assert.AreNotEqual(TVisualStylesEnum.vsShepherd, FPnl.VisualStyleEnum); // Specifiying 'TVisualStylesEnum.vsHorizontalCollapse' in the next statement, which is invalid and... FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL, TVisualStylesEnum.vsHorizontalCollapse); // ...gets automatically corrected to TVisualStylesEnum.vsDashboard by the Control! Assert.AreEqual(TVisualStylesEnum.vsDashboard, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsAccordionPanel; Assert.AreEqual(TVisualStylesEnum.vsAccordionPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsTaskPanel; Assert.AreEqual(TVisualStylesEnum.vsTaskPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsDashboard; Assert.AreEqual(TVisualStylesEnum.vsDashboard, FPnl.VisualStyleEnum); // The following Tests should work with 'Assert.AreNotEqual' because the Visual Style we try to assign is only valid // for a different CollapseDirection: cdHorizontal or cdHorizontalRight FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse; Assert.AreNotEqual(TVisualStylesEnum.vsHorizontalCollapse, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsShepherd; Assert.AreNotEqual(TVisualStylesEnum.vsShepherd, FPnl.VisualStyleEnum); FPnl = new TPnlCollapsible(THostedControlKind.hckCollapsiblePanelHoster, TTestTaskList.GetTestXmlNode()); Assert.AreEqual(TVisualStylesEnum.vsAccordionPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsTaskPanel; Assert.AreEqual(TVisualStylesEnum.vsTaskPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsAccordionPanel; Assert.AreEqual(TVisualStylesEnum.vsAccordionPanel, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsDashboard; Assert.AreEqual(TVisualStylesEnum.vsDashboard, FPnl.VisualStyleEnum); // The following Tests should work with 'Assert.AreNotEqual' because the Visual Style we try to assign is only valid // for a different CollapseDirection: cdHorizontal or cdHorizontalRight FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse; Assert.AreNotEqual(TVisualStylesEnum.vsHorizontalCollapse, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsShepherd; Assert.AreNotEqual(TVisualStylesEnum.vsShepherd, FPnl.VisualStyleEnum); FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, TTestTaskList.GetTestXmlNode(), TVisualStylesEnum.vsShepherd, TCollapseDirection.cdHorizontal); Assert.AreEqual(TVisualStylesEnum.vsShepherd, FPnl.VisualStyleEnum); FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse; Assert.AreEqual(TVisualStylesEnum.vsHorizontalCollapse, FPnl.VisualStyleEnum); // To ensure Unit Test code coverage only - nothing to assert here... FPnl.RealiseTaskListNow(); FPnl.VisualStyleEnum = TVisualStylesEnum.vsShepherd; // To ensure Unit Test code coverage only - nothing to assert here... FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, TTestTaskList.GetTestXmlNode(), TVisualStylesEnum.vsHorizontalCollapse, TCollapseDirection.cdHorizontal); FPnl.VisualStyleEnum = TVisualStylesEnum.vsHorizontalCollapse_InfoPanelWithGradient; }
public void TestSetter_ActiveTaskItem() { XmlNode TestNode = TTestTaskList.GetTestXmlNode(); FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList, TestNode); FPnl.Expand(); Assert.IsNull(FPnl.ActiveTaskItem); FPnl.ActiveTaskItem = TestNode.ChildNodes[1]; Assert.AreEqual(FPnl.ActiveTaskItem, TestNode.ChildNodes[1]); FPnl.ActiveTaskItem = TestNode.ChildNodes[2]; Assert.AreEqual(FPnl.ActiveTaskItem, TestNode.ChildNodes[2]); FPnl.ActiveTaskItem = null; Assert.IsNull(FPnl.ActiveTaskItem); FPnl.TaskListNode = null; Assert.IsNull(FPnl.ActiveTaskItem); }
public void TestSetter_UserControlClass_UserControlNamespace_UserControlString() { // Changing of UserControl after realising a first UserControl specified through Constructor FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL); FPnl.RealiseUserControlNow(); UserControl UC1 = FPnl.UserControlInstance; FPnl.UserControlClass = "TUC_Subscription"; FPnl.UserControlNamespace = "Ict.Petra.Client.MPartner.Gui"; FPnl.RealiseUserControlNow(); Assert.AreNotEqual(UC1, FPnl.UserControlInstance); Assert.IsInstanceOf <Ict.Petra.Client.MPartner.Gui.TUC_Subscription>(FPnl.UserControlInstance); // Assigning of UserControl with UserControlClass and UserControlNamespace Properties FPnl = new TPnlCollapsible(new object[] { }); FPnl.UserControlClass = "TUC_Subscription"; FPnl.UserControlNamespace = "Ict.Petra.Client.MPartner.Gui"; FPnl.RealiseUserControlNow(); Assert.IsInstanceOf <Ict.Petra.Client.MPartner.Gui.TUC_Subscription>(FPnl.UserControlInstance); // Assigning of UserControl with UserControlString Property FPnl = new TPnlCollapsible(new object[] { }); FPnl.UserControlString = "Ict.Petra.Client.MPartner.Gui.TUC_Subscription"; // Calling Expand() has the side effect of instantiating the UserControl FPnl.Expand(); UserControl UC2 = FPnl.UserControlInstance; Assert.IsInstanceOf <Ict.Petra.Client.MPartner.Gui.TUC_Subscription>(UC2); // Assures that a further call only makes a previously instantiated UserControl visible again FPnl.Expand(); Assert.AreEqual(UC2, FPnl.UserControlInstance); }
public void TestConstructorUserControlWithInvalidClass() { FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl, HOSTEDUSERCONTROL + "WRONG"); assertIsStable(FPnl); //Now we want to check that we can't realise the task list without it throwing an exception. try { FPnl.Expand(); } catch (Exception e) { Assert.AreEqual(typeof(EUserControlCantInstantiateClassException), e.GetType()); } }
public void TestConstructorUserControlWithoutUserControlString() { FPnl = new TPnlCollapsible(THostedControlKind.hckUserControl); try { assertIsStable(FPnl); } catch (Exception e) { Assert.AreEqual(typeof(EInsufficientDataSetForHostedControlKindException), e.GetType()); } //Now we want to check that we can't realise the task list without it throwing an exception. try { FPnl.Expand(); } catch (Exception e) { Assert.AreEqual(typeof(EUserControlInvalidNamespaceSpecifiedException), e.GetType()); } }
public void TestConstructorTaskListWithoutXmlNode() { FPnl = new TPnlCollapsible(THostedControlKind.hckTaskList); try { assertIsStable2(FPnl); } catch (Exception e) { Assert.AreEqual(typeof(EInsufficientDataSetForHostedControlKindException), e.GetType()); } //Now we want to check that we can't realise the task list without it throwing an exception. try { FPnl.Expand(); } catch (Exception e) { Assert.AreEqual(typeof(ENoTaskListNodeSpecifiedException), e.GetType()); } }
public void TestConstructorXmlNode() { XmlNode TestXmlNode = TTestTaskList.GetTestXmlNode(); FPnl = new TPnlCollapsible(TestXmlNode, THostedControlKind.hckTaskList); Assert.AreEqual(TestXmlNode, FPnl.TaskListNode); assertIsStable2(FPnl); //Now we want to see if we can realise the task list without it throwing an exception. FPnl.Expand(); assertIsStable2(FPnl); }