//
// Authors:
// Ritvik Mayank (mritvik@novell.com)
+// Stefan Noack (noackstefan@googlemail.com)
//
using System;
using System.Collections;
-using InvalidEnumArgumentException = System.ComponentModel.InvalidEnumArgumentException;
+using System.ComponentModel;
using System.Drawing;
using System.Reflection;
using System.Runtime.Remoting;
using System.Threading;
using System.Windows.Forms;
+#if NET_2_0
+using System.Windows.Forms.Layout;
+#endif
using NUnit.Framework;
+using CategoryAttribute = NUnit.Framework.CategoryAttribute;
namespace MonoTests.System.Windows.Forms
{
[TestFixture]
- public class ControlTest
+ public class ControlTest : TestHelper
{
- class Helper {
- public static void TestAccessibility(Control c, string Default, string Description, string Name, AccessibleRole Role)
- {
- Assert.IsNotNull (c.AccessibilityObject, "Acc1");
- Assert.AreEqual (Default, c.AccessibleDefaultActionDescription, "Acc2");
- Assert.AreEqual (Description, c.AccessibleDescription, "Acc3");
- Assert.AreEqual (Name, c.AccessibleName, "Acc4");
- Assert.AreEqual (Role, c.AccessibleRole, "Acc5");
- }
+ [Test] // .ctor ()
+ public void Constructor1 ()
+ {
+ MockControl c = new MockControl ();
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "Height");
+ Assert.AreEqual (0, c.Left, "Left");
+ Assert.AreEqual (string.Empty, c.Name, "Name");
+ Assert.IsNull (c.Parent, "Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#A:Text");
+ Assert.AreEqual (0, c.Top, "Top");
+ Assert.AreEqual (0, c.Width, "Width");
+ }
- public static string TestControl(Control container, Control start, bool forward) {
- Control ctl;
+ [Test] // .ctor (String)
+ public void Constructor2 ()
+ {
+ MockControl c = new MockControl ((string) null);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#A:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#A:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#A:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#A:Height");
+ Assert.AreEqual (0, c.Left, "#A:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#A:Name");
+ Assert.IsNull (c.Parent, "#A:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#A:Text");
+ Assert.AreEqual (0, c.Top, "#A:Top");
+ Assert.AreEqual (0, c.Width, "#A:Width");
+
+ c = new MockControl ("child");
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#B:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#B:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#B:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#B:Height");
+ Assert.AreEqual (0, c.Left, "#B:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#B:Name");
+ Assert.IsNull (c.Parent, "#B:Parent");
+ Assert.AreEqual ("child", c.Text, "#B:Text");
+ Assert.AreEqual (0, c.Top, "#B:Top");
+ Assert.AreEqual (0, c.Width, "#B:Width");
+ }
- ctl = container.GetNextControl(start, forward);
+ [Test] // .ctor (Control, String)
+ public void Constructor3 ()
+ {
+ Control parent = new Control ("parent");
+ MockControl c = new MockControl ((Control) null, (string) null);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#A:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#A:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#A:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#A:Height");
+ Assert.AreEqual (0, c.Left, "#A:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#A:Name");
+ Assert.IsNull (c.Parent, "#A:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#A:Text");
+ Assert.AreEqual (0, c.Top, "#A:Top");
+ Assert.AreEqual (0, c.Width, "#A:Width");
+
+ c = new MockControl ((Control) null, "child");
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#B:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#B:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#B:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#B:Height");
+ Assert.AreEqual (0, c.Left, "#B:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#B:Name");
+ Assert.IsNull (c.Parent, "#B:Parent");
+ Assert.AreEqual ("child", c.Text, "#B:Text");
+ Assert.AreEqual (0, c.Top, "#B:Top");
+ Assert.AreEqual (0, c.Width, "#B:Width");
+
+ c = new MockControl (parent, (string) null);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#C:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#C:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#C:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#C:Height");
+ Assert.AreEqual (0, c.Left, "#C:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#C:Name");
+ Assert.AreSame (parent, c.Parent, "#C:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#C:Text");
+ Assert.AreEqual (0, c.Top, "#C:Top");
+ Assert.AreEqual (0, c.Width, "#C:Width");
+
+ c = new MockControl (parent, "child");
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#D:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#D:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#D:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#D:Height");
+ Assert.AreEqual (0, c.Left, "#D:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#D:Name");
+ Assert.AreSame (parent, c.Parent, "#D:Parent");
+ Assert.AreEqual ("child", c.Text, "#D:Text");
+ Assert.AreEqual (0, c.Top, "#D:Top");
+ Assert.AreEqual (0, c.Width, "#D:Width");
+ }
- if (ctl == null) {
- return null;
- }
+ [Test] // .ctor (String, Int32, Int32, Int32, Int32)
+ public void Constructor4 ()
+ {
+ MockControl c = new MockControl ((string) null, 0, 0, 0, 0);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#A:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#A:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#A:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#A:Height");
+ Assert.AreEqual (0, c.Left, "#A:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#A:Name");
+ Assert.IsNull (c.Parent, "#A:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#A:Text");
+ Assert.AreEqual (0, c.Top, "#A:Top");
+ Assert.AreEqual (0, c.Width, "#A:Width");
+
+ c = new MockControl ((string) null, 1, 0, 0, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#B:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#B:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#B:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#B:Height");
+ Assert.AreEqual (1, c.Left, "#B:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#B:Name");
+ Assert.IsNull (c.Parent, "#B:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#B:Text");
+ Assert.AreEqual (0, c.Top, "#B:Top");
+ Assert.AreEqual (0, c.Width, "#B:Width");
+
+ c = new MockControl ("child", 0, 1, 0, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#C:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#C:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#C:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#C:Height");
+ Assert.AreEqual (0, c.Left, "#C:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#C:Name");
+ Assert.IsNull (c.Parent, "#C:Parent");
+ Assert.AreEqual ("child", c.Text, "#C:Text");
+ Assert.AreEqual (1, c.Top, "#C:Top");
+ Assert.AreEqual (0, c.Width, "#C:Width");
+
+ c = new MockControl ("child", 0, 0, 1, 0);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#D:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#D:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#D:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#D:Height");
+ Assert.AreEqual (0, c.Left, "#D:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#D:Name");
+ Assert.IsNull (c.Parent, "#D:Parent");
+ Assert.AreEqual ("child", c.Text, "#D:Text");
+ Assert.AreEqual (0, c.Top, "#D:Top");
+ Assert.AreEqual (1, c.Width, "#D:Width");
+
+ c = new MockControl ("child", 0, 0, 0, 1);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#E:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#E:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#E:OnSizeChangedCount");
+ Assert.AreEqual (1, c.Height, "#E:Height");
+ Assert.AreEqual (0, c.Left, "#E:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#E:Name");
+ Assert.IsNull (c.Parent, "#E:Parent");
+ Assert.AreEqual ("child", c.Text, "#E:Text");
+ Assert.AreEqual (0, c.Top, "#E:Top");
+ Assert.AreEqual (0, c.Width, "#E:Width");
+
+ c = new MockControl ("child", 1, 0, 1, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#F:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#F:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#F:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#F:Height");
+ Assert.AreEqual (1, c.Left, "#F:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#F:Name");
+ Assert.IsNull (c.Parent, "#F:Parent");
+ Assert.AreEqual ("child", c.Text, "#F:Text");
+ Assert.AreEqual (0, c.Top, "#F:Top");
+ Assert.AreEqual (1, c.Width, "#F:Width");
+
+ c = new MockControl ("child", 0, 1, 0, 1);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#G:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#G:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#G:OnSizeChangedCount");
+ Assert.AreEqual (1, c.Height, "#G:Height");
+ Assert.AreEqual (0, c.Left, "#G:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#G:Name");
+ Assert.IsNull (c.Parent, "#G:Parent");
+ Assert.AreEqual ("child", c.Text, "#G:Text");
+ Assert.AreEqual (1, c.Top, "#G:Top");
+ Assert.AreEqual (0, c.Width, "#G:Width");
+ }
- return ctl.Text;
+ [Test] // .ctor (Control, String, Int32, Int32, Int32, Int32)
+ public void Constructor5 ()
+ {
+ Control parent = new Control ("parent");
+ MockControl c = new MockControl ((Control) null,
+ (string) null, 0, 0, 0, 0);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#A:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#A:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#A:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#A:Height");
+ Assert.AreEqual (0, c.Left, "#A:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#A:Name");
+ Assert.IsNull (c.Parent, "#A:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#A:Text");
+ Assert.AreEqual (0, c.Top, "#A:Top");
+ Assert.AreEqual (0, c.Width, "#A:Width");
+
+ c = new MockControl (parent, (string) null, 1, 0, 0, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#B:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#B:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#B:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#B:Height");
+ Assert.AreEqual (1, c.Left, "#B:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#B:Name");
+ Assert.AreSame (parent, c.Parent, "#B:Parent");
+ Assert.AreEqual (string.Empty, c.Text, "#B:Text");
+ Assert.AreEqual (0, c.Top, "#B:Top");
+ Assert.AreEqual (0, c.Width, "#B:Width");
+
+ c = new MockControl ((Control) null, "child", 0, 1, 0, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#C:OnLocationChangedCount");
+ Assert.AreEqual (0, c.OnResizeCount, "#C:OnResizeCount");
+ Assert.AreEqual (0, c.OnSizeChangedCount, "#C:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#C:Height");
+ Assert.AreEqual (0, c.Left, "#C:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#C:Name");
+ Assert.IsNull (c.Parent, "#C:Parent");
+ Assert.AreEqual ("child", c.Text, "#C:Text");
+ Assert.AreEqual (1, c.Top, "#C:Top");
+ Assert.AreEqual (0, c.Width, "#C:Width");
+
+ c = new MockControl (parent, "child", 0, 0, 1, 0);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#D:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#D:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#D:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#D:Height");
+ Assert.AreEqual (0, c.Left, "#D:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#D:Name");
+ Assert.AreSame (parent, c.Parent, "#D:Parent");
+ Assert.AreEqual ("child", c.Text, "#D:Text");
+ Assert.AreEqual (0, c.Top, "#D:Top");
+ Assert.AreEqual (1, c.Width, "#D:Width");
+
+ c = new MockControl (parent, "child", 0, 0, 0, 1);
+
+ Assert.AreEqual (0, c.OnLocationChangedCount, "#E:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#E:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#E:OnSizeChangedCount");
+ Assert.AreEqual (1, c.Height, "#E:Height");
+ Assert.AreEqual (0, c.Left, "#E:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#E:Name");
+ Assert.AreSame (parent, c.Parent, "#E:Parent");
+ Assert.AreEqual ("child", c.Text, "#E:Text");
+ Assert.AreEqual (0, c.Top, "#E:Top");
+ Assert.AreEqual (0, c.Width, "#E:Width");
+
+ c = new MockControl (parent, "child", 1, 0, 1, 0);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#F:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#F:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#F:OnSizeChangedCount");
+ Assert.AreEqual (0, c.Height, "#F:Height");
+ Assert.AreEqual (1, c.Left, "#F:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#F:Name");
+ Assert.AreSame (parent, c.Parent, "#F:Parent");
+ Assert.AreEqual ("child", c.Text, "#F:Text");
+ Assert.AreEqual (0, c.Top, "#F:Top");
+ Assert.AreEqual (1, c.Width, "#F:Width");
+
+ c = new MockControl (parent, "child", 0, 1, 0, 1);
+
+ Assert.AreEqual (1, c.OnLocationChangedCount, "#G:OnLocationChangedCount");
+ Assert.AreEqual (1, c.OnResizeCount, "#G:OnResizeCount");
+ Assert.AreEqual (1, c.OnSizeChangedCount, "#G:OnSizeChangedCount");
+ Assert.AreEqual (1, c.Height, "#G:Height");
+ Assert.AreEqual (0, c.Left, "#G:Left");
+ Assert.AreEqual (string.Empty, c.Name, "#G:Name");
+ Assert.AreSame (parent, c.Parent, "#G:Parent");
+ Assert.AreEqual ("child", c.Text, "#G:Text");
+ Assert.AreEqual (1, c.Top, "#G:Top");
+ Assert.AreEqual (0, c.Width, "#G:Width");
+ }
+
+ [Test]
+ public void DisposeTest ()
+ {
+ ControlDisposeTester control = new ControlDisposeTester ();
+ control.Visible = true;
+ control.Dispose ();
+
+ try {
+ control.CreateControl ();
+ } catch (ObjectDisposedException ex) {
+ Console.WriteLine (ex);
+ Assert.Fail ("#1");
+ }
+ Assert.IsFalse (control.IsHandleCreated, "#2");
+
+ // The control remains Visible until WM_DESTROY is received.
+ Assert.IsTrue (control.Visible, "#3");
+
+ try {
+ control.InvokeCreateHandle ();
+ Assert.Fail ("#4");
+ } catch (ObjectDisposedException ex) {
+ //Console.WriteLine (ex);
}
}
+ private class ControlDisposeTester : Control
+ {
+ public void InvokeCreateHandle ()
+ {
+ CreateHandle ();
+ }
+ }
+#if NET_2_0
[Test]
- public void CreatedTest ()
+ public void AutoSizeTest ()
{
- Control c = new Control ();
- Assert.IsFalse (c.Created, "A1");
+ ControlAutoSizeTester c = new ControlAutoSizeTester (new Size (23, 17), AutoSizeMode.GrowAndShrink);
+
+ Form f = new Form();
+ f.Size = new Size (200, 200);
+ c.Parent = f;
+ f.Show();
+
+ Size s = new Size (42, 42);
+ c.Size = s;
+
+ Point l = new Point (10, 10);
+ c.Location = l;
+
+ //Check wether normal size setting is OK
+ Assert.AreEqual (s, c.Size, "#S1");
+
+ //Check wether size remains without GetPreferredSize implemented even when AutoSize turned on.
+ c.AutoSize = true;
+ f.PerformLayout();
+ Assert.AreEqual (s, c.Size, "#S2");
+
+ //Simulate a Control implementing GetPreferredSize
+ c.UseCustomPrefSize = true;
+ f.PerformLayout();
+
+ //Check wether size shrinks to preferred size
+ Assert.AreEqual (c.CustomPrefSize, c.Size, "#S3");
+ //Check wether Location stays constant
+ Assert.AreEqual (l, c.Location, "#L1");
+
+ //Check wether Dock is respected
+ c.Dock = DockStyle.Bottom;
+ Assert.AreEqual (f.ClientSize.Width, c.Width, "#D1");
+
+ //Check wether size shrinks to preferred size again
+ c.Dock = DockStyle.None;
+ Assert.AreEqual (c.CustomPrefSize, c.Size, "#S4");
+
+ //Check wether Anchor is respected for adjusting Locatioon
+ c.Anchor = AnchorStyles.Bottom;
+ f.Height += 50;
+ Assert.AreEqual (l.Y + 50, c.Top, "#A1");
+ //Check wether size is still OK
+ Assert.AreEqual (c.CustomPrefSize, c.Size, "#S5");
+
+
+ //just tidy up
+ c.Anchor = AnchorStyles.Top | AnchorStyles.Left;
+ c.Location = l;
+
+ //Check wether shrinking to zero is possible
+ c.CustomPrefSize = new Size (0, 0);
+ f.PerformLayout();
+ Assert.AreEqual (c.CustomPrefSize, c.Size, "#S6");
+
+ //Check wether MinimumSize is honored
+ c.MinimumSize = new Size (10, 12);
+ c.CustomPrefSize = new Size (5, 5);
+ f.PerformLayout();
+ Assert.AreEqual (c.MinimumSize, c.Size, "#S7");
+ c.MinimumSize = new Size (0, 0);
+
+ //Check wether MaximumSize is honored
+ c.MaximumSize = new Size (100, 120);
+ c.CustomPrefSize = new Size (500, 500);
+ f.PerformLayout();
+ Assert.AreEqual (c.MaximumSize, c.Size, "#S8");
+
+ //Check wether shrinking does not happen when GrowOnly
+ c.AutoSize = false;
+ s = new Size (23, 23);
+ c.Size = s;
+ c.CustomPrefSize = new Size (5, 5);
+ c.AutoSizeMode = AutoSizeMode.GrowOnly;
+ c.AutoSize = true;
+ f.PerformLayout();
+ Assert.AreEqual (s, c.Size, "#S9");
+ f.Close ();
}
+
+ public class ControlAutoSizeTester : Control {
+
+
+ public ControlAutoSizeTester (Size customPrefSize, AutoSizeMode autoSizeMode)
+ {
+ custom_prefsize = customPrefSize;
+ AutoSizeMode = autoSizeMode;
+ }
+
+ public AutoSizeMode AutoSizeMode {
+ set {
+ base.SetAutoSizeMode (value);
+ }
+ }
+ private bool use_custom_prefsize = false;
+ public bool UseCustomPrefSize {
+ set {
+ use_custom_prefsize = value;
+ }
+ }
+
+ private Size custom_prefsize;
+
+ public Size CustomPrefSize {
+ get {
+ return custom_prefsize;
+ }
+ set {
+ custom_prefsize = value;
+ }
+ }
+
+
+ public override Size GetPreferredSize (Size proposedSize)
+ {
+ if (use_custom_prefsize) {
+ return custom_prefsize;
+ } else {
+ return base.GetPreferredSize(proposedSize);
+ }
+ }
+
+ }
+#endif
+
[Test]
- [Category ("NotWorking")]
- public void CreatedAccessibilityTest ()
+ public void Bug82748 ()
{
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+
Control c = new Control ();
- Assert.IsFalse (c.Created, "A1");
+ c.Size = new Size (100, 100);
+
+ Control c2 = new Control ();
+ c2.Size = c.Size;
+ c2.Controls.Add (c);
+
+ c.Anchor = AnchorStyles.Right;
+
+ f.Controls.Add (c);
+
+ f.Show ();
+
+ Assert.AreEqual (0, c.Left, "A1");
+
+ f.Close ();
+ f.Dispose ();
+ }
+
+ [Test]
+ public void InvokeTestParentHandle ()
+ {
+ Control child, parent;
+
+ parent = new Control ();
+ child = new Control ();
+ parent.Controls.Add (child);
+ parent.Visible = true;
+ parent.CreateControl ();
+ child.Invoke (new CrossAppDomainDelegate (dummy)) ;
+ }
+
+ public void dummy ()
+ {
+ }
+
+ public class ControlStylesTester : Control {
+ private WindowStyles style;
+ private WindowStyles ex_style;
+ private bool or_styles;
- Helper.TestAccessibility(c, null, null, null, AccessibleRole.Default);
+ public ControlStylesTester (WindowStyles Style, WindowStyles ExStyle, bool OrStyles)
+ {
+ style = Style;
+ ex_style = ExStyle;
+ or_styles = OrStyles;
+ }
- Assert.IsTrue (c.Created, "A2");
+ protected override CreateParams CreateParams {
+ get {
+ CreateParams result = base.CreateParams;
+ if (or_styles) {
+ result.Style |= (int) style;
+ result.ExStyle |= (int) ex_style;
+ } else {
+ result.Style = (int) style;
+ result.ExStyle = (int) ex_style;
+ }
+ return result;
+ }
+ }
+ }
+
+ [Test]
+ public void ControlSizeTest ()
+ {
+ ControlStylesTester c = new ControlStylesTester (WindowStyles.WS_CHILD, 0, true);
+ Assert.AreEqual ("{X=0,Y=0}", c.Location.ToString (), "#L1");
+ Assert.AreEqual ("{Width=0, Height=0}", c.Size.ToString (), "#S1");
+ }
- c.Dispose ();
+#if NET_2_0
+ [Test]
+ public void CaptureTest ()
+ {
+ Form frm = new Form ();
+ ControlOverrideLogger log = new ControlOverrideLogger ();
+ frm.Controls.Add (log);
+ log.Visible = true;
+ log.Capture = true;
+ log.Capture = false;
+ log.BackColor = Color.Blue;
+ log.Size = new Size (100, 100);
+
+ frm.Show ();
+ Application.DoEvents ();
+
+ frm.Dispose ();
+ Assert.IsTrue (log.Log.ToString ().IndexOf ("OnMouseCaptureChanged") > -1, "#01");
+
+ log = new ControlOverrideLogger ();
+ log.Capture = true;
+ log.Capture = false;
+ Assert.IsTrue (log.Log.ToString ().IndexOf ("OnMouseCaptureChanged") > -1, "#02");
+
+ log = new ControlOverrideLogger ();
+ log.Capture = true;
+ Assert.IsTrue (log.IsHandleCreated, "#03");
+ Assert.IsTrue (log.Log.ToString ().IndexOf ("OnMouseCaptureChanged") == -1, "#04");
+
+ log = new ControlOverrideLogger ();
+ log.Capture = false;
+ Assert.IsFalse (log.IsHandleCreated, "#05");
+ Assert.IsTrue (log.Log.ToString ().IndexOf ("OnMouseCaptureChanged") == -1, "#06");
+ }
+#endif
+
+ public class OnPaintTester : Form
+ {
+ int counter;
+ int total;
+ ArrayList list = new ArrayList ();
+ public bool Recursive;
+ public bool TestRefresh;
+ public bool TestInvalidate;
+ public bool TestUpdate;
+#if NET_2_0
+ public new bool DoubleBuffered {
+ get {
+ return base.DoubleBuffered;
+ }
+ set {
+ base.DoubleBuffered = value;
+ }
+ }
+#endif
+ protected override void OnPaint (PaintEventArgs pevent)
+ {
+ Assert.IsFalse (list.Contains (pevent.Graphics), "OnPaintTester.OnPaint: Got the same Graphics twice");
+ list.Add (pevent.Graphics);
+
+ if (total > 10)
+ return;
+ Recursive = counter > 0 || Recursive;
+ counter++;
+ if (counter < 2) {
+ if (TestRefresh)
+ Refresh ();
+ else if (TestInvalidate)
+ Invalidate ();
+ else {
+ Update ();
+ }
+ }
+ base.OnPaint (pevent);
+ counter--;
+ total++;
+ }
+ public new void Show ()
+ {
+ base.Show ();
+ Application.DoEvents ();
+ }
+ }
- Assert.IsFalse (c.Created, "A3");
+ [Test]
+ public void ControlCollectionTest ()
+ {
+ Form frm = new Form ();
+ frm.IsMdiContainer = true;
+ Form child = new Form ();
+ Control.ControlCollection c = new Control.ControlCollection (frm);
+ child.MdiParent = frm;
+ c.Add (child);
+
+ child.Dispose ();
+ frm.Dispose ();
}
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ControlCollectionExceptionTest ()
+ {
+ Form frm = new Form ();
+ frm.IsMdiContainer = true;
+ Form child = new Form ();
+ Control.ControlCollection c = new Control.ControlCollection (frm);
+ //child.MdiParent = frm;
+ c.Add (child);
+
+ child.Dispose ();
+ frm.Dispose ();
+ }
+
[Test]
[Category ("NotWorking")]
- public void BoundsTest ()
+ public void OnPaintTest ()
{
- Control c = new Control ();
- Assert.IsTrue (c.Bounds.IsEmpty, "A1");
- Assert.IsTrue (c.Size.IsEmpty, "A2");
- Assert.IsTrue (c.ClientSize.IsEmpty, "A3");
- Assert.IsTrue (c.ClientRectangle.IsEmpty, "A4");
-
- Assert.AreEqual (((IWin32Window)c).Handle, c.Handle, "A5");
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.TestRefresh = true;
+ t.Show ();
+ Assert.IsTrue (t.Recursive, "#1");
+ }
- /* this part fails on linux because we can't allocate X windows which are 0x0,
- and the Control bounds directly reflect the size of the X window */
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.TestUpdate = true;
+ t.Show ();
+ Assert.IsFalse (t.Recursive, "#2");
+ }
- Assert.IsTrue (c.Bounds.IsEmpty, "A6");
- Assert.IsTrue (c.Size.IsEmpty, "A7");
- Assert.IsTrue (c.ClientSize.IsEmpty, "A8");
- Assert.IsTrue (c.ClientRectangle.IsEmpty, "A9");
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.TestInvalidate = true;
+ t.Show ();
+ Assert.IsFalse (t.Recursive, "#3");
+ }
}
-
+#if NET_2_0
[Test]
- public void PubPropTest()
- {
- Control c = new Control();
+ [Category ("Interactive")]
+ public void OnPaintDoubleBufferedTest ()
+ {
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.DoubleBuffered = true;
+ t.TestRefresh = true;
+ t.Show ();
+ Assert.IsTrue (t.Recursive, "#1");
+ }
- Assert.IsFalse (c.AllowDrop , "A1");
- Assert.AreEqual(AnchorStyles.Top | AnchorStyles.Left, c.Anchor, "A2");
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.DoubleBuffered = true;
+ t.TestUpdate = true;
+ t.Show ();
+ Assert.IsFalse (t.Recursive, "#2");
+ }
- Assert.AreEqual ("Control", c.BackColor.Name , "B1");
- Assert.IsNull (c.BackgroundImage, "B2");
- Assert.IsNull (c.BindingContext, "B3");
+ using (OnPaintTester t = new OnPaintTester ()) {
+ t.DoubleBuffered = true;
+ t.TestInvalidate = true;
+ t.Show ();
+ Assert.IsFalse (t.Recursive, "#3");
+ }
+ }
+#endif
+ public class PaintEventForm : Form
+ {
+ public ArrayList overrides = new ArrayList ();
+ public ArrayList events = new ArrayList ();
- Assert.IsFalse (c.CanFocus, "C1");
- Assert.IsTrue (c.CanSelect, "C2");
- Assert.IsFalse (c.Capture, "C3");
- Assert.IsTrue (c.CausesValidation, "C4");
+ public PaintEventForm ()
+ {
+ Paint += new PaintEventHandler (DoubleBufferEventForm_Paint);
+ }
+ public bool GetControlStyle (ControlStyles style)
+ {
+ return base.GetStyle (style);
+ }
- Assert.IsNotNull (c.CompanyName, "C7");
- Assert.IsNull (c.Container, "C8");
- Assert.IsFalse (c.ContainsFocus, "C9");
- Assert.IsNull (c.ContextMenu, "C10");
- Assert.AreEqual (0, c.Controls.Count, "C11");
- Assert.IsFalse (c.Created, "C12");
- Assert.AreEqual (Cursors.Default, c.Cursor, "C13");
+ public void SetControlStyle (ControlStyles style, bool value)
+ {
+ base.SetStyle (style, value);
+ }
+
+ void DoubleBufferEventForm_Paint (object sender, PaintEventArgs e)
+ {
+ events.Add("Paint");
+ }
+
+ protected override void OnPaintBackground (PaintEventArgs e)
+ {
+ base.OnPaintBackground (e);
+ overrides.Add("OnPaintBackground");
+ }
- Assert.IsNotNull(c.DataBindings, "D1");
- Assert.AreEqual("Control", Control.DefaultBackColor.Name, "D2");
- Assert.AreEqual("ControlText", Control.DefaultForeColor.Name, "D3");
- Assert.AreEqual(FontStyle.Regular, Control.DefaultFont.Style, "D4");
- Assert.AreEqual (new Rectangle(0, 0, 0, 0), c.DisplayRectangle , "D5");
- Assert.IsFalse (c.Disposing, "D6");
- Assert.AreEqual(DockStyle.None, c.Dock, "D7");
+ protected override void OnPaint (PaintEventArgs pevent)
+ {
+ base.OnPaint (pevent);
+ overrides.Add("OnPaint");
+ }
+ }
- Assert.IsTrue (c.Enabled, "E1");
+ [Test]
+ [Ignore ("Can't find a reliable way to generate a paint message on Windows.")]
+ public void EventStyleTest ()
+ {
+#if NET_2_0
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.OptimizedDoubleBuffer, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#A1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#A2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#A3");
+ }
+#endif
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.DoubleBuffer, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#B1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#B2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#B3");
+ }
- Assert.IsFalse (c.Focused, "F1");
- Assert.AreEqual (FontStyle.Regular, c.Font.Style, "F2");
- Assert.AreEqual (SystemColors.ControlText, c.ForeColor, "F3");
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.AllPaintingInWmPaint, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#C1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#C2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#C3");
+ }
- Assert.IsFalse (c.HasChildren, "H2");
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.UserPaint, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#D1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#D2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#D3");
+ }
- Assert.AreEqual (ImeMode.NoControl, c.ImeMode, "I1");
- Assert.IsFalse (c.InvokeRequired, "I2");
- Assert.IsFalse (c.IsAccessible, "I3");
- Assert.IsFalse (c.IsDisposed, "I4");
- Assert.IsFalse (c.IsHandleCreated, "I5");
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#E1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#E2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#E3");
+ }
- Assert.AreEqual(Point.Empty, c.Location, "L2");
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#F1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#F2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#F3");
+ }
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.DoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#G1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#G2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#G3");
+ }
+
+ using (PaintEventForm f = new PaintEventForm ()) {
+ f.Show ();
+ f.SetControlStyle (ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.DoubleBuffer, true);
+ f.Refresh ();
+ Assert.IsTrue (f.overrides.Contains ("OnPaintBackground"), "#H1");
+ Assert.IsTrue (f.overrides.Contains ("OnPaint"), "#H2");
+ Assert.IsTrue (f.events.Contains ("Paint"), "#H3");
+ }
+ }
#if NET_2_0
- Assert.IsTrue(c.MaximumSize.IsEmpty);
- Assert.IsTrue(c.MinimumSize.IsEmpty);
-#endif
- Assert.AreEqual (Keys.None, Control.ModifierKeys, "M1");
- Assert.IsFalse (Control.MousePosition.IsEmpty, "M2");
- Assert.AreEqual (MouseButtons.None, Control.MouseButtons, "M3");
+ public class DoubleBufferedForm : Form
+ {
+ public bool painted;
+ public bool failed;
+ public DoubleBufferedForm ()
+ {
+ this.DoubleBuffered = true;
+ }
+
+ protected override void OnPaint (PaintEventArgs e)
+ {
+ if (failed || painted)
+ return;
+ painted = true;
+ Height = Height + 1;
+ try {
+ e.Graphics.DrawString (Size.ToString (), Font, Brushes.AliceBlue, new Point (2, 2));
+ } catch (Exception exception) {
+ Console.WriteLine (exception.StackTrace);
+ failed = true;
+ }
+ }
+ }
+
+ public class DoubleBufferControl : Control
+ {
+ public bool IsDoubleBuffered
+ {
+ get { return base.DoubleBuffered; }
+ set { base.DoubleBuffered = value; }
+ }
+
+ public bool GetControlStyle (ControlStyles style)
+ {
+ return base.GetStyle (style);
+ }
+
+ public void SetControlStyle (ControlStyles style, bool value)
+ {
+ base.SetStyle (style, value);
+ }
+ }
+
+ [Test]
+ [Ignore ("Can't find a reliable way to generate a paint message on Windows.")]
+ public void DoubleBufferTest ()
+ {
+ DoubleBufferedForm f = new DoubleBufferedForm ();
+ f.ShowInTaskbar = false;
+ f.Show ();
+ f.Refresh ();
+
+ Assert.IsFalse (f.failed, "#01");
+ Assert.IsTrue (f.painted, "The control was never painted, so please check the test");
+ f.Close ();
+ }
+
+ [Test]
+ public void DoubleBufferedTest ()
+ {
+ DoubleBufferControl c = new DoubleBufferControl ();
+ Assert.IsFalse (c.IsDoubleBuffered, "#A1");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#A2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#A3");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#A4");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.UserPaint), "#A5");
+
+ c.SetControlStyle (ControlStyles.OptimizedDoubleBuffer, true);
+ Assert.IsTrue (c.IsDoubleBuffered, "#B1");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#B2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#B3");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#B4");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.UserPaint), "#A5");
+
+ c.SetControlStyle (ControlStyles.AllPaintingInWmPaint, false);
+ c.SetControlStyle (ControlStyles.UserPaint, false);
+ Assert.IsTrue (c.IsDoubleBuffered, "#C1");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#C2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#C3");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#C4");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.UserPaint), "#C5");
+
+ c.SetControlStyle (ControlStyles.OptimizedDoubleBuffer, false);
+ Assert.IsFalse (c.IsDoubleBuffered, "#D1");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#D2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#D3");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#D4");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.UserPaint), "#D5");
+
+ c.SetControlStyle (ControlStyles.DoubleBuffer, true);
+ Assert.IsFalse (c.IsDoubleBuffered, "#E1");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#E2");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.DoubleBuffer), "#E3");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#E4");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.UserPaint), "#E5");
+
+ c.SetControlStyle (ControlStyles.DoubleBuffer, false);
+ Assert.IsFalse (c.IsDoubleBuffered, "#F1");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#F2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#F3");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#F4");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.UserPaint), "#F5");
+
+ c.IsDoubleBuffered = true;
+ Assert.IsTrue (c.IsDoubleBuffered, "#G1");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#G2");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.DoubleBuffer), "#G3");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#G4");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.UserPaint), "#G5");
+
+ c.SetControlStyle (ControlStyles.AllPaintingInWmPaint, true);
+ c.SetControlStyle (ControlStyles.OptimizedDoubleBuffer, true);
+ c.SetControlStyle (ControlStyles.DoubleBuffer, true);
+ c.SetControlStyle (ControlStyles.UserPaint, true);
+ c.IsDoubleBuffered = false;
+ Assert.IsFalse (c.IsDoubleBuffered, "#H1");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.AllPaintingInWmPaint), "#H2");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.DoubleBuffer), "#H3");
+ Assert.IsFalse (c.GetControlStyle (ControlStyles.OptimizedDoubleBuffer), "#H4");
+ Assert.IsTrue (c.GetControlStyle (ControlStyles.UserPaint), "#H5");
+ }
+
+ [Test]
+ public void DoubleBufferedStyleTest ()
+ {
+ DoubleBufferControl c = new DoubleBufferControl ();
+ TestControlStyle.CheckStyles (c, "#A1", ControlStyles.UserPaint, ControlStyles.StandardClick, ControlStyles.Selectable, ControlStyles.StandardDoubleClick, ControlStyles.AllPaintingInWmPaint, ControlStyles.UseTextForAccessibility);
+
+ c.IsDoubleBuffered = true;
+ TestControlStyle.CheckStyles (c, "#A2", ControlStyles.UserPaint, ControlStyles.StandardClick, ControlStyles.Selectable, ControlStyles.StandardDoubleClick, ControlStyles.AllPaintingInWmPaint, ControlStyles.UseTextForAccessibility, ControlStyles.OptimizedDoubleBuffer);
+
+ c.IsDoubleBuffered = false;
+ TestControlStyle.CheckStyles (c, "#A3", ControlStyles.UserPaint, ControlStyles.StandardClick, ControlStyles.Selectable, ControlStyles.StandardDoubleClick, ControlStyles.AllPaintingInWmPaint, ControlStyles.UseTextForAccessibility);
+
+ c = new DoubleBufferControl ();
+ foreach (ControlStyles style in Enum.GetValues (typeof(ControlStyles))) {
+ c.SetControlStyle (style, false);
+ }
+
+ TestControlStyle.CheckStyles (c, "#B1");
+
+ c.IsDoubleBuffered = true;
+ TestControlStyle.CheckStyles (c, "#B2", ControlStyles.OptimizedDoubleBuffer, ControlStyles.AllPaintingInWmPaint);
+
+ c.IsDoubleBuffered = false;
+ TestControlStyle.CheckStyles (c, "#B3", ControlStyles.AllPaintingInWmPaint);
+
+ }
+#endif
+
+ class Helper {
+ public static void TestAccessibility(Control c, string Default, string Description, string Name, AccessibleRole Role)
+ {
+ Assert.IsNotNull (c.AccessibilityObject, "Acc1");
+ Assert.AreEqual (Default, c.AccessibleDefaultActionDescription, "Acc2");
+ Assert.AreEqual (Description, c.AccessibleDescription, "Acc3");
+ Assert.AreEqual (Name, c.AccessibleName, "Acc4");
+ Assert.AreEqual (Role, c.AccessibleRole, "Acc5");
+ }
+
+ public static string TestControl(Control container, Control start, bool forward) {
+ Control ctl;
+
+ ctl = container.GetNextControl(start, forward);
+
+ if (ctl == null) {
+ return null;
+ }
+
+ return ctl.Text;
+ }
+ }
+
+ [Test]
+ public void CreatedTest ()
+ {
+ Control c = new Control ();
+ Assert.IsFalse (c.Created, "A1");
+ }
+
+ class CustomA11yEnabledControl : Control {
+ public CustomA11yEnabledControl () : base() { }
+ protected override AccessibleObject CreateAccessibilityInstance () { return new CustomAccessibleObject (this); }
+
+ class CustomAccessibleObject : ControlAccessibleObject {
+ public CustomAccessibleObject (CustomA11yEnabledControl control) : base(control) { }
+ public override string Name { get { return "custom name"; } }
+ public override string DefaultAction { get { return "custom default action"; } }
+ public override string Description { get { return "custom description"; } }
+ public override AccessibleRole Role { get { return AccessibleRole.Alert; } }
+ }
+ }
+
+ [Test]
+ public void CreatedAccessibilityTest ()
+ {
+ CustomA11yEnabledControl c = new CustomA11yEnabledControl ();
+ Assert.IsFalse(c.Created, "A1");
+
+ // Tests default values
+
+ Assert.AreEqual (null, c.AccessibleDefaultActionDescription, "A2.0");
+ Assert.IsFalse(c.IsHandleCreated, "A2.1");
+
+ Assert.AreEqual (null, c.AccessibleDescription, "A3.0");
+ Assert.IsFalse(c.IsHandleCreated, "A3.1");
+
+ Assert.AreEqual (null, c.AccessibleName, "A4.0");
+ Assert.IsFalse(c.IsHandleCreated, "A4.1");
+
+ Assert.AreEqual (AccessibleRole.Default, c.AccessibleRole, "A5.0");
+ Assert.IsFalse(c.IsHandleCreated, "A5.1");
+
+ object o = c.AccessibilityObject;
+ Assert.IsTrue(c.IsHandleCreated, "A6");
+
+ // Tests to confirm that:
+ // - calling Control.AccessibleXXXXX is not returning AccessibleObject.XXXXX
+ // - Handle is not Created when calling Control.AccessibleXXXXX
+ c = new CustomA11yEnabledControl ();
+
+ string accessibleDefaultActionDescription = "default action description";
+ c.AccessibleDefaultActionDescription = accessibleDefaultActionDescription;
+ Assert.IsFalse (c.IsHandleCreated, "A7.0");
+ Assert.AreEqual (accessibleDefaultActionDescription, c.AccessibleDefaultActionDescription, "A7.1");
+
+ string accessibleDescription = "accessible description";
+ c.AccessibleDescription = accessibleDescription;
+ Assert.IsFalse (c.IsHandleCreated, "A8.0");
+ Assert.AreEqual (accessibleDescription, c.AccessibleDescription, "A8.1");
+
+ string accessibleName = "accessible name";
+ c.AccessibleName = accessibleName;
+ Assert.IsFalse (c.IsHandleCreated, "A9.0");
+ Assert.AreEqual (accessibleName, c.AccessibleName, "A9.1");
+
+ AccessibleRole accessibleRole = AccessibleRole.Diagram;
+ c.AccessibleRole = accessibleRole;
+ Assert.AreEqual (accessibleRole, c.AccessibleRole, "A10.0");
+ Assert.IsFalse (c.IsHandleCreated, "A10.1");
+
+ c.Dispose ();
+ Assert.IsFalse (c.Created, "A11");
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void BoundsTest ()
+ {
+ Control c = new Control ();
+ Assert.IsTrue (c.Bounds.IsEmpty, "A1");
+ Assert.IsTrue (c.Size.IsEmpty, "A2");
+ Assert.IsTrue (c.ClientSize.IsEmpty, "A3");
+ Assert.IsTrue (c.ClientRectangle.IsEmpty, "A4");
+
+ Assert.AreEqual (((IWin32Window)c).Handle, c.Handle, "A5");
+
+ /* this part fails on linux because we can't allocate X windows which are 0x0,
+ and the Control bounds directly reflect the size of the X window */
+
+ Assert.IsTrue (c.Bounds.IsEmpty, "A6");
+ Assert.IsTrue (c.Size.IsEmpty, "A7");
+ Assert.IsTrue (c.ClientSize.IsEmpty, "A8");
+ Assert.IsTrue (c.ClientRectangle.IsEmpty, "A9");
+ }
+
+ [Test]
+ [Ignore ("Depends on specific DPI")]
+ public void FontHeightTest ()
+ {
+ MockControl c = new MockControl ();
+ Assert.AreEqual (13, c.font_height);
+ }
+
+ [Test]
+ public void FontTest ()
+ {
+ Control c = new Control ();
+ Assert.IsFalse (c.Font.Bold, "#A1");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.FontFamily.Name, "#A2");
+ Assert.IsFalse (c.Font.Italic, "#A3");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.Name, "#A4");
+ Assert.AreEqual (8.25, c.Font.Size, "#A5");
+ Assert.AreEqual (8.25, c.Font.SizeInPoints, "#A6");
+ Assert.IsFalse (c.Font.Strikeout, "#A7");
+ Assert.IsFalse (c.Font.Underline, "#A8");
+ Assert.AreEqual (GraphicsUnit.Point, c.Font.Unit, "#A9");
+#if NET_2_0
+ Assert.IsTrue (c.Font.IsSystemFont, "#A10");
+#endif
+
+ c.Font = new Font (c.Font.FontFamily, 3, FontStyle.Italic);
+ Assert.IsFalse (c.Font.Bold, "#B1");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.FontFamily.Name, "#B2");
+ Assert.IsTrue (c.Font.Italic, "#B3");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.Name, "#B4");
+ Assert.AreEqual (3, c.Font.Size, "#B5");
+ Assert.AreEqual (3, c.Font.SizeInPoints, "#B6");
+ Assert.IsFalse (c.Font.Strikeout, "#B7");
+ Assert.IsFalse (c.Font.Underline, "#B8");
+ Assert.AreEqual (GraphicsUnit.Point, c.Font.Unit, "#B9");
+#if NET_2_0
+ Assert.AreEqual (false, c.Font.IsSystemFont, "#B10");
+#endif
+ }
+
+ [Test]
+ [Category ("NotWorking")] // on Unix mapping is done to Bitstream Vera Sans
+ public void FontTest_Names ()
+ {
+ Control c = new Control ();
+ Assert.AreEqual ("Microsoft Sans Serif", c.Font.FontFamily.Name, "#1");
+ Assert.AreEqual ("Microsoft Sans Serif", c.Font.Name, "#2");
+ }
+
+ [Test]
+ public void PubPropTest()
+ {
+ Control c = new Control();
+
+ Assert.IsFalse (c.AllowDrop , "A1");
+ Assert.AreEqual(AnchorStyles.Top | AnchorStyles.Left, c.Anchor, "A2");
+
+ Assert.AreEqual ("Control", c.BackColor.Name , "B1");
+ Assert.IsNull (c.BackgroundImage, "B2");
+ Assert.IsNull (c.BindingContext, "B3");
+#if NET_2_0
+ Assert.AreEqual (ImageLayout.Tile, c.BackgroundImageLayout, "B4");
+#endif
+
+ Assert.IsFalse (c.CanFocus, "C1");
+ Assert.IsTrue (c.CanSelect, "C2");
+ Assert.IsFalse (c.Capture, "C3");
+ Assert.IsTrue (c.CausesValidation, "C4");
+
+ Assert.IsNotNull (c.CompanyName, "C7");
+ Assert.IsNull (c.Container, "C8");
+ Assert.IsFalse (c.ContainsFocus, "C9");
+ Assert.IsNull (c.ContextMenu, "C10");
+ Assert.AreEqual (0, c.Controls.Count, "C11");
+ Assert.IsFalse (c.Created, "C12");
+ Assert.AreEqual (Cursors.Default, c.Cursor, "C13");
+
+ Assert.IsNotNull(c.DataBindings, "D1");
+ Assert.AreEqual("Control", Control.DefaultBackColor.Name, "D2");
+ Assert.AreEqual("ControlText", Control.DefaultForeColor.Name, "D3");
+ Assert.AreEqual(FontStyle.Regular, Control.DefaultFont.Style, "D4");
+ Assert.AreEqual (new Rectangle(0, 0, 0, 0), c.DisplayRectangle , "D5");
+ Assert.IsFalse (c.Disposing, "D6");
+ Assert.AreEqual(DockStyle.None, c.Dock, "D7");
+
+ Assert.IsTrue (c.Enabled, "E1");
+
+ Assert.IsFalse (c.Focused, "F1");
+ Assert.AreEqual (FontStyle.Regular, c.Font.Style, "F2");
+ Assert.AreEqual (SystemColors.ControlText, c.ForeColor, "F3");
+
+ Assert.IsFalse (c.HasChildren, "H2");
+
+ Assert.AreEqual (ImeMode.NoControl, c.ImeMode, "I1");
+ Assert.IsFalse (c.InvokeRequired, "I2");
+ Assert.IsFalse (c.IsAccessible, "I3");
+ Assert.IsFalse (c.IsDisposed, "I4");
+ Assert.IsFalse (c.IsHandleCreated, "I5");
+
+ Assert.AreEqual(Point.Empty, c.Location, "L2");
+
+#if NET_2_0
+ Assert.IsTrue(c.MaximumSize.IsEmpty);
+ Assert.IsTrue(c.MinimumSize.IsEmpty);
+#endif
+ Assert.AreEqual (Keys.None, Control.ModifierKeys, "M1");
+ Assert.IsTrue (Control.MousePosition.X >= 0 && Control.MousePosition.Y >= 0, "M2");
+ Assert.AreEqual (MouseButtons.None, Control.MouseButtons, "M3");
Assert.AreEqual("", c.Name, "N1");
c.Name = "Control Name";
private void SizeChangedTest_ResizeHandler (object sender, EventArgs e)
{
- Console.WriteLine("Resized");
((Control) sender).Tag = false;
}
Assert.AreEqual (f, c.TopLevelControl, "T3");
Assert.AreEqual (f, f.TopLevelControl, "T4");
+
+ f.Dispose ();
}
[Test]
Assert.AreEqual(c1, c2.Parent, "Rel8");
}
+ [Test]
+ public void AnchorDockTest ()
+ {
+ Control c = new Control ();
+
+ Assert.AreEqual (DockStyle.None, c.Dock, "1");
+ Assert.AreEqual (AnchorStyles.Top | AnchorStyles.Left, c.Anchor, "2");
+
+ c.Dock = DockStyle.Top;
+ Assert.AreEqual (DockStyle.Top, c.Dock, "3");
+ Assert.AreEqual (AnchorStyles.Top | AnchorStyles.Left, c.Anchor, "4");
+
+ c.Anchor = AnchorStyles.Top;
+ Assert.AreEqual (DockStyle.None, c.Dock, "5");
+ Assert.AreEqual (AnchorStyles.Top, c.Anchor, "6");
+ }
+
[Test]
[Category ("NotWorking")]
- public void TabOrder() {
+ public void TabOrder()
+ {
Form form;
- Control active;
+ //Control active;
Label label1 = new Label(); // To test non-tabstop items as well
Label label2 = new Label();
Assert.AreEqual(40, r1.Height, "Scale2");
}
+#if NET_2_0
[Test]
- public void TextTest()
+ public void ScaleChildrenTest ()
{
- Control r1 = new Control();
- r1.Text = "Hi" ;
- Assert.AreEqual("Hi" , r1.Text , "Text1");
-
- r1.ResetText();
- Assert.AreEqual("" , r1.Text , "Text2");
+ ScaleChildrenControl c = new ScaleChildrenControl ();
+ Assert.AreEqual (true, c.PublicScaleChildren, "A1");
}
-
- [Test]
- public void PubMethodTest7()
+
+ private class ScaleChildrenControl : Control
{
- Control r1 = new Control();
- r1.RightToLeft = RightToLeft.Yes ;
- r1.ResetRightToLeft() ;
- Assert.AreEqual(RightToLeft.No , r1.RightToLeft , "#81");
- r1.ImeMode = ImeMode.Off ;
- r1.ResetImeMode () ;
- Assert.AreEqual(ImeMode.NoControl , r1.ImeMode , "#82");
- r1.ForeColor= SystemColors.GrayText ;
- r1.ResetForeColor() ;
- Assert.AreEqual(SystemColors.ControlText , r1.ForeColor , "#83");
- //r1.Font = Font.FromHdc();
- r1.ResetFont () ;
- //Assert.AreEqual(FontFamily.GenericSansSerif , r1.Font , "#83");
- r1.Cursor = Cursors.Hand ;
- r1.ResetCursor () ;
- Assert.AreEqual(Cursors.Default , r1.Cursor , "#83");
- //r1.DataBindings = System.Windows.Forms.Binding ;
- //r1.ResetBindings() ;
- //Assert.AreEqual(ControlBindingsCollection , r1.DataBindings , "#83");
- r1.BackColor = Color.Black ;
- r1.ResetBackColor() ;
- Assert.AreEqual( SystemColors.Control , r1.BackColor , "#84");
- r1.BackColor = Color.Black ;
- r1.Refresh() ;
- Assert.AreEqual( null , r1.Region , "#85");
- Rectangle M = new Rectangle(10, 20, 30 ,40);
- r1.RectangleToScreen(M) ;
- Assert.AreEqual( null , r1.Region , "#86");
-
+ public bool PublicScaleChildren {
+ get { return base.ScaleChildren; }
+ }
}
-
+
[Test]
- public void ScreenClientCoords()
+ public void ScaleControlTest ()
{
- Label l;
- Point p1;
- Point p2;
- Point p3;
+ ScaleControl c = new ScaleControl ();
+
+ c.Location = new Point (5, 10);
+ c.Size = new Size (15, 20);
+
+ Assert.AreEqual (new Rectangle (5, 10, 15, 20), c.Bounds, "A1");
- l = new Label();
- l.Left = 10;
- l.Top = 12;
- l.Visible = true;
- p1 = new Point (10,10);
+ c.PublicScaleControl (new SizeF (1.5f, 1.3f), BoundsSpecified.All);
+ Assert.AreEqual (new Rectangle (8, 13, 22, 26), c.Bounds, "A2");
+
+ c.PublicScaleControl (new SizeF (2f, 1.5f), BoundsSpecified.Location);
+ Assert.AreEqual (new Rectangle (16, 20, 22, 26), c.Bounds, "A3");
+
+ c.PublicScaleControl (new SizeF (1.5f, 2f), BoundsSpecified.Size);
+ Assert.AreEqual (new Rectangle (16, 20, 33, 52), c.Bounds, "A4");
+
+ c.PublicScaleControl (new SizeF (1.5f, 1.5f), BoundsSpecified.Width);
+ Assert.AreEqual (new Rectangle (16, 20, 50, 52), c.Bounds, "A5");
+
+ c.PublicScaleControl (new SizeF (1.5f, 1.3f), BoundsSpecified.None);
+ Assert.AreEqual (new Rectangle (16, 20, 50, 52), c.Bounds, "A6");
+
+ // Test with ScaleChildren
+ c = new ScaleControl ();
+
+ c.Location = new Point (5, 10);
+ c.Size = new Size (50, 50);
+
+ Control c2 = new Control ();
+ c2.Location = new Point (15, 15);
+ c2.Size = new Size (25, 25);
+ c.Controls.Add (c2);
+
+ Assert.AreEqual (new Rectangle (5, 10, 50, 50), c.Bounds, "B1");
+ Assert.AreEqual (new Rectangle (15, 15, 25, 25), c2.Bounds, "B2");
+
+ c.scale_children = false;
+
+ c.PublicScaleControl (new SizeF (2f, 2f), BoundsSpecified.All);
+ Assert.AreEqual (new Rectangle (10, 20, 100, 100), c.Bounds, "B3");
+ Assert.AreEqual (new Rectangle (15, 15, 25, 25), c2.Bounds, "B4");
+
+ c.scale_children = true;
+
+ // Will not scale children in ScaleControl
+ c.PublicScaleControl (new SizeF (2f, 2f), BoundsSpecified.All);
+ Assert.AreEqual (new Rectangle (20, 40, 200, 200), c.Bounds, "B5");
+ Assert.AreEqual (new Rectangle (15, 15, 25, 25), c2.Bounds, "B6");
+
+ // Does scale children in Scale
+ c.Scale (new SizeF (2f, 2f));
+ Assert.AreEqual (new Rectangle (40, 80, 400, 400), c.Bounds, "B7");
+ Assert.AreEqual (new Rectangle (30, 30, 50, 50), c2.Bounds, "B8");
+ }
+
+ [Test]
+ public void GetScaledBoundsTest ()
+ {
+ ScaleControl c = new ScaleControl ();
+
+ Rectangle r = new Rectangle (10, 20, 30, 40);
+
+ Assert.AreEqual (new Rectangle (20, 10, 60, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.All), "A1");
+ Assert.AreEqual (new Rectangle (20, 10, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Location), "A2");
+ Assert.AreEqual (new Rectangle (10, 20, 60, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Size), "A3");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Height), "A4");
+ Assert.AreEqual (new Rectangle (20, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.X), "A5");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.None), "A6");
+
+ c.PublicSetTopLevel (true);
+
+ Assert.AreEqual (new Rectangle (10, 20, 60, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.All), "A7");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Location), "A8");
+ Assert.AreEqual (new Rectangle (10, 20, 60, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Size), "A9");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 20), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Height), "A10");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.X), "A11");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.None), "A12");
+
+ c = new ScaleControl ();
+ c.PublicSetStyle (ControlStyles.FixedHeight, true);
+ c.PublicSetStyle (ControlStyles.FixedWidth, true);
+
+ Assert.AreEqual (new Rectangle (20, 10, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.All), "A13");
+ Assert.AreEqual (new Rectangle (20, 10, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Location), "A14");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Size), "A15");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.Height), "A16");
+ Assert.AreEqual (new Rectangle (20, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.X), "A17");
+ Assert.AreEqual (new Rectangle (10, 20, 30, 40), c.PublicGetScaledBounds (r, new SizeF (2f, .5f), BoundsSpecified.None), "A18");
+ }
+
+ private class ScaleControl : Control
+ {
+ public bool scale_children = true;
+
+ public void PublicScaleControl (SizeF factor, BoundsSpecified specified)
+ {
+ base.ScaleControl (factor, specified);
+ }
+
+ public Rectangle PublicGetScaledBounds (Rectangle bounds, SizeF factor, BoundsSpecified specified)
+ {
+ return base.GetScaledBounds (bounds, factor, specified);
+ }
+
+ public void PublicSetStyle (ControlStyles flag, bool value)
+ {
+ base.SetStyle (flag, value);
+ }
+
+ public void PublicSetTopLevel (bool value)
+ {
+ base.SetTopLevel (value);
+ }
+
+ protected override bool ScaleChildren {
+ get { return scale_children; }
+ }
+ }
+#endif
+
+ [Test] // Bug #347282
+ public void ScaleHierarchy ()
+ {
+ Form f = new Form ();
+ Panel p = new Panel ();
+ Button b = new Button ();
+
+ f.ClientSize = new Size (300, 300);
+
+ f.Controls.Add (p);
+ p.Controls.Add (b);
+
+ f.AutoScaleBaseSize = new Size (3, 11);
+ f.Show ();
+
+ // Due to font differences, all we can guarantee is that
+ // the button is larger that the default.
+ Assert.IsTrue (b.Width > 75, "A1");
+ Assert.IsTrue (b.Height > 23, "A2");
+
+ f.Dispose ();
+ }
+
+ class TestWindowTarget : IWindowTarget
+ {
+ public void OnHandleChange (IntPtr newHandle) {
+ }
+
+ public void OnMessage (ref Message m) {
+ }
+ }
+
+ [Test]
+ public void WindowTargetTest()
+ {
+ Control c = new Control ();
+ Assert.IsNotNull (c.WindowTarget, "WindowTarget1");
+ c.WindowTarget = null;
+ Assert.IsNull (c.WindowTarget, "WindowTarget2");
+
+ IWindowTarget existing_target = c.WindowTarget;
+ IWindowTarget new_target = new TestWindowTarget ();
+ c.WindowTarget = new_target;
+ Assert.AreSame (new_target, c.WindowTarget, "WindowTarget3");
+
+ TestHelper.RemoveWarning (existing_target);
+ }
+
+ [Test]
+ public void TextTest()
+ {
+ Control r1 = new Control();
+ r1.Text = "Hi" ;
+ Assert.AreEqual("Hi" , r1.Text , "Text1");
+
+ r1.ResetText();
+ Assert.AreEqual("" , r1.Text , "Text2");
+ }
+
+ [Test]
+ public void PubMethodTest7()
+ {
+ Control r1 = new Control();
+ r1.RightToLeft = RightToLeft.Yes ;
+ r1.ResetRightToLeft() ;
+ Assert.AreEqual(RightToLeft.No , r1.RightToLeft , "#81");
+ r1.ImeMode = ImeMode.Off ;
+ r1.ResetImeMode () ;
+ Assert.AreEqual(ImeMode.NoControl , r1.ImeMode , "#82");
+ r1.ForeColor= SystemColors.GrayText ;
+ r1.ResetForeColor() ;
+ Assert.AreEqual(SystemColors.ControlText , r1.ForeColor , "#83");
+ //r1.Font = Font.FromHdc();
+ r1.ResetFont () ;
+ //Assert.AreEqual(FontFamily.GenericSansSerif , r1.Font , "#83");
+ r1.Cursor = Cursors.Hand ;
+ r1.ResetCursor () ;
+ Assert.AreEqual(Cursors.Default , r1.Cursor , "#83");
+ //r1.DataBindings = System.Windows.Forms.Binding ;
+ //r1.ResetBindings() ;
+ //Assert.AreEqual(ControlBindingsCollection , r1.DataBindings , "#83");
+ r1.BackColor = Color.Black ;
+ r1.ResetBackColor() ;
+ Assert.AreEqual( SystemColors.Control , r1.BackColor , "#84");
+ r1.BackColor = Color.Black ;
+ r1.Refresh() ;
+ Assert.AreEqual( null , r1.Region , "#85");
+ Rectangle M = new Rectangle(10, 20, 30 ,40);
+ r1.RectangleToScreen(M) ;
+ Assert.AreEqual( null , r1.Region , "#86");
+ }
+
+ [Test]
+ public void ScreenClientCoords()
+ {
+ Label l;
+ Point p1;
+ Point p2;
+ Point p3;
+
+ l = new Label();
+ l.Left = 10;
+ l.Top = 12;
+ l.Visible = true;
+ p1 = new Point (10,10);
p2 = l.PointToScreen(p1);
p3 = l.PointToClient(p2);
}
[Test]
- public void CreateHandleTest ()
+ public void IsHandleCreated_NotVisible ()
{
- Control parent;
- Control child;
+ Control c = new Control ();
+ c.Visible = false;
+
+ Form form = new Form ();
+ form.ShowInTaskbar = false;
+ form.Controls.Add (c);
+ form.Show ();
+
+ Assert.IsFalse (c.IsHandleCreated, "#1");
+ c.Visible = true;
+ Assert.IsTrue (c.IsHandleCreated, "#2");
+ c.Visible = false;
+ Assert.IsTrue (c.IsHandleCreated, "#3");
+ form.Close ();
+ }
+
+ class OnCreateControlTest : Control {
+ public bool reached = false;
+ protected override void OnCreateControl () {
+ reached = true;
+ }
+ }
+
+ [Test]
+ public void CreateControlVisibleTest ()
+ {
+ OnCreateControlTest test = new OnCreateControlTest ();
+ test.Visible = false;
+ Assert.IsFalse (test.IsHandleCreated, "0");
+ Assert.IsFalse (test.Visible, "1");
+ test.Visible = true;
+ Assert.IsTrue (test.Visible, "2");
+ Assert.IsTrue (test.reached, "3");
+ }
+
+
+ [Test]
+ public void CreateGraphicsTest ()
+ {
+ Graphics g = null;
+ Pen p = null;
+
+ try {
+ Control c = new Control ();
+ c.SetBounds (0,0, 20, 20);
+ g = c.CreateGraphics ();
+ Assert.IsNotNull (g, "Graph1");
+ } finally {
+ if (p != null)
+ p.Dispose ();
+ if (g != null)
+ g.Dispose ();
+ }
+ }
+
+ bool delegateCalled = false;
+ public delegate void TestDelegate ();
+
+ public void delegate_call () {
+ delegateCalled = true;
+
+ TestHelper.RemoveWarning (delegateCalled);
+ }
+
+ [Test]
+ [ExpectedException(typeof(InvalidOperationException))]
+ public void InvokeException1 () {
+ Control c = new Control ();
+ IAsyncResult result;
+
+ result = c.BeginInvoke (new TestDelegate (delegate_call));
+ c.EndInvoke (result);
+ }
+
+ [Test]
+ public void FindFormTest () {
+ Form f = new Form ();
+
+ f.ShowInTaskbar = false;
+ f.Name = "form";
+ Control c = null;
+
+ try {
+ f.Controls.Add (c = new Control ());
+ Assert.AreEqual (f.Name, c.FindForm ().Name, "Find1");
+
+ f.Controls.Remove (c);
+
+ GroupBox g = new GroupBox ();
+ g.Name = "box";
+ f.Controls.Add (g);
+ g.Controls.Add (c);
+
+ Assert.AreEqual (f.Name, f.FindForm ().Name, "Find2");
+
+ g.Controls.Remove (c);
+ Assert.IsNull(c.FindForm (), "Find3");
+
+ } finally {
+ if (c != null)
+ c.Dispose ();
+ if (f != null)
+ f.Dispose ();
+ }
+ }
+
+ [Test]
+ public void FocusTest ()
+ {
+ Form f = null;
+ Button c = null, d = null;
+
+ try {
+ f = new Form ();
+ f.ShowInTaskbar = false;
+ f.Visible = true;
+ c = new Button ();
+ c.Visible = true;
+ f.Controls.Add (c);
+
+ d = new Button ();
+ d.Visible = false;
+ f.Controls.Add (d);
+
+ Assert.IsTrue (c.CanFocus, "Focus1");
+ Assert.IsFalse (c.Focused, "Focus2");
+ c.Focus ();
+ Assert.IsTrue (c.Focused, "Focus3");
+ d.Focus ();
+ Assert.IsFalse (d.Focused, "Focus4");
+
+ d.Visible = true;
+ d.Focus ();
+ Assert.IsTrue (d.Focused, "Focus5");
+ Assert.IsFalse (c.Focused, "Focus6");
+
+ c.Enabled = false;
+ Assert.IsFalse (c.Focused, "Focus7");
+ } finally {
+ if (f != null)
+ f.Dispose ();
+ if (c != null)
+ c.Dispose ();
+ if (d != null)
+ d.Dispose ();
+ }
+ }
- parent = null;
- child = null;
+ [Test]
+ public void FromHandleTest ()
+ {
+ Control c1 = null;
+ Control c2 = null;
try {
- parent = new Control ();
- child = new Control ();
+ c1 = new Control ();
+ c2 = new Control ();
+
+ c1.Name = "parent";
+ c2.Name = "child";
+ c1.Controls.Add(c2);
+
+ // Handle
+ Assert.AreEqual (c1.Name, Control.FromHandle (c1.Handle).Name, "Handle1");
+ Assert.IsNull (Control.FromHandle (IntPtr.Zero), "Handle2");
- parent.Visible = true;
- parent.Controls.Add (child);
+ // ChildHandle
+ Assert.AreEqual (c1.Name, Control.FromChildHandle (c1.Handle).Name, "Handle3");
+ Assert.IsNull (Control.FromChildHandle (IntPtr.Zero), "Handle4");
- Assert.IsFalse (parent.IsHandleCreated, "CH1");
- Assert.IsFalse (child.IsHandleCreated, "CH2");
- parent.CreateControl ();
- Assert.IsNotNull (parent.Handle, "CH3");
- Assert.IsNotNull (child.Handle, "CH4");
- Assert.IsTrue (parent.IsHandleCreated, "CH5");
- Assert.IsTrue (child.IsHandleCreated, "CH6");
} finally {
- if (parent != null)
- parent.Dispose ();
- if (child != null)
- child.Dispose ();
+ if (c1 != null)
+ c1.Dispose ();
+
+ if (c2 != null)
+ c2.Dispose ();
}
+ }
+
+ [Test]
+ public void GetChildAtPointTest ()
+ {
+ Control c = null, d = null;
+ TransparentControl e = null;
- // Accessing Handle Property creates the handle
try {
- parent = new Control ();
- parent.Visible = true;
- child = new Control ();
- parent.Controls.Add (child);
- Assert.IsFalse (parent.IsHandleCreated, "CH7");
- Assert.IsFalse (child.IsHandleCreated, "CH8");
- Assert.IsNotNull (parent.Handle, "CH9");
- Assert.IsTrue (parent.IsHandleCreated, "CH10");
- Assert.IsTrue (child.IsHandleCreated, "CH11");
+ c = new Control ();
+ c.Name = "c1";
+ c.SetBounds (0, 0, 100, 100);
+
+ d = new Control ();
+ d.Name = "d1";
+ d.SetBounds (10, 10, 40, 40);
+ c.Controls.Add (d);
+
+ e = new TransparentControl ();
+ e.Name = "e1";
+ e.SetBounds (55, 55, 10, 10);
+
+ Control l = c.GetChildAtPoint (new Point (15, 15));
+ Assert.AreEqual (d.Name, l.Name, "Child1");
+ Assert.IsFalse (e.Name == l.Name, "Child2");
+
+ l = c.GetChildAtPoint (new Point (57, 57));
+ Assert.AreEqual (null, l, "Child3");
+
+ l = c.GetChildAtPoint (new Point (10, 10));
+ Assert.AreEqual (d.Name, l.Name, "Child4");
+
+ // GetChildAtPointSkip is not implemented and the following test is breaking for Net_2_0 profile
+#if NET_2_0
+ c.Controls.Add (e);
+ e.Visible = false;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Invisible);
+ Assert.IsNull (l, "Child5");
+
+ e.Visible = true;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Invisible);
+ Assert.AreSame (e.Name, l.Name, "Child6");
+
+ e.Enabled = false;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Disabled);
+ Assert.IsNull (l, "Child7");
+
+ e.Enabled = true;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Disabled);
+ Assert.AreSame (e.Name, l.Name, "Child8");
+
+
+ e.BackColor = Color.Transparent;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Transparent);
+ Assert.IsNull (l, "Child9");
+
+ e.BackColor = Color.Green;
+ l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Transparent);
+ Assert.AreSame (e.Name, l.Name, "Child10");
+
+#endif // NET_2_0
} finally {
- if (parent != null)
- parent.Dispose ();
- if (child != null)
- child.Dispose ();
+ if (c != null)
+ c.Dispose ();
+ if (d != null)
+ d.Dispose ();
+ }
+ }
+
+ private class TransparentControl : Control
+ {
+ public TransparentControl ()
+ {
+ SetStyle (ControlStyles.SupportsTransparentBackColor, true);
+ }
+
+ protected override CreateParams CreateParams
+ {
+ get
+ {
+ CreateParams cp = base.CreateParams;
+ cp.ExStyle |= 0x00000020;
+ return cp;
+ }
+ }
+ }
+
+ [Test]
+ public void ResetFontTest ()
+ {
+ Control c = new Control ();
+ c.Font = new Font (c.Font.FontFamily, 3, FontStyle.Italic);
+ c.ResetFont ();
+
+ Assert.IsFalse (c.Font.Bold, "#1");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.FontFamily.Name, "#2");
+ Assert.IsFalse (c.Font.Italic, "#3");
+ //Assert.AreEqual ("Microsoft Sans Serif", c.Font.Name, "#4");
+ Assert.AreEqual (8.25, c.Font.Size, "#5");
+ Assert.AreEqual (8.25, c.Font.SizeInPoints, "#6");
+ Assert.IsFalse (c.Font.Strikeout, "#7");
+ Assert.IsFalse (c.Font.Underline, "#8");
+ Assert.AreEqual (GraphicsUnit.Point, c.Font.Unit, "#9");
+#if NET_2_0
+ Assert.AreEqual (true, c.Font.IsSystemFont, "#10");
+#endif
+ }
+
+ public class LayoutTestControl : Control {
+ public int LayoutCount;
+
+ public LayoutTestControl () : base() {
+ LayoutCount = 0;
+ }
+
+ protected override void OnLayout(LayoutEventArgs levent) {
+ LayoutCount++;
+ base.OnLayout (levent);
}
}
[Test]
- [Category ("NotWorking")]
- public void CreateHandleTest2 ()
+ public void LayoutTest() {
+ LayoutTestControl c;
+
+ c = new LayoutTestControl();
+
+ c.SuspendLayout();
+ c.SuspendLayout();
+ c.SuspendLayout();
+ c.SuspendLayout();
+
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.ResumeLayout(true);
+ c.PerformLayout();
+ c.SuspendLayout();
+ c.PerformLayout();
+
+ Assert.AreEqual(5, c.LayoutCount, "Layout Suspend/Resume locking does not bottom out at 0");
+ }
+
+ [Test]
+ [ExpectedException(typeof(ArgumentException))]
+ public void TransparentBackgroundTest1() {
+ Control c;
+
+ c = new Control();
+ c.BackColor = Color.Transparent;
+ }
+
+ [Test]
+ public void TransparentBackgroundTest2() {
+ Panel c;
+
+ c = new Panel();
+ c.BackColor = Color.Transparent;
+ Assert.AreEqual(Color.Transparent, c.BackColor, "Transparent background not set");
+ }
+
+ [Test]
+ public void TransparentBackgroundTest3() {
+ Control c;
+
+ c = new Control();
+ c.BackColor = Color.Empty;
+ Assert.AreEqual(Control.DefaultBackColor, c.BackColor, "Setting empty color failed");
+ }
+
+ [Test]
+ public void Dock_Value_Invalid ()
+ {
+ Control c = new Control ();
+ try {
+ c.Dock = (DockStyle) 666;
+ Assert.Fail ("#1");
+ } catch (InvalidEnumArgumentException ex) {
+ Assert.AreEqual (typeof (InvalidEnumArgumentException), ex.GetType (), "#2");
+ Assert.IsNotNull (ex.Message, "#3");
+ Assert.IsNotNull (ex.ParamName, "#4");
+ Assert.AreEqual ("value", ex.ParamName, "#5");
+ Assert.IsNull (ex.InnerException, "#6");
+ }
+ }
+
+ [Test]
+ public void EnabledTest1() {
+ Control child;
+ Control parent;
+ Control grandma;
+
+ grandma = new Control();
+ parent = new Control();
+ child = new Control();
+
+ grandma.Controls.Add(parent);
+ parent.Controls.Add(child);
+ grandma.Enabled = false;
+ Assert.AreEqual(grandma.Enabled, child.Enabled, "Child did not inherit disabled state");
+ }
+
+ int EnabledCalledCount = 0;
+ private void EnabledTest2EnabledChanged(object sender, EventArgs e) {
+ EnabledCalledCount++;
+ }
+
+ [Test]
+ public void EnabledTest2() {
+ // Check nesting of enabled calls
+ // OnEnabled is not called for disabled child controls
+ Control child;
+ Control parent;
+ Control grandma;
+
+ EnabledCalledCount = 0;
+
+ grandma = new Control();
+ parent = new Control();
+ child = new Control();
+ child.EnabledChanged += new EventHandler(EnabledTest2EnabledChanged);
+
+ grandma.Controls.Add(parent);
+ parent.Controls.Add(child);
+ grandma.Enabled = false;
+
+ Assert.AreEqual(1, EnabledCalledCount, "Child Enabled Event not properly fired");
+ grandma.Enabled = true;
+ Assert.AreEqual(2, EnabledCalledCount, "Child Enabled Event not properly fired");
+ child.Enabled = false;
+ grandma.Enabled = false;
+ Assert.AreEqual(3, EnabledCalledCount, "Child Enabled Event not properly fired");
+ }
+
+ [Test]
+ public void ControlsRemoveNullTest ()
+ {
+ Control c = new Control ();
+ c.Controls.Remove (null);
+ }
+
+ [Test]
+ public void ControlsAddNullTest ()
+ {
+ Control c = new Control ();
+ c.Controls.Add (null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void ControlsSetChildIndexNullTest ()
+ {
+ Control c = new Control ();
+ c.Controls.SetChildIndex (null, 1);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void ControlsAddRangeNullTest ()
{
- // This should eventually test all operations
- // that can be performed on a control (within
- // reason)
Control c = new Control ();
-
- Assert.IsFalse (c.IsHandleCreated, "0");
-
- c.Width = 100;
- Assert.IsFalse (c.IsHandleCreated, "1");
-
- c.Height = 100;
- Assert.IsFalse (c.IsHandleCreated, "2");
-
- c.Name = "hi";
- Assert.IsFalse (c.IsHandleCreated, "3");
-
- c.Left = 5;
- Assert.IsFalse (c.IsHandleCreated, "5");
-
- c.Top = 5;
- Assert.IsFalse (c.IsHandleCreated, "6");
-
- c.Location = new Point (1,1);
- Assert.IsFalse (c.IsHandleCreated, "7");
-
- c.Region = new Region ();
- Assert.IsFalse (c.IsHandleCreated, "8");
-
- c.Size = new Size (100, 100);
- Assert.IsFalse (c.IsHandleCreated, "9");
-
- c.Text = "bye";
- Assert.IsFalse (c.IsHandleCreated, "10");
-
- c.Visible = !c.Visible;
- Assert.IsFalse (c.IsHandleCreated, "11");
+ c.Controls.AddRange (null);
}
[Test]
- public void CreateGraphicsTest ()
+ public void ControlsAddRangeNullElementTest ()
{
- Graphics g = null;
- Pen p = null;
-
- try {
- Control c = new Control ();
- c.SetBounds (0,0, 20, 20);
- g = c.CreateGraphics ();
- Assert.IsNotNull (g, "Graph1");
- } finally {
- if (p != null)
- p.Dispose ();
- if (g != null)
- g.Dispose ();
- }
- }
-
- bool delegateCalled = false;
- public delegate void TestDelegate ();
+ Control c = new Control ();
+ Control[] subcontrols = new Control[2];
+ subcontrols[0] = new Control ();
+ subcontrols[1] = null;
- public void delegate_call () {
- delegateCalled = true;
+ c.Controls.AddRange (subcontrols);
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void InvokeException1 () {
+ public void RegionTest () {
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
Control c = new Control ();
- IAsyncResult result;
+ f.Controls.Add (c);
+ Assert.IsNull (c.Region, "#A1");
+ f.Show ();
+ Assert.IsNull (c.Region, "#A2");
+ c.Region = null;
+ Assert.IsNull (c.Region, "#A3");
+ f.Dispose ();
- result = c.BeginInvoke (new TestDelegate (delegate_call));
- c.EndInvoke (result);
+ Region region = new Region ();
+ f = new Form ();
+ f.ShowInTaskbar = false;
+ c = new Control ();
+ f.Controls.Add (c);
+ c.Region = region;
+ Assert.IsNotNull (c.Region, "#B1");
+ Assert.AreSame (region, c.Region, "#B2");
+ f.Show ();
+ c.Region = null;
+ Assert.IsNull (c.Region, "#B3");
+
+ f.Dispose ();
}
- [Test]
- public void FindFormTest () {
- Form f = new Form ();
+ [Test] // bug #330501
+ public void OnValidating_Parent_Close ()
+ {
+ MockControl control = new MockControl ();
+ Form f = new Form ();
+ f.Controls.Add (control);
f.ShowInTaskbar = false;
- f.Name = "form";
- Control c = null;
- try {
- f.Controls.Add (c = new Control ());
- Assert.AreEqual (f.Name, c.FindForm ().Name, "Find1");
+ f.Show ();
+ Assert.AreEqual (0, control.OnValidatingCount, "#A1");
+ f.Close ();
+ Assert.AreEqual (1, control.OnValidatingCount, "#A2");
+ f.Dispose ();
+ }
- f.Controls.Remove (c);
+ [Test] // bug #80280
+ public void Validated_Multiple_Containers ()
+ {
+ Form form = new Form ();
+ form.ShowInTaskbar = false;
- GroupBox g = new GroupBox ();
- g.Name = "box";
- f.Controls.Add (g);
- g.Controls.Add (c);
+ UserControl control1 = new UserControl();
+ UserControl container1 = new UserControl();
+ control1.Tag = true;
+ control1.Validated += new EventHandler (Control_ValidatedHandler);
+ container1.Controls.Add(control1);
+ form.Controls.Add (container1);
- Assert.AreEqual (f.Name, f.FindForm ().Name, "Find2");
+ UserControl container2 = new UserControl();
+ UserControl control2 = new UserControl();
+ container2.Controls.Add(control2);
+ form.Controls.Add (container2);
- g.Controls.Remove (c);
- Assert.IsNull(c.FindForm (), "Find3");
+ Assert.IsTrue ((bool) control1.Tag, "#1");
+ control1.Select();
+ Assert.IsTrue ((bool) control1.Tag, "#2");
+ control2.Select();
+ Assert.IsFalse ((bool) control1.Tag, "#3");
- } finally {
- if (c != null)
- c.Dispose ();
- if (f != null)
- f.Dispose ();
- }
+ form.Dispose ();
}
+ private void Control_ValidatedHandler (object sender, EventArgs e)
+ {
+ ((Control) sender).Tag = false;
+ }
+
[Test]
- public void FocusTest ()
+ public void ControlReparentLocationTest ()
{
- Form f = null;
- Button c = null, d = null;
+ Form form = new Form ();
+ Label l = new Label ();
+ l.Location = new Point (0, 0);
+ form.Controls.Add (l);
+ form.Show ();
+ Assert.AreEqual (0, l.Left, "#A1");
+ Assert.AreEqual (0, l.Top, "#A2");
+ form.Hide ();
+ form.Controls.Remove (l);
+ form.Show ();
+ form.Controls.Add (l);
+ Assert.AreEqual (0, l.Left, "#A3");
+ Assert.AreEqual (0, l.Top, "#A4");
+
+ form.Dispose ();
+ }
- try {
- f = new Form ();
- f.ShowInTaskbar = false;
- f.Visible = true;
- c = new Button ();
- c.Visible = true;
- f.Controls.Add (c);
+#if NET_2_0
+ [Test]
+ public void UseWaitCursorTest ()
+ {
+ Control c = new Control ();
+ Assert.IsFalse (c.UseWaitCursor, "#1");
+ c.Cursor = Cursors.Hand;
+ c.UseWaitCursor = true;
+ Assert.AreEqual (Cursors.WaitCursor, c.Cursor, "#2");
+ c.UseWaitCursor = false;
+ Assert.AreEqual (Cursors.Hand, c.Cursor, "#3");
+
+ c.UseWaitCursor = true;
+ c.Cursor = Cursors.Help;
+ Assert.AreEqual (Cursors.WaitCursor, c.Cursor, "#4");
+ Assert.AreEqual (true, c.UseWaitCursor, "#5");
+
+ c.UseWaitCursor = false;
+ Assert.AreEqual (Cursors.Help, c.Cursor, "#6");
+ }
- d = new Button ();
- d.Visible = false;
- f.Controls.Add (d);
+ [Test] // bug #80621, #81125
+ public void DontCallSizeFromClientSize ()
+ {
+ SizeControl sc = new SizeControl ();
+
+ Assert.AreEqual (0, sc.size_from_client_size_count, "A1");
+
+ sc.ClientSize = new Size (300, 300);
+ Assert.AreEqual (0, sc.size_from_client_size_count, "A2");
+
+ SizeForm sf = new SizeForm ();
+ sf.ShowInTaskbar = false;
+ sf.Show ();
+
+ Assert.AreEqual (0, sc.size_from_client_size_count, "A3");
- Assert.IsTrue (c.CanFocus, "Focus1");
- Assert.IsFalse (c.Focused, "Focus2");
- c.Focus ();
- Assert.IsTrue (c.Focused, "Focus3");
- d.Focus ();
- Assert.IsFalse (d.Focused, "Focus4");
+ sc.ClientSize = new Size (300, 300);
+ Assert.AreEqual (0, sc.size_from_client_size_count, "A4");
+
+ sf.Dispose ();
+ }
+
+ private class SizeControl : Control
+ {
+ public int size_from_client_size_count = 0;
+
+ protected override Size SizeFromClientSize (Size clientSize)
+ {
+ size_from_client_size_count++;
+ return base.SizeFromClientSize (clientSize);
+ }
+ }
- d.Visible = true;
- d.Focus ();
- Assert.IsTrue (d.Focused, "Focus5");
- Assert.IsFalse (c.Focused, "Focus6");
+ private class SizeForm : Form
+ {
+ public int size_from_client_size_count = 0;
- c.Enabled = false;
- Assert.IsFalse (c.Focused, "Focus7");
- } finally {
- if (f != null)
- f.Dispose ();
- if (c != null)
- c.Dispose ();
- if (d != null)
- d.Dispose ();
+ protected override Size SizeFromClientSize (Size clientSize)
+ {
+ size_from_client_size_count++;
+ return base.SizeFromClientSize (clientSize);
}
}
+#endif
- [Test]
- public void FromHandleTest ()
+ public class MockControl : Control
{
- Control c1 = null;
- Control c2 = null;
+ public int OnValidatingCount;
+ public int OnSizeChangedCount;
+ public int OnResizeCount;
+ public int OnLocationChangedCount;
- try {
- c1 = new Control ();
- c2 = new Control ();
+ public MockControl ()
+ {
+ }
- c1.Name = "parent";
- c2.Name = "child";
- c1.Controls.Add(c2);
+ public MockControl (string text)
+ : base (text)
+ {
+ }
- // Handle
- Assert.AreEqual (c1.Name, Control.FromHandle (c1.Handle).Name, "Handle1");
- Assert.IsNull (Control.FromHandle (IntPtr.Zero), "Handle2");
+ public MockControl (Control parent, string text)
+ : base (parent, text)
+ {
+ }
- // ChildHandle
- Assert.AreEqual (c1.Name, Control.FromChildHandle (c1.Handle).Name, "Handle3");
- Assert.IsNull (Control.FromChildHandle (IntPtr.Zero), "Handle4");
+ public MockControl (string text, int left, int top, int width, int height)
+ : base (text, left, top, width, height)
+ {
+ }
+ public MockControl (Control parent, string text, int left, int top, int width, int height)
+ : base (parent, text, left, top, width, height)
+ {
+ }
- } finally {
- if (c1 != null)
- c1.Dispose ();
+ public int font_height
+ {
+ get { return base.FontHeight; }
+ set { base.FontHeight = value; }
+ }
- if (c2 != null)
- c2.Dispose ();
+ protected override void OnLocationChanged (EventArgs e)
+ {
+ OnLocationChangedCount++;
+ base.OnLocationChanged (e);
+ }
+
+ protected override void OnSizeChanged (EventArgs e)
+ {
+ OnSizeChangedCount++;
+ base.OnSizeChanged (e);
+ }
+
+ protected override void OnResize (EventArgs e)
+ {
+ OnResizeCount++;
+ base.OnResize (e);
+ }
+
+ protected override void OnValidating (CancelEventArgs e)
+ {
+ OnValidatingCount++;
}
}
+ const int WM_KEYDOWN = 0x0100;
+ const int WM_CHAR = 0x0102;
+ const int WM_SYSCHAR = 0x0106;
+ const int WM_KEYUP = 0x0101;
+
+#if NET_2_0
[Test]
- public void GetChildAtPointTest ()
+ public void MethodPreProcessControlMessage ()
{
- Control c = null, d = null, e = null;
-
- try {
- c = new Control ();
- c.Name = "c1";
- c.SetBounds (0, 0, 100, 100);
+ bool testing_callstack = false;
+
+ MyControl c = new MyControl ();
+ Message m = new Message ();
+ m.HWnd = c.Handle;
+ m.Msg = WM_KEYDOWN;
+ m.WParam = (IntPtr)Keys.Down;
+ m.LParam = IntPtr.Zero;
+
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A1");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.OnPreviewKeyDown);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNeeded, c.PreProcessControlMessage (ref m), "A2");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessCmdKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageProcessed, c.PreProcessControlMessage (ref m), "A3");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNeeded, c.PreProcessControlMessage (ref m), "A4");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageProcessed, c.PreProcessControlMessage (ref m), "A5");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_CHAR;
+ c.SetState (State.None);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A6");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNeeded, c.PreProcessControlMessage (ref m), "A7");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageProcessed, c.PreProcessControlMessage (ref m), "A8");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_SYSCHAR;
+ c.SetState (State.None);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A9");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNeeded, c.PreProcessControlMessage (ref m), "A10");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageProcessed, c.PreProcessControlMessage (ref m), "A11");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_KEYUP;
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A12");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.OnPreviewKeyDown);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A13");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessCmdKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A14");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A15");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (PreProcessControlState.MessageNotNeeded, c.PreProcessControlMessage (ref m), "A16");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+ }
+#endif
- d = new Control ();
- d.Name = "d1";
- d.SetBounds (10, 10, 40, 40);
- c.Controls.Add (d);
+ [Test]
+ public void MethodPreProcessMessage ()
+ {
+ bool testing_callstack = false;
+
+ MyControl c = new MyControl ();
+ Message m = new Message ();
+ m.HWnd = c.Handle;
+ m.Msg = WM_KEYDOWN;
+ m.WParam = (IntPtr)Keys.Down;
+ m.LParam = IntPtr.Zero;
+
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A1");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.OnPreviewKeyDown);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A2");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessCmdKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (true, c.PreProcessMessage (ref m), "A3");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A4");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (true, c.PreProcessMessage (ref m), "A5");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_CHAR;
+ c.SetState (State.None);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A6");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A7");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (true, c.PreProcessMessage (ref m), "A8");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_SYSCHAR;
+ c.SetState (State.None);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A9");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A10");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogChar);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (true, c.PreProcessMessage (ref m), "A11");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+
+ m.Msg = WM_KEYUP;
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A12");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.OnPreviewKeyDown);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A13");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessCmdKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A14");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.IsInputKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A15");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+
+ c.SetState (State.ProcessDialogKey);
+ if (testing_callstack) Console.WriteLine ("Start");
+ Assert.AreEqual (false, c.PreProcessMessage (ref m), "A16");
+ if (testing_callstack) Console.WriteLine ("End {0}\n", m.WParam.ToString ());
+ }
+ private enum State
+ {
+ None,
+ ProcessCmdKey,
+ OnPreviewKeyDown,
+ IsInputChar,
+ IsInputKey,
+ PreProcessMessage,
+ ProcessDialogKey,
+ ProcessDialogChar
+ }
- e = new Control ();
- e.Name = "e1";
- e.SetBounds (55, 55, 10, 10);
+ private class MyControl : Control
+ {
- Control l = c.GetChildAtPoint (new Point (15, 15));
- Assert.AreEqual (d.Name, l.Name, "Child1");
- Assert.IsFalse (e.Name == l.Name, "Child2");
+ private State current_state;
+ bool testing_callstack = false;
- l = c.GetChildAtPoint (new Point (57, 57));
- Assert.IsNull (l, "Child3");
+ public void SetState (State state)
+ {
+ current_state = state;
+ }
- l = c.GetChildAtPoint (new Point (10, 10));
- Assert.AreEqual (d.Name, l.Name, "Child4");
+ protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
+ {
+ if (testing_callstack) Console.Write ("ProcessCmdKey[");
+ if (current_state == State.ProcessCmdKey) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
- // GetChildAtPointSkip is not implemented and the following test is breaking for Net_2_0 profile
-// #if NET_2_0
-// c.Controls.Add (e);
-// e.Visible = false;
-// l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Invisible);
-// Assert.IsNull (l, "Child5");
-
-// e.Visible = true;
-// l = c.GetChildAtPoint (new Point (57, 57), GetChildAtPointSkip.Invisible);
-// Assert.AreSame (e.Name, l.Name, "Child6");
-// #endif // NET_2_0
- } finally {
- if (c != null)
- c.Dispose ();
- if (d != null)
- d.Dispose ();
+ bool retval = base.ProcessCmdKey (ref msg, keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
}
- }
-
- public class LayoutTestControl : Control {
- public int LayoutCount;
+#if NET_2_0
+ protected override void OnPreviewKeyDown (PreviewKeyDownEventArgs e)
+ {
+ if (testing_callstack) Console.Write ("OnPreviewKeyDown[");
+ if (current_state == State.OnPreviewKeyDown) {
+ e.IsInputKey = true;
+ if (testing_callstack) Console.WriteLine ("]");
+ return;
+ }
- public LayoutTestControl () : base() {
- LayoutCount = 0;
+ base.OnPreviewKeyDown (e);
+ if (testing_callstack) Console.WriteLine ("]");
}
+#endif
- protected override void OnLayout(LayoutEventArgs levent) {
- LayoutCount++;
- base.OnLayout (levent);
+ protected override bool IsInputChar (char charCode)
+ {
+ if (testing_callstack) Console.Write ("IsInputChar[");
+ if (current_state == State.IsInputChar) {
+ if (testing_callstack) Console.WriteLine ("true]");
+ return true;
+ }
+
+ bool retval = base.IsInputChar (charCode);
+ if (testing_callstack) Console.WriteLine ("{0}]", retval.ToString ());
+ return retval;
}
- }
- [Test]
- public void LayoutTest() {
- LayoutTestControl c;
+ protected override bool IsInputKey (Keys keyData)
+ {
+ if (testing_callstack) Console.Write ("IsInputKey[");
+ if (current_state == State.IsInputKey) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
- c = new LayoutTestControl();
+ bool retval = base.IsInputKey (keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
- c.SuspendLayout();
- c.SuspendLayout();
- c.SuspendLayout();
- c.SuspendLayout();
+ public override bool PreProcessMessage (ref Message msg)
+ {
+ if (testing_callstack) Console.Write ("PreProcessMessage[");
+ if (current_state == State.PreProcessMessage) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.ResumeLayout(true);
- c.PerformLayout();
- c.SuspendLayout();
- c.PerformLayout();
+ bool retval = base.PreProcessMessage (ref msg);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
- Assert.AreEqual(5, c.LayoutCount, "Layout Suspend/Resume locking does not bottom out at 0");
- }
+ protected override bool ProcessDialogKey (Keys keyData)
+ {
+ if (testing_callstack) Console.Write ("ProcessDialogKey[");
+ if (current_state == State.ProcessDialogKey) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
- [Test]
- [ExpectedException(typeof(ArgumentException))]
- public void TransparentBackgroundTest1() {
- Control c;
+ bool retval = base.ProcessDialogKey (keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
- c = new Control();
- c.BackColor = Color.Transparent;
- }
+ protected override bool ProcessDialogChar (char charCode)
+ {
+ if (testing_callstack) Console.Write ("ProcessDialogChar[");
+ if (current_state == State.ProcessDialogChar) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
+ bool retval = base.ProcessDialogChar (charCode);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
+ }
+
[Test]
- public void TransparentBackgroundTest2() {
- Panel c;
-
- c = new Panel();
- c.BackColor = Color.Transparent;
- Assert.AreEqual(Color.Transparent, c.BackColor, "Transparent background not set");
+ public void MethodIsInputChar ()
+ {
+ // Basically, show that this method always returns false
+ InputCharControl m = new InputCharControl ();
+ bool result = false;
+
+ for (int i = 0; i < 256; i++)
+ result |= m.PublicIsInputChar ((char)i);
+
+ Assert.AreEqual (false, result, "I1");
}
- [Test]
- public void TransparentBackgroundTest3() {
- Control c;
+ private class InputCharControl : Control
+ {
+ public bool PublicIsInputChar (char charCode)
+ {
+ return base.IsInputChar (charCode);
+ }
- c = new Control();
- c.BackColor = Color.Empty;
- Assert.AreEqual(Control.DefaultBackColor, c.BackColor, "Setting empty color failed");
}
- [Test]
- public void Dock_Value_Invalid ()
+ [Test] // bug #81118, 81718
+ public void VisibleTriggersLayout ()
{
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+
Control c = new Control ();
- try {
- c.Dock = (DockStyle) 666;
- Assert.Fail ("#1");
- } catch (InvalidEnumArgumentException ex) {
- Assert.AreEqual (typeof (InvalidEnumArgumentException), ex.GetType (), "#2");
- Assert.IsNotNull (ex.Message, "#3");
- Assert.IsNotNull (ex.ParamName, "#4");
- Assert.AreEqual ("value", ex.ParamName, "#5");
- Assert.IsNull (ex.InnerException, "#6");
- }
+ c.Visible = false;
+
+ f.Controls.Add (c);
+
+ c.Dock = DockStyle.Fill;
+ c.Visible = true;
+
+ Assert.AreEqual (f.ClientSize.Width, c.Width, "L1");
+
+ f.Dispose ();
}
-
+
[Test]
- public void EnabledTest1() {
- Control child;
- Control parent;
- Control grandma;
+ public void ResumeLayoutEffects ()
+ {
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+ f.ClientSize = new Size (300, 300);
+
+ Button button1 = new Button ();
+ f.Controls.Add (button1);
+ button1.Anchor = AnchorStyles.Right | AnchorStyles.Bottom;
+ button1.Location = new Point (f.ClientSize.Width - button1.Width, f.ClientSize.Height - button1.Height);
- grandma = new Control();
- parent = new Control();
- child = new Control();
+ f.Show ();
+
+ Assert.AreEqual (new Point (225, 277), button1.Location, "A1");
+
+ f.SuspendLayout ();
+ f.Height += 10;
+ f.ResumeLayout (false);
+ f.PerformLayout ();
- grandma.Controls.Add(parent);
- parent.Controls.Add(child);
- grandma.Enabled = false;
- Assert.AreEqual(grandma.Enabled, child.Enabled, "Child did not inherit disabled state");
+ Assert.AreEqual (new Point (225, 277), button1.Location, "A2");
+
+ f.SuspendLayout ();
+ f.Height += 10;
+ f.ResumeLayout ();
+
+ Assert.AreEqual (new Point (225, 287), button1.Location, "A3");
+ f.Dispose ();
}
+
+ [Test]
+ public void DisposeEnumerator ()
+ {
+ // We can modify the collection while looping through it without crashing
+ Control c = new Control ();
- int EnabledCalledCount = 0;
- private void EnabledTest2EnabledChanged(object sender, EventArgs e) {
- EnabledCalledCount++;
+ c.Controls.Add (new Control ());
+ c.Controls.Add (new Control ());
+
+ foreach (Control c1 in c.Controls)
+ c.Controls.Remove (c1);
}
+
+ [Test]
+ public void MethodSetBounds ()
+ {
+ Control myControl = new Control();
+ myControl.SetBounds(10, 20, 30, 40);
+ myControl.SetBounds(50, 60, 70, 70, BoundsSpecified.Location);
+ Assert.AreEqual (new Rectangle (50, 60, 30, 40), myControl.Bounds, "A1");
+ }
+
[Test]
- public void EnabledTest2() {
- // Check nesting of enabled calls
- // OnEnabled is not called for disabled child controls
- Control child;
- Control parent;
- Control grandma;
+ public void Bug386450 ()
+ {
+ // Should not crash. We have to check for the font object
+ // being different, not just if they represent the same font.
+ Form f = new Form ();
+ Label l = new Label ();
+ l.Text = "Hello";
- EnabledCalledCount = 0;
+ Font f1 = new Font ("Arial", 12);
+ Font f2 = new Font ("Arial", 12);
- grandma = new Control();
- parent = new Control();
- child = new Control();
- child.EnabledChanged += new EventHandler(EnabledTest2EnabledChanged);
+ l.Font = f1;
+ l.Font = f2;
- grandma.Controls.Add(parent);
- parent.Controls.Add(child);
- grandma.Enabled = false;
+ f1.Dispose ();
- Assert.AreEqual(1, EnabledCalledCount, "Child Enabled Event not properly fired");
- grandma.Enabled = true;
- Assert.AreEqual(2, EnabledCalledCount, "Child Enabled Event not properly fired");
- child.Enabled = false;
- grandma.Enabled = false;
- Assert.AreEqual(3, EnabledCalledCount, "Child Enabled Event not properly fired");
+ f.Controls.Add (l);
+ f.Show ();
+ f.Dispose ();
+ }
+ }
+
+ [TestFixture]
+ public class ControlSetTopLevelTest : TestHelper
+ {
+ class ControlPoker : Control {
+ public void DoSetTopLevel ()
+ {
+ SetTopLevel (true);
+ }
+ public bool DoGetTopLevel ()
+ {
+ return GetTopLevel ();
+ }
}
[Test]
- public void ControlsRemoveNullTest ()
+ public void TestControl ()
{
- Control c = new Control ();
- c.Controls.Remove (null);
+ ControlPoker c = new ControlPoker ();
+ c.Visible = false;
+ c.DoSetTopLevel ();
+ Assert.IsTrue (c.DoGetTopLevel (), "1");
+ Assert.IsFalse (c.Visible, "2");
}
[Test]
- public void ControlsAddNullTest ()
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestChildControl ()
{
- Control c = new Control ();
- c.Controls.Add (null);
+ Control c1 = new Control();
+ ControlPoker c2 = new ControlPoker ();
+
+ c1.Controls.Add (c2);
+ c2.DoSetTopLevel ();
}
[Test]
- [ExpectedException (typeof (ArgumentNullException))]
- public void ControlsSetChildIndexNullTest ()
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestTopLevelAdd () {
+ Form f = new Form();
+ Form f1 = new Form();
+ f.Controls.Add(f1);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void TestForm ()
{
- Control c = new Control ();
- c.Controls.SetChildIndex (null, 1);
+ Form f = new Form ();
+ Assert.IsFalse (f.Visible, "3");
+ f.TopLevel = true;
+ Assert.IsFalse (f.Visible, "4");
+
+ f.Dispose ();
}
+ }
- [Test]
- [ExpectedException (typeof (ArgumentNullException))]
- public void ControlsAddRangeNullTest ()
+ [TestFixture]
+ public class ControlResizeLayoutTest : TestHelper
+ {
+ class ControlPoker : Control {
+ public void DoOnResize ()
+ {
+ OnResize (EventArgs.Empty);
+ }
+ }
+
+ int child_event;
+ string child_affected_property;
+ void ChildLayoutEvent (object sender, LayoutEventArgs e)
{
- Control c = new Control ();
- c.Controls.AddRange (null);
+ child_event ++;
+ child_affected_property = e.AffectedProperty;
}
- [Test]
- public void ControlsAddRangeNullElementTest ()
+ int parent_event;
+ string parent_affected_property;
+ void ParentLayoutEvent (object sender, LayoutEventArgs e)
{
- Control c = new Control ();
- Control[] subcontrols = new Control[2];
- subcontrols[0] = new Control ();
- subcontrols[1] = null;
+ parent_event ++;
+ parent_affected_property = e.AffectedProperty;
- c.Controls.AddRange (subcontrols);
+ TestHelper.RemoveWarning (parent_affected_property);
}
[Test]
- public void RegionTest () {
- Form f = new Form();
- Control c = new Control();
- f.Controls.Add(c);
- f.Show();
+ public void Test ()
+ {
+ Panel p = new Panel ();
+ ControlPoker c = new ControlPoker();
- try {
- c.Region = null;
- }
- catch(Exception ex) {
- Assert.IsNotNull(c.Region, "A1");
- }
-
- f.Close();
+ p.Controls.Add (c);
+
+ p.Layout += new LayoutEventHandler (ParentLayoutEvent);
+ c.Layout += new LayoutEventHandler (ChildLayoutEvent);
+
+ c.DoOnResize ();
+
+ Assert.AreEqual (1, child_event, "1");
+ Assert.AreEqual ("Bounds", child_affected_property, "2");
+
+ Assert.AreEqual (0, parent_event, "3");
}
+
}
[TestFixture]
- public class ControlInvokeTest {
+ [Category ("NotWorking")]
+ public class ControlInvokeTest : TestHelper {
+
+ [TearDown]
+ protected override void TearDown ()
+ {
+ if (f != null && !f.IsDisposed)
+ f.Dispose ();
+ base.TearDown ();
+ }
+
+
public delegate void TestDelegate ();
Form f;
Thread control_t;
ApplicationContext control_context;
bool delegateCalled = false;
+ bool threadDied = false;
object m;
void CreateControl ()
{
+ try {
f = new Form ();
f.ShowInTaskbar = false;
Console.WriteLine ("control thread running");
Application.Run (control_context);
c.Dispose ();
+ Console.WriteLine ("dying");
+ threadDied = true;
+ Monitor.Enter (m);
+ Console.WriteLine ("pulsing again");
+ Monitor.Pulse (m);
+ Monitor.Exit (m);
+ } catch (Exception e) { Console.WriteLine (e); }
}
[Test]
result = c.BeginInvoke (new TestDelegate (delegate_call));
c.EndInvoke (result);
- Assert.AreEqual (true, delegateCalled, "Invoke1");
+ Assert.IsTrue (delegateCalled, "Invoke1");
+
+ Monitor.Wait (m);
+ Assert.IsTrue (threadDied, "Invoke2");
}
public void delegate_call () {
+ try {
/* invoked on control_context's thread */
delegateCalled = true;
f.Dispose ();
- Application.Exit ();
+ Console.WriteLine ("calling Application.Exit");
+ control_context.ExitThread ();
+ } catch (Exception e) { Console.WriteLine (e); }
}
}
[TestFixture]
- public class ControlWMTest
+ public class ControlWMTest : TestHelper
{
[Test]
public void WM_PARENTNOTIFY_Test ()
}
}
}
+
+#if NET_2_0
+ [TestFixture]
+ public class ControlLayoutTest : TestHelper
+ {
+ [SetUp]
+ protected override void SetUp ()
+ {
+ _layoutCount = 0;
+ base.SetUp ();
+ }
+
+ [Test] // bug #80456
+ public void LayoutTest ()
+ {
+ MockLayoutEngine layoutEngine = new MockLayoutEngine ();
+ MockControl c = new MockControl (layoutEngine);
+ c.Layout += new LayoutEventHandler (LayoutEvent);
+ Assert.IsFalse (layoutEngine.LayoutInvoked, "#A1");
+ Assert.AreEqual (0, _layoutCount, "#A2");
+ c.PerformLayout ();
+ Assert.IsTrue (layoutEngine.LayoutInvoked, "#A3");
+ Assert.AreEqual (1, _layoutCount, "#A4");
+
+ layoutEngine.Reset ();
+ c.OverrideOnLayout = true;
+ Assert.IsFalse (layoutEngine.LayoutInvoked, "#B1");
+ c.PerformLayout ();
+ Assert.IsFalse (layoutEngine.LayoutInvoked, "#B2");
+ Assert.AreEqual (1, _layoutCount, "#B3");
+ }
+
+ void LayoutEvent (object sender, LayoutEventArgs e)
+ {
+ _layoutCount++;
+ }
+
+ private int _layoutCount;
+
+ class MockControl : Control
+ {
+ public MockControl (LayoutEngine layoutEngine)
+ {
+ _layoutEngine = layoutEngine;
+ }
+
+ public bool OverrideOnLayout
+ {
+ get { return _overrideOnLayout; }
+ set { _overrideOnLayout = value; }
+ }
+
+ protected override void OnLayout (LayoutEventArgs levent)
+ {
+ if (!OverrideOnLayout)
+ base.OnLayout (levent);
+ }
+
+ public override LayoutEngine LayoutEngine {
+ get {
+ if (_layoutEngine == null)
+ return base.LayoutEngine;
+ return _layoutEngine;
+ }
+ }
+
+ private bool _overrideOnLayout;
+ private LayoutEngine _layoutEngine;
+ }
+
+ class MockLayoutEngine : LayoutEngine
+ {
+ public bool LayoutInvoked {
+ get { return _layoutInvoked; }
+ }
+
+ public void Reset ()
+ {
+ _layoutInvoked = false;
+ }
+
+ public override bool Layout (object container, LayoutEventArgs args)
+ {
+ _layoutInvoked = true;
+ return true;
+ }
+
+ private bool _layoutInvoked;
+ }
+ }
+#endif
}
projects / mono.git / blobdiff