mcs/class/Managed.Windows.Forms/Test/System.Windows.Forms/FormEventTest.cs

   1 //
   2 // Copyright (c) 2005 Novell, Inc.
   3 //
   4 // Authors:
   5 //      Ritvik Mayank (mritvik@novell.com)
   6 //
   7
   8 using System;
   9 using NUnit.Framework;
  10 using System.Windows.Forms;
  11 using System.Drawing;
  12 using System.Collections;
  13 using System.ComponentModel;
  14 using System.Threading;
  15 using Timer = System.Windows.Forms.Timer;
  16 using System.Globalization;
  17
  18 namespace MonoTests.System.Windows.Forms
  19 {
  20         [TestFixture]
  21         public class FormEvent : TestHelper
  22         {
  23                 static bool eventhandled = false;
  24                 public void New_EventHandler (object sender, EventArgs e)
  25                 {
  26                         eventhandled = true;
  27                 }
  28
  29                 private Form _form;
  30
  31                 [TearDown]
  32                 protected override void TearDown ()
  33                 {
  34                         if (_form != null)
  35                                 _form.Dispose ();
  36                         base.TearDown ();
  37                 }
  38
  39                 [Test]
  40                 public void Activated ()
  41                 {
  42                         if (TestHelper.RunningOnUnix)
  43                                 Assert.Ignore ("#3 fails");
  44
  45                         _form = new Form ();
  46                         EventLogger logger = new EventLogger (_form);
  47                         _form.ShowInTaskbar = false;
  48                         Assert.AreEqual (0, logger.CountEvents ("Activated"), "#1");
  49                         _form.Activate ();
  50                         Application.DoEvents ();
  51                         Assert.AreEqual (0, logger.CountEvents ("Activated"), "#2");
  52                         _form.Show ();
  53                         Application.DoEvents ();
  54                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#3");
  55                         _form.Show ();
  56                         Application.DoEvents ();
  57                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#4");
  58                         _form.Activate ();
  59                         Application.DoEvents ();
  60                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#5");
  61                         _form.Hide ();
  62                         Application.DoEvents ();
  63                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#6");
  64                         _form.Show ();
  65                         Application.DoEvents ();
  66                         Assert.AreEqual (2, logger.CountEvents ("Activated"), "#7");
  67                 }
  68
  69                 [Test]
  70                 public void Activated_Dialog ()
  71                 {
  72                         if (TestHelper.RunningOnUnix)
  73                                 Assert.Ignore ("#4 fails");
  74
  75                         _form = new DelayedCloseForm ();
  76                         EventLogger logger = new EventLogger (_form);
  77                         _form.ShowInTaskbar = false;
  78                         Assert.AreEqual (0, logger.CountEvents ("Activated"), "#1");
  79                         _form.Activate ();
  80                         Assert.AreEqual (0, logger.CountEvents ("Activated"), "#2");
  81                         _form.ShowDialog ();
  82                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#3");
  83                         _form.ShowDialog ();
  84                         Assert.AreEqual (2, logger.CountEvents ("Activated"), "#4");
  85                 }
  86
  87                 [Test]
  88                 public void Closed ()
  89                 {
  90                         _form = new Form ();
  91                         EventLogger logger = new EventLogger (_form);
  92                         _form.ShowInTaskbar = false;
  93                         _form.Show ();
  94                         Application.DoEvents ();
  95                         Assert.AreEqual (0, logger.CountEvents ("Closed"), "#1");
  96                         _form.Close ();
  97                         Application.DoEvents ();
  98                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#2");
  99                         _form.Close ();
 100                         Application.DoEvents ();
 101                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#3");
 102                 }
 103
 104                 [Test]
 105                 public void Closed_Dialog ()
 106                 {
 107                         _form = new DelayedCloseForm ();
 108                         EventLogger logger = new EventLogger (_form);
 109                         _form.ShowInTaskbar = false;
 110                         _form.ShowDialog ();
 111                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#1");
 112                         _form.ShowDialog ();
 113                         Assert.AreEqual (2, logger.CountEvents ("Closed"), "#2");
 114                         _form.Close ();
 115                         Application.DoEvents ();
 116                         Assert.AreEqual (2, logger.CountEvents ("Closed"), "#3");
 117                 }
 118
 119                 [Test]
 120                 public void Closing ()
 121                 {
 122                         _form = new Form ();
 123                         EventLogger logger = new EventLogger (_form);
 124                         _form.ShowInTaskbar = false;
 125                         _form.Show ();
 126                         Application.DoEvents ();
 127                         Assert.AreEqual (0, logger.CountEvents ("Closing"), "#1");
 128                         _form.Close ();
 129                         Application.DoEvents ();
 130                         Assert.AreEqual (1, logger.CountEvents ("Closing"), "#2");
 131                 }
 132
 133                 [Test]
 134                 public void Closing_Dialog ()
 135                 {
 136                         _form = new DelayedCloseForm ();
 137                         EventLogger logger = new EventLogger (_form);
 138                         _form.ShowInTaskbar = false;
 139                         _form.ShowDialog ();
 140                         Assert.AreEqual (1, logger.CountEvents ("Closing"), "#1");
 141                         _form.ShowDialog ();
 142                         Assert.AreEqual (2, logger.CountEvents ("Closing"), "#2");
 143                         _form.Close ();
 144                         Application.DoEvents ();
 145                         Assert.AreEqual (2, logger.CountEvents ("Closing"), "#3");
 146                 }
 147
 148                 [Test]
 149                 public void Deactivate ()
 150                 {
 151                         if (TestHelper.RunningOnUnix)
 152                                 Assert.Ignore ("#3 or #5 fail");
 153
 154                         _form = new Form ();
 155                         EventLogger logger = new EventLogger (_form);
 156                         _form.ShowInTaskbar = false;
 157                         _form.Activate ();
 158                         Application.DoEvents ();
 159                         Assert.AreEqual (0, logger.CountEvents ("Deactivate"), "#1");
 160                         _form.Show ();
 161                         Application.DoEvents ();
 162                         Assert.AreEqual (0, logger.CountEvents ("Deactivate"), "#2");
 163                         _form.Hide ();
 164                         Application.DoEvents ();
 165                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#3");
 166                         _form.Show ();
 167                         Application.DoEvents ();
 168                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#4");
 169                         _form.Hide ();
 170                         Application.DoEvents ();
 171                         Assert.AreEqual (2, logger.CountEvents ("Deactivate"), "#5");
 172                         _form.Close ();
 173                         Application.DoEvents ();
 174                         Assert.AreEqual (2, logger.CountEvents ("Deactivate"), "#6");
 175                         _form.Close ();
 176                         Application.DoEvents ();
 177                         Assert.AreEqual (2, logger.CountEvents ("Deactivate"), "#7");
 178                 }
 179
 180                 [Test]
 181                 public void Deactivate_Dialog ()
 182                 {
 183                         if (TestHelper.RunningOnUnix)
 184                                 Assert.Ignore ("#2 sometimes fails");
 185
 186                         _form = new DelayedCloseForm ();
 187                         EventLogger logger = new EventLogger (_form);
 188                         _form.ShowInTaskbar = false;
 189                         _form.Activate ();
 190                         Assert.AreEqual (0, logger.CountEvents ("Deactivate"), "#1");
 191                         _form.ShowDialog ();
 192                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#2");
 193                         _form.Close ();
 194                         Application.DoEvents ();
 195                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#3");
 196                 }
 197
 198                 [Test] // bug #413898
 199                 public void EventOrder ()
 200                 {
 201                         if (TestHelper.RunningOnUnix)
 202                                 Assert.Ignore ("#A3 fails");
 203
 204                         string [] expectedEvents_Show = {
 205                                 "Load",
 206                                 "VisibleChanged",
 207                                 "GotFocus",
 208                                 "Activated" };
 209
 210                         string [] expectedEvents_Close = {
 211                                 "Closing",
 212 #if NET_2_0
 213                                 "FormClosing",
 214 #endif
 215                                 "Closed",
 216 #if NET_2_0
 217                                 "FormClosed",
 218 #endif
 219                                 "Deactivate",
 220                                 "LostFocus",
 221                                 "HandleDestroyed",
 222                                 "Disposed" };
 223
 224                         _form = new Form ();
 225                         EventLogger logger = new EventLogger (_form);
 226
 227                         _form.Show ();
 228                         Application.DoEvents ();
 229
 230                         Assert.IsTrue (logger.ContainsEventsOrdered (expectedEvents_Show), "#A1:" + logger.EventsJoined());
 231                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#A2");
 232                         Assert.AreEqual (1, logger.CountEvents ("VisibleChanged"), "#A3");
 233                         Assert.AreEqual (1, logger.CountEvents ("GotFocus"), "#A4");
 234                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#A5");
 235                         Assert.AreEqual (0, logger.CountEvents ("Closing"), "#A6");
 236 #if NET_2_0
 237                         Assert.AreEqual (0, logger.CountEvents ("FormClosing"), "#A7");
 238 #endif
 239                         Assert.AreEqual (0, logger.CountEvents ("Closed"), "#A8");
 240 #if NET_2_0
 241                         Assert.AreEqual (0, logger.CountEvents ("FormClosed"), "#A9");
 242 #endif
 243                         Assert.AreEqual (0, logger.CountEvents ("Deactivate"), "#A10");
 244                         Assert.AreEqual (0, logger.CountEvents ("LostFocus"), "#A11");
 245                         Assert.AreEqual (0, logger.CountEvents ("HandleDestroyed"), "#A12");
 246                         Assert.AreEqual (0, logger.CountEvents ("Disposed"), "#A13");
 247
 248                         logger.Clear ();
 249                         _form.Close ();
 250                         Application.DoEvents ();
 251
 252                         Assert.IsTrue (logger.ContainsEventsOrdered (expectedEvents_Close), "#B1:" + logger.EventsJoined ());
 253                         Assert.AreEqual (0, logger.CountEvents ("Load"), "#B2");
 254                         Assert.AreEqual (0, logger.CountEvents ("VisibleChanged"), "#B3");
 255                         Assert.AreEqual (0, logger.CountEvents ("GotFocus"), "#B4");
 256                         Assert.AreEqual (0, logger.CountEvents ("Activated"), "#B5");
 257                         Assert.AreEqual (1, logger.CountEvents ("Closing"), "#B6");
 258 #if NET_2_0
 259                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#B7");
 260 #endif
 261                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#B8");
 262 #if NET_2_0
 263                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#B9");
 264 #endif
 265                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#B10");
 266                         Assert.AreEqual (1, logger.CountEvents ("LostFocus"), "#B11");
 267                         Assert.AreEqual (1, logger.CountEvents ("HandleDestroyed"), "#B12");
 268                         Assert.AreEqual (1, logger.CountEvents ("Disposed"), "#B13");
 269                 }
 270
 271                 [Test] // bug #413898
 272                 public void EventOrder_Dialog ()
 273                 {
 274                         if (TestHelper.RunningOnUnix)
 275                                 Assert.Ignore ("#A3 fails");
 276
 277                         string [] expectedEvents = {
 278                                 "Load",
 279                                 "VisibleChanged",
 280                                 "GotFocus",
 281                                 "Activated",
 282                                 "Closing",
 283 #if NET_2_0
 284                                 "FormClosing",
 285 #endif
 286                                 "Closed",
 287 #if NET_2_0
 288                                 "FormClosed",
 289 #endif
 290                                 "VisibleChanged",
 291                                 "Deactivate",
 292                                 "LostFocus",
 293                                 "HandleDestroyed" };
 294
 295                         _form = new DelayedCloseForm ();
 296                         EventLogger logger = new EventLogger (_form);
 297
 298                         _form.ShowDialog ();
 299                         Assert.IsTrue (logger.ContainsEventsOrdered (expectedEvents), "#A1:" + logger.EventsJoined ());
 300                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#A2");
 301                         Assert.AreEqual (2, logger.CountEvents ("VisibleChanged"), "#A3");
 302                         Assert.AreEqual (1, logger.CountEvents ("GotFocus"), "#A4");
 303                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#A5");
 304                         Assert.AreEqual (1, logger.CountEvents ("Closing"), "#A6");
 305 #if NET_2_0
 306                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#A7");
 307 #endif
 308                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#A8");
 309 #if NET_2_0
 310                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#A9");
 311 #endif
 312                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#A10");
 313                         Assert.AreEqual (1, logger.CountEvents ("LostFocus"), "#A11");
 314                         Assert.AreEqual (1, logger.CountEvents ("HandleDestroyed"), "#A12");
 315                         Assert.AreEqual (0, logger.CountEvents ("Disposed"), "#A13");
 316
 317                         logger.Clear ();
 318
 319                         _form.ShowDialog ();
 320                         Assert.IsTrue (logger.ContainsEventsOrdered (expectedEvents), "#B1:" + logger.EventsJoined ());
 321                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#B2");
 322                         Assert.AreEqual (2, logger.CountEvents ("VisibleChanged"), "#B3");
 323                         Assert.AreEqual (1, logger.CountEvents ("GotFocus"), "#B4");
 324                         Assert.AreEqual (1, logger.CountEvents ("Activated"), "#B5");
 325                         Assert.AreEqual (1, logger.CountEvents ("Closing"), "#B6");
 326 #if NET_2_0
 327                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#B7");
 328 #endif
 329                         Assert.AreEqual (1, logger.CountEvents ("Closed"), "#B8");
 330 #if NET_2_0
 331                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#B9");
 332 #endif
 333                         Assert.AreEqual (1, logger.CountEvents ("Deactivate"), "#B10");
 334                         Assert.AreEqual (1, logger.CountEvents ("LostFocus"), "#B11");
 335                         Assert.AreEqual (1, logger.CountEvents ("HandleDestroyed"), "#B12");
 336                         Assert.AreEqual (0, logger.CountEvents ("Disposed"), "#B13");
 337                 }
 338
 339 #if NET_2_0
 340                 [Test]
 341                 public void FormClosed ()
 342                 {
 343                         _form = new Form ();
 344                         EventLogger logger = new EventLogger (_form);
 345                         _form.ShowInTaskbar = false;
 346                         Assert.AreEqual (0, logger.CountEvents ("FormClosed"), "#1");
 347                         _form.Show ();
 348                         Application.DoEvents ();
 349                         Assert.AreEqual (0, logger.CountEvents ("FormClosed"), "#2");
 350                         _form.Close ();
 351                         Application.DoEvents ();
 352                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#3");
 353                         _form.Close ();
 354                         Application.DoEvents ();
 355                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#4");
 356                         _form.Close ();
 357                         Application.DoEvents ();
 358                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#5");
 359                 }
 360
 361                 [Test]
 362                 public void FormClosed_Dialog ()
 363                 {
 364                         _form = new DelayedCloseForm ();
 365                         EventLogger logger = new EventLogger (_form);
 366                         _form.ShowInTaskbar = false;
 367                         Assert.AreEqual (0, logger.CountEvents ("FormClosed"), "#1");
 368                         _form.ShowDialog ();
 369                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#2");
 370                         _form.Close ();
 371                         Application.DoEvents ();
 372                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#3");
 373                         _form.Close ();
 374                         Application.DoEvents ();
 375                         Assert.AreEqual (1, logger.CountEvents ("FormClosed"), "#4");
 376                 }
 377
 378                 [Test]
 379                 public void FormClosing ()
 380                 {
 381                         _form = new Form ();
 382                         EventLogger logger = new EventLogger (_form);
 383                         _form.ShowInTaskbar = false;
 384                         Assert.AreEqual (0, logger.CountEvents ("FormClosing"), "#1");
 385                         _form.Show ();
 386                         Application.DoEvents ();
 387                         Assert.AreEqual (0, logger.CountEvents ("FormClosing"), "#2");
 388                         _form.Close ();
 389                         Application.DoEvents ();
 390                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#3");
 391                         _form.Close ();
 392                         Application.DoEvents ();
 393                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#4");
 394                         _form.Close ();
 395                         Application.DoEvents ();
 396                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"), "#5");
 397                 }
 398
 399                 [Test]
 400                 public void FormClosing_Dialog ()
 401                 {
 402                         _form = new DelayedCloseForm ();
 403                         EventLogger logger = new EventLogger (_form);
 404                         _form.ShowInTaskbar = false;
 405                         Assert.AreEqual (0, logger.CountEvents ("FormClosing"));
 406                         _form.ShowDialog ();
 407                         Assert.AreEqual (1, logger.CountEvents ("FormClosing"));
 408                         _form.ShowDialog ();
 409                         Assert.AreEqual (2, logger.CountEvents ("FormClosing"));
 410                 }
 411 #endif
 412
 413                 [Test]
 414                 public void Load ()
 415                 {
 416                         _form = new Form ();
 417                         EventLogger logger = new EventLogger (_form);
 418                         _form.ShowInTaskbar = false;
 419                         Assert.AreEqual (0, logger.CountEvents ("Load"), "#1");
 420                         _form.Show ();
 421                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#2");
 422                         _form.Show ();
 423                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#3");
 424                         _form.Hide ();
 425                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#4");
 426                         _form.Show ();
 427                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#5");
 428                 }
 429
 430                 [Test]
 431                 public void Load_Dialog ()
 432                 {
 433                         _form = new DelayedCloseForm ();
 434                         EventLogger logger = new EventLogger (_form);
 435                         _form.ShowInTaskbar = false;
 436                         Assert.AreEqual (0, logger.CountEvents ("Load"), "#1");
 437                         _form.ShowDialog ();
 438                         Assert.AreEqual (1, logger.CountEvents ("Load"), "#2");
 439                         _form.ShowDialog ();
 440                         Assert.AreEqual (2, logger.CountEvents ("Load"), "#3");
 441                 }
 442
 443 #if NET_2_0
 444                 [Test]
 445                 public void Shown ()
 446                 {
 447                         _form = new Form ();
 448                         EventLogger logger = new EventLogger (_form);
 449                         //_form.ShowInTaskbar = false;
 450                         Assert.AreEqual (0, logger.CountEvents ("Shown"), "#1");
 451                         _form.Show ();
 452                         Application.DoEvents ();
 453                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#2");
 454                         _form.Show ();
 455                         Application.DoEvents ();
 456                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#3");
 457                         _form.Hide ();
 458                         Application.DoEvents ();
 459                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#4");
 460                         _form.Show ();
 461                         Application.DoEvents ();
 462                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#5");
 463                         _form.Close ();
 464                         Application.DoEvents ();
 465                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#6");
 466                 }
 467
 468                 [Test]
 469                 public void Shown_Dialog ()
 470                 {
 471                         _form = new DelayedCloseForm ();
 472                         EventLogger logger = new EventLogger (_form);
 473                         _form.ShowInTaskbar = false;
 474                         Assert.AreEqual (0, logger.CountEvents ("Shown"), "#1");
 475                         _form.ShowDialog ();
 476                         Assert.AreEqual (1, logger.CountEvents ("Shown"), "#2");
 477                         _form.ShowDialog ();
 478                         Assert.AreEqual (2, logger.CountEvents ("Shown"), "#3");
 479                 }
 480 #endif
 481
 482                 [Test]
 483                 public void VisibleChangedEvent ()
 484                 {
 485                         _form = new Form ();
 486                         _form.VisibleChanged += new EventHandler (FormVisibleChangedHandler);
 487
 488                         Control control1 = new Control ();
 489                         control1.Location = new Point (5, 5);
 490                         control1.VisibleChanged += new EventHandler (Control1VisibleChangedHandler);
 491                         control1_visiblechanged_count = 0;
 492
 493                         Assert.AreEqual (true, control1.Visible, "#A1");
 494                         Assert.AreEqual (false, _form.Visible, "#A2");
 495
 496                         // case one - change without being added to the form
 497                         control1.Visible = false;
 498                         Assert.AreEqual (false, control1.Visible, "#B1");
 499                         Assert.AreEqual (1, control1_visiblechanged_count, "#B2");
 500
 501                         control1.Visible = true;
 502                         control1_visiblechanged_count = 0;
 503                         _form.Controls.Add (control1);
 504                         Assert.AreEqual (false, control1.Visible, "#C1");
 505                         Assert.AreEqual (1, control1_visiblechanged_count, "#C2");
 506
 507                         // Add a second control that actually is not visible
 508                         Control control2 = new Control ();
 509                         control2.Visible = false;
 510                         _form.Controls.Add (control2);
 511
 512                         control1_visiblechanged_count = control2_visiblechanged_count = form_visiblechanged_count = 0;
 513                         _form.Show ();
 514                         Assert.AreEqual (1, control1_visiblechanged_count, "#D1");
 515                         Assert.AreEqual (0, control2_visiblechanged_count, "#D2");
 516                         Assert.AreEqual (1, form_visiblechanged_count, "#D3");
 517
 518                         _form.Dispose ();
 519                 }
 520
 521                 int control1_visiblechanged_count;
 522                 int control2_visiblechanged_count;
 523                 int form_visiblechanged_count;
 524
 525                 void Control1VisibleChangedHandler (object o, EventArgs args)
 526                 {
 527                         control1_visiblechanged_count++;
 528                 }
 529
 530                 void FormVisibleChangedHandler (object o, EventArgs args)
 531                 {
 532                         form_visiblechanged_count++;
 533                 }
 534
 535                 class DelayedCloseForm : Form
 536                 {
 537                         private Timer _timer;
 538
 539                         public DelayedCloseForm ()
 540                         {
 541                                 _timer = new Timer ();
 542                                 _timer.Tick += new EventHandler (OnTick);
 543                                 _timer.Interval = 50;
 544
 545                                 Closed += new EventHandler (OnClosed);
 546                                 Load += new EventHandler (OnLoad);
 547                         }
 548
 549                         void OnClosed (object sender, EventArgs e)
 550                         {
 551                                 _timer.Enabled = false;
 552                         }
 553
 554                         void OnLoad (object sender, EventArgs e)
 555                         {
 556                                 _timer.Enabled = true;
 557                         }
 558
 559                         void OnTick (object sender, EventArgs e)
 560                         {
 561                                 Close ();
 562                                 Application.DoEvents ();
 563                         }
 564                 }
 565
 566                 class MyForm : Form
 567                 {
 568                         public void MaximizeBoundsTest ()
 569                         {
 570                                 this.MaximizedBounds = new Rectangle (10,10,100,100);
 571                         }
 572                 }
 573
 574                 [Test]
 575                 public void MaximizedBoundsChangedTest ()
 576                 {
 577                         _form = new MyForm ();
 578                         _form.MaximizedBoundsChanged += new EventHandler (New_EventHandler);
 579                         eventhandled = false;
 580                         ((MyForm) _form).MaximizeBoundsTest ();
 581                         Assert.AreEqual (true, eventhandled, "#A5");
 582                 }
 583
 584                 [Test]
 585                 public void MaximumSizeChangedTest ()
 586                 {
 587                         _form = new Form ();
 588                         _form.ShowInTaskbar = false;
 589                         _form.MaximumSizeChanged += new EventHandler (New_EventHandler);
 590                         eventhandled = false;
 591                         _form.MaximumSize = new Size (500, 500);
 592                         Assert.AreEqual (true, eventhandled, "#A6");
 593                 }
 594
 595                 [Test, Ignore ("Manual Intervention")]
 596                 public void MdiChildActivateTest ()
 597                 {
 598                         Form parent = new Form ();
 599                         parent.ShowInTaskbar = false;
 600                         Form child = new Form ();
 601                         parent.IsMdiContainer = true;
 602                         child.IsMdiContainer = false;
 603                         child.MdiParent = parent;
 604                         parent.MdiChildActivate += new EventHandler (New_EventHandler);
 605                         eventhandled = false;
 606                         using (parent)
 607                         {
 608                                 child.Visible = true;
 609                                 parent.Show ();
 610                                 Assert.AreEqual (true, eventhandled, "#A7");
 611                                 eventhandled = false;
 612                                 child.Close ();
 613                                 Assert.AreEqual (true, eventhandled, "#A8");
 614                         }
 615                 }
 616
 617                 [Test]
 618                 public void MinimumSizeChangedTest ()
 619                 {
 620                         _form = new Form ();
 621                         _form.ShowInTaskbar = false;
 622                         _form.MinimumSizeChanged += new EventHandler (New_EventHandler);
 623                         eventhandled = false;
 624                         _form.MinimumSize = new Size(100, 100);
 625                         Assert.AreEqual (true, eventhandled, "#A10");
 626                 }
 627
 628                 /**
 629                  ** This next test is in response to a bug report
 630                  ** which pointed out that the idle events were being
 631                  ** sent to every thread rather than just the thread
 632                  ** they were assigned on.
 633                  **
 634                  ** Report: https://bugzilla.novell.com/show_bug.cgi?id=321541
 635                  **/
 636                 private static Form form1_OneIdlePerThread = null;
 637                 private static Form form2_OneIdlePerThread = null;
 638                 private static int count1_OIPT = 0;
 639                 private static int count2_OIPT = 0;
 640                 private static ThreadStart OIPT_ThreadStart2;
 641                 private static Thread OIPT_Thread2;
 642                 private static int oipt_t1 = 0;
 643                 private static int oipt_t2 = 0;
 644                 [Test]
 645                 [NUnit.Framework.Category ("NotWorking")]
 646                 public void OneIdlePerThread () {
 647                         Thread t = Thread.CurrentThread;
 648                         oipt_t1 = t.ManagedThreadId;
 649                         count1_OIPT = 0;
 650                         count2_OIPT = 0;
 651                         form1_OneIdlePerThread = new Form ();
 652                         form2_OneIdlePerThread = new Form ();
 653                         form1_OneIdlePerThread.Show ();
 654
 655                         OIPT_ThreadStart2 = new ThreadStart (TIPT_Two);
 656                         OIPT_Thread2=new Thread (OIPT_ThreadStart2);
 657                         OIPT_Thread2.IsBackground = true;
 658                         OIPT_Thread2.SetApartmentState (ApartmentState.STA);
 659                         OIPT_Thread2.Start ();
 660                         Application.Idle += new EventHandler (TestIdlePerThread);
 661                         Application.Run (form1_OneIdlePerThread);
 662                         if (!OIPT_Thread2.Join (1000)){
 663                                 OIPT_Thread2.Abort();
 664                         }
 665
 666                         Assert.AreEqual (true, count1_OIPT == 1,
 667                                 "#Idle: idle #1 hit too many times");
 668                         Assert.AreEqual (true, count2_OIPT == 1,
 669                                 "#Idle: idle #2 hit too many times");
 670                 }
 671                 public static void TIPT_Two (){
 672                         Thread t = Thread.CurrentThread;
 673                         oipt_t2 = t.ManagedThreadId;
 674                         Application.Idle +=
 675                                 new EventHandler (TestIdlePerThread2);
 676                         Application.Run (form2_OneIdlePerThread);
 677                 }
 678                 public static void TestIdlePerThread (object o, EventArgs e) {
 679                         Thread t = Thread.CurrentThread;
 680                         count1_OIPT++;
 681                         Application.Idle -=
 682                                 new EventHandler (TestIdlePerThread);
 683                         /* Give thread2 time to finish before we close */
 684                         Thread.Sleep(100);
 685                         if (form1_OneIdlePerThread != null)
 686                                 form1_OneIdlePerThread.Close ();
 687                         Assert.AreEqual (true, oipt_t1 == t.ManagedThreadId,
 688                                 "#Idle:Wrong Thread-t1");
 689                 }
 690                 public static void TestIdlePerThread2 (object o, EventArgs e) {
 691                         Thread t = Thread.CurrentThread;
 692                         count2_OIPT++;
 693                         Application.Idle -=
 694                                 new EventHandler(TestIdlePerThread2);
 695                         if (form2_OneIdlePerThread != null)
 696                                 form2_OneIdlePerThread.Invoke
 697                                   (new MethodInvoker (form2_OneIdlePerThread.Close));
 698                         Assert.AreEqual (true, oipt_t2 == t.ManagedThreadId,
 699                                 "#Idle:Wrong Thread-t2");
 700                 }
 701
 702         }
 703
 704         [TestFixture]
 705         public class ClosingEvent
 706         {
 707                 bool cancel = true;
 708                 CancelEventArgs args = null;
 709                 public void Closing_Handler (object sender, CancelEventArgs e)
 710                 {
 711                         e.Cancel = cancel;
 712                         args = e;
 713                 }
 714
 715                 [Test, Ignore ("visual test")]
 716                 public void ClosingEventTest ()
 717                 {
 718                         Form myform = new Form ();
 719                         myform.ShowInTaskbar = false;
 720                         myform.Closing += new CancelEventHandler (Closing_Handler);
 721                         myform.Show ();
 722                         args = null;
 723                         myform.Close ();
 724                         Assert.AreEqual (true, args != null, "#A11");
 725                         Assert.AreEqual (true, myform.Visible, "#A12");
 726                         cancel = false;
 727                         args = null;
 728                         myform.Close ();
 729                         Assert.AreEqual (true, args != null, "#A13");
 730                         Assert.AreEqual (false, myform.Visible, "#A14");
 731                 }
 732         }
 733
 734         [TestFixture,Ignore ("Test Breaks")]
 735         public class InputLanguageChangedEvent
 736         {
 737                 static bool eventhandled = false;
 738                 public void InputLanguage_Handler (object sender,InputLanguageChangedEventArgs e)
 739                 {
 740                         eventhandled = true;
 741                 }
 742
 743                 [Test]
 744                 public void InputLanguageChangedEventTest ()
 745                 {
 746                         Form myform = new Form ();
 747                         myform.ShowInTaskbar = false;
 748                         CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
 749                         CultureInfo oldcui = Thread.CurrentThread.CurrentUICulture;
 750                         InputLanguage oldil = InputLanguage.CurrentInputLanguage;
 751                         try {
 752                                 if (InputLanguage.InstalledInputLanguages.Count > 1) {
 753                                         InputLanguage.CurrentInputLanguage = InputLanguage.InstalledInputLanguages[0];
 754                                         myform.InputLanguageChanged += new InputLanguageChangedEventHandler (InputLanguage_Handler);
 755                                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("ta-IN");
 756                                         Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
 757                                         InputLanguage.CurrentInputLanguage = InputLanguage.InstalledInputLanguages[1];
 758                                         Assert.AreEqual (true, eventhandled, "#A15");
 759                                 }
 760                         } finally {
 761                                 Thread.CurrentThread.CurrentCulture = oldci;
 762                                 Thread.CurrentThread.CurrentUICulture = oldcui;
 763                                 InputLanguage.CurrentInputLanguage = oldil;
 764                         }
 765                         myform.Dispose ();
 766                 }
 767         }
 768
 769         [TestFixture,Ignore ("Test Breaks")]
 770         public class InputLanguageChangingEvent
 771         {
 772                 static bool eventhandled = false;
 773                 public void InputLangChanging_Handler(object sender,InputLanguageChangingEventArgs e)
 774                 {
 775                         eventhandled = true;
 776                 }
 777
 778                 [Test]
 779                 public void InputLanguageChangingEventTest ()
 780                 {
 781                         Form myform = new Form ();
 782                         myform.ShowInTaskbar = false;
 783                         CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
 784                         CultureInfo oldcui = Thread.CurrentThread.CurrentUICulture;
 785                         InputLanguage oldil = InputLanguage.CurrentInputLanguage;
 786                         try {
 787                                 if (InputLanguage.InstalledInputLanguages.Count > 1)
 788                                 {
 789                                         InputLanguage.CurrentInputLanguage = InputLanguage.InstalledInputLanguages[0];
 790                                         myform.InputLanguageChanging += new InputLanguageChangingEventHandler (InputLangChanging_Handler);
 791                                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("ta-IN");
 792                                         Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
 793                                         InputLanguage.CurrentInputLanguage = InputLanguage.InstalledInputLanguages[1];
 794                                         Assert.AreEqual (true, eventhandled, "#A16");
 795                                 }
 796                         } finally {
 797                                 Thread.CurrentThread.CurrentCulture = oldci;
 798                                 Thread.CurrentThread.CurrentUICulture = oldcui;
 799                                 InputLanguage.CurrentInputLanguage = oldil;
 800                         }
 801                         myform.Dispose ();
 802                 }
 803         }
 804 }