//
// 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
{
+ [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");
+ }
+
+ [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");
+ }
+
+ [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");
+ }
+
+ [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");
+ }
+
+ [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 AutoSizeTest ()
+ {
+ 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]
+ public void Bug82748 ()
+ {
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+
+ Control c = new Control ();
+ 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;
+
+ public ControlStylesTester (WindowStyles Style, WindowStyles ExStyle, bool OrStyles)
+ {
+ style = Style;
+ ex_style = ExStyle;
+ or_styles = OrStyles;
+ }
+
+ 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");
+ }
+
+#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;
Application.DoEvents ();
}
}
+
+ [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 OnPaintTest ()
{
using (OnPaintTester t = new OnPaintTester ()) {
}
#if NET_2_0
[Test]
+ [Category ("Interactive")]
public void OnPaintDoubleBufferedTest ()
{
using (OnPaintTester t = new OnPaintTester ()) {
overrides.Add("OnPaint");
}
}
-
+
[Test]
+ [Ignore ("Can't find a reliable way to generate a paint message on Windows.")]
public void EventStyleTest ()
{
#if NET_2_0
}
[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]
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 ()
{
Assert.IsTrue(c.MinimumSize.IsEmpty);
#endif
Assert.AreEqual (Keys.None, Control.ModifierKeys, "M1");
- Assert.IsFalse (Control.MousePosition.IsEmpty, "M2");
+ Assert.IsTrue (Control.MousePosition.X >= 0 && Control.MousePosition.Y >= 0, "M2");
Assert.AreEqual (MouseButtons.None, Control.MouseButtons, "M3");
Assert.AreEqual("", c.Name, "N1");
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 ScaleChildrenTest ()
+ {
+ ScaleChildrenControl c = new ScaleChildrenControl ();
+ Assert.AreEqual (true, c.PublicScaleChildren, "A1");
+ }
+
+ private class ScaleChildrenControl : Control
+ {
+ public bool PublicScaleChildren {
+ get { return base.ScaleChildren; }
+ }
+ }
+
+ [Test]
+ public void ScaleControlTest ()
+ {
+ 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");
+
+ 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()
{
}
[Test]
- public void CreateHandleTest ()
+ public void IsHandleCreated_NotVisible ()
{
- Control parent;
- Control child;
-
- parent = null;
- child = null;
-
- try {
- parent = new Control ();
- child = new Control ();
+ Control c = new Control ();
+ c.Visible = false;
- parent.Visible = true;
- parent.Controls.Add (child);
+ Form form = new Form ();
+ form.ShowInTaskbar = false;
+ form.Controls.Add (c);
+ form.Show ();
- Assert.IsFalse (parent.IsHandleCreated, "CH1");
- Assert.IsFalse (child.IsHandleCreated, "CH2");
+ Assert.IsFalse (c.IsHandleCreated, "#1");
+ c.Visible = true;
+ Assert.IsTrue (c.IsHandleCreated, "#2");
+ c.Visible = false;
+ Assert.IsTrue (c.IsHandleCreated, "#3");
+ form.Close ();
+ }
- 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 ();
+ class OnCreateControlTest : Control {
+ public bool reached = false;
+ protected override void OnCreateControl () {
+ reached = true;
}
-
- // 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");
- } finally {
- if (parent != null)
- parent.Dispose ();
- if (child != null)
- child.Dispose ();
- }
- }
+ }
[Test]
- [Category ("NotWorking")]
- public void CreateHandleTest2 ()
+ public void CreateControlVisibleTest ()
{
- // 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");
+ 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]
- [Category ("NotWorking")]
- public void IsHandleCreated_NotVisible ()
- {
- 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");
- }
[Test]
public void CreateGraphicsTest ()
public void delegate_call () {
delegateCalled = true;
+
+ TestHelper.RemoveWarning (delegateCalled);
}
[Test]
[Test]
public void GetChildAtPointTest ()
{
- Control c = null, d = null, e = null;
+ Control c = null, d = null;
+ TransparentControl e = null;
try {
c = new Control ();
d.SetBounds (10, 10, 40, 40);
c.Controls.Add (d);
- e = new Control ();
+ e = new TransparentControl ();
e.Name = "e1";
e.SetBounds (55, 55, 10, 10);
Assert.IsFalse (e.Name == l.Name, "Child2");
l = c.GetChildAtPoint (new Point (57, 57));
- Assert.IsNull (l, "Child3");
+ 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");
-// #endif // NET_2_0
+#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 (c != null)
c.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 ()
{
f.Dispose ();
}
+ [Test] // bug #330501
+ public void OnValidating_Parent_Close ()
+ {
+ MockControl control = new MockControl ();
+
+ Form f = new Form ();
+ f.Controls.Add (control);
+ f.ShowInTaskbar = false;
+
+ f.Show ();
+ Assert.AreEqual (0, control.OnValidatingCount, "#A1");
+ f.Close ();
+ Assert.AreEqual (1, control.OnValidatingCount, "#A2");
+ f.Dispose ();
+ }
+
[Test] // bug #80280
public void Validated_Multiple_Containers ()
{
{
((Control) sender).Tag = false;
}
+
+ [Test]
+ public void ControlReparentLocationTest ()
+ {
+ 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 ();
+ }
+
+#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");
+ }
+
+ [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");
+
+ 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);
+ }
+ }
+
+ private class SizeForm : Form
+ {
+ public int size_from_client_size_count = 0;
+
+ protected override Size SizeFromClientSize (Size clientSize)
+ {
+ size_from_client_size_count++;
+ return base.SizeFromClientSize (clientSize);
+ }
+ }
+#endif
+
+ public class MockControl : Control
+ {
+ public int OnValidatingCount;
+ public int OnSizeChangedCount;
+ public int OnResizeCount;
+ public int OnLocationChangedCount;
+
+ public MockControl ()
+ {
+ }
+
+ public MockControl (string text)
+ : base (text)
+ {
+ }
+
+ public MockControl (Control parent, string text)
+ : base (parent, text)
+ {
+ }
+
+ 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)
+ {
+ }
+
+ public int font_height
+ {
+ get { return base.FontHeight; }
+ set { base.FontHeight = value; }
+ }
+
+ 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 MethodPreProcessControlMessage ()
+ {
+ 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
+
+ [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
+ }
+
+ private class MyControl : Control
+ {
+
+ private State current_state;
+ bool testing_callstack = false;
+
+ public void SetState (State state)
+ {
+ current_state = state;
+ }
+
+ 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;
+ }
+
+ bool retval = base.ProcessCmdKey (ref msg, keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
+
+#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;
+ }
+
+ base.OnPreviewKeyDown (e);
+ if (testing_callstack) Console.WriteLine ("]");
+ }
+#endif
+
+ 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;
+ }
+
+ protected override bool IsInputKey (Keys keyData)
+ {
+ if (testing_callstack) Console.Write ("IsInputKey[");
+ if (current_state == State.IsInputKey) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
+
+ bool retval = base.IsInputKey (keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
+
+ 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;
+ }
+
+ bool retval = base.PreProcessMessage (ref msg);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
+
+ protected override bool ProcessDialogKey (Keys keyData)
+ {
+ if (testing_callstack) Console.Write ("ProcessDialogKey[");
+ if (current_state == State.ProcessDialogKey) {
+ if (testing_callstack) Console.WriteLine ("]");
+ return true;
+ }
+
+ bool retval = base.ProcessDialogKey (keyData);
+ if (testing_callstack) Console.WriteLine ("]");
+ return retval;
+ }
+
+ 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 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");
+ }
+
+ private class InputCharControl : Control
+ {
+ public bool PublicIsInputChar (char charCode)
+ {
+ return base.IsInputChar (charCode);
+ }
+
+ }
+
+ [Test] // bug #81118, 81718
+ public void VisibleTriggersLayout ()
+ {
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+
+ Control c = new Control ();
+ 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 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);
+
+ f.Show ();
+
+ Assert.AreEqual (new Point (225, 277), button1.Location, "A1");
+
+ f.SuspendLayout ();
+ f.Height += 10;
+ f.ResumeLayout (false);
+ f.PerformLayout ();
+
+ 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 ();
+
+ 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 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";
+
+ Font f1 = new Font ("Arial", 12);
+ Font f2 = new Font ("Arial", 12);
+
+ l.Font = f1;
+ l.Font = f2;
+
+ f1.Dispose ();
+
+ f.Controls.Add (l);
+ f.Show ();
+ f.Dispose ();
+ }
}
[TestFixture]
- public class ControlResizeLayoutTest
+ public class ControlSetTopLevelTest : TestHelper
+ {
+ class ControlPoker : Control {
+ public void DoSetTopLevel ()
+ {
+ SetTopLevel (true);
+ }
+ public bool DoGetTopLevel ()
+ {
+ return GetTopLevel ();
+ }
+ }
+
+ [Test]
+ public void TestControl ()
+ {
+ ControlPoker c = new ControlPoker ();
+ c.Visible = false;
+ c.DoSetTopLevel ();
+ Assert.IsTrue (c.DoGetTopLevel (), "1");
+ Assert.IsFalse (c.Visible, "2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestChildControl ()
+ {
+ Control c1 = new Control();
+ ControlPoker c2 = new ControlPoker ();
+
+ c1.Controls.Add (c2);
+ c2.DoSetTopLevel ();
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestTopLevelAdd () {
+ Form f = new Form();
+ Form f1 = new Form();
+ f.Controls.Add(f1);
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void TestForm ()
+ {
+ Form f = new Form ();
+ Assert.IsFalse (f.Visible, "3");
+ f.TopLevel = true;
+ Assert.IsFalse (f.Visible, "4");
+
+ f.Dispose ();
+ }
+ }
+
+ [TestFixture]
+ public class ControlResizeLayoutTest : TestHelper
{
class ControlPoker : Control {
public void DoOnResize ()
{
parent_event ++;
parent_affected_property = e.AffectedProperty;
+
+ TestHelper.RemoveWarning (parent_affected_property);
}
[Test]
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
}