test/2.0/moon-unit/System.Windows/LoadedTest.cs

   1 //
   2 // Contact:
   3 //   Moonlight List (moonlight-list@lists.ximian.com)
   4 //
   5 // Copyright (C) 2009 Novell, Inc (http://www.novell.com)
   6 //
   7 // Permission is hereby granted, free of charge, to any person obtaining
   8 // a copy of this software and associated documentation files (the
   9 // "Software"), to deal in the Software without restriction, including
  10 // without limitation the rights to use, copy, modify, merge, publish,
  11 // distribute, sublicense, and/or sell copies of the Software, and to
  12 // permit persons to whom the Software is furnished to do so, subject to
  13 // the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be
  16 // included in all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.Net;
  29 using System.Windows;
  30 using System.Windows.Controls;
  31 using System.Windows.Documents;
  32 using System.Windows.Ink;
  33 using System.Windows.Input;
  34 using System.Windows.Media;
  35 using System.Windows.Media.Animation;
  36 using System.Windows.Shapes;
  37 using System.Collections.Generic;
  38 using System.Windows.Markup;
  39 using Microsoft.VisualStudio.TestTools.UnitTesting;
  40 using Microsoft.Silverlight.Testing;
  41 using Mono.Moonlight.UnitTesting;
  42
  43 namespace MoonTest.System.Windows
  44 {
  45         [TestClass]
  46         public class LoadedTest : SilverlightTest
  47         {
  48                 public class MyComboBox : ComboBox
  49                 {
  50                         public bool AppliedTemplate { get; private set; }
  51
  52                         public override void OnApplyTemplate ()
  53                         {
  54                                 AppliedTemplate = true;
  55                                 base.OnApplyTemplate ();
  56                         }
  57                 }
  58
  59                 void AddThenRemove_test (bool match_tick_numbers)
  60                 {
  61                         int b_count = 0;
  62                         int c_count = 0;
  63
  64                         Canvas c = new Canvas ();
  65                         MyComboBox b = new MyComboBox ();
  66                         MyComboBox second = new MyComboBox ();
  67
  68                         b.Loaded += delegate { b_count++; };
  69                         c.Loaded += delegate { c_count++; };
  70
  71                         c.Children.Add (b);
  72
  73                         TestPanel.Children.Add (c);
  74                         EnqueueConditional (() => b_count == 1 && c_count == 1, "#1");
  75
  76                         // If an item with delayed loaded emission is added to the tree, the entire tree
  77                         // will be walked to find Loaded handlers which have not been emitted and will emit
  78                         // those. The handlers will be invoked the tick *after* the template is applied.
  79                         Enqueue (() => {
  80                                 b.Loaded += delegate { b_count += 10; };
  81                                 c.Loaded += delegate { c_count += 10; };
  82
  83                                 c.Children.Add (second);
  84                                 Assert.IsFalse (second.AppliedTemplate, "#AppliedTemplate 1");
  85                         });
  86                         Enqueue (() => {
  87                                 Assert.IsTrue (second.AppliedTemplate, "#AppliedTemplate 2");
  88
  89                                 if (match_tick_numbers) {
  90                                         // in moonlight the c.Children.Add posts the
  91                                         // loaded event emission hook for async use, but the
  92                                         // render callback is invoked right after the Enqueue
  93                                         // which happens from a DispatcherTimer (an
  94                                         // animation clock).
  95
  96                                         // therefore the properties are updated after the
  97                                         // previous Enqueue, but before this one.
  98                                         //
  99                                         Assert.AreEqual (1, b_count, "#2");
 100                                         Assert.AreEqual (1, c_count, "#3");
 101                                 }
 102                         });
 103                         // Adding an item with immediate loaded emission doesn't invoke new
 104                         // Loaded handlers on its parent UIElements
 105                         Enqueue (() => {
 106                                 Assert.AreEqual (11, b_count, "#4");
 107                                 Assert.AreEqual (11, c_count, "#5");
 108
 109                                 b.Loaded += delegate { b_count += 100; };
 110                                 c.Loaded += delegate { c_count += 100; };
 111                                 c.Children.Add (new Canvas ());
 112                         });
 113                         Enqueue (() => {
 114                                 Assert.AreEqual (11, b_count, "#6");
 115                                 Assert.AreEqual (11, c_count, "#7");
 116                         });
 117                         EnqueueTestComplete ();
 118                 }
 119
 120                 [TestMethod]
 121                 [Asynchronous]
 122                 public void AddThenRemove ()
 123                 {
 124                         AddThenRemove_test (false);
 125                 }
 126
 127                 [TestMethod]
 128                 [Asynchronous]
 129                 [MoonlightBug ("see comment in AddThenRemove_test")]
 130                 public void AddThenRemove_strictOrdering ()
 131                 {
 132                         AddThenRemove_test (true);
 133                 }
 134
 135                 [TestMethod]
 136                 [Asynchronous]
 137                 public void AddTwice ()
 138                 {
 139                         AddTwice_test (false);
 140                 }
 141
 142                 [TestMethod]
 143                 [Asynchronous]
 144                 [MoonlightBug ("see comment in AddThenRemove_test")]
 145                 public void AddTwice_strictOrdering ()
 146                 {
 147                         AddTwice_test (true);
 148                 }
 149
 150                 public void AddTwice_test (bool match_tick_numbers)
 151                 {
 152                         // If we add a handler both before and after we add a templated item
 153                         // to the tree, check to ensure that both handlers get called immediately
 154                         // if the element is removed and added again.
 155                         int before = 0;
 156                         int after = 0;
 157                         ComboBox box = new ComboBox ();
 158                         box.Loaded += delegate { before++; };
 159                         TestPanel.Children.Add (box);
 160                         box.Loaded += delegate { after++; };
 161                         Enqueue (() => {
 162                                 // The first handler should have emitted now.
 163                                 Assert.AreEqual (1, before, "#1");
 164
 165                                 if (match_tick_numbers) {
 166                                         // The template has been applied this tick, so the
 167                                         // second handler will invoke during the next tick
 168                                         Assert.AreEqual (0, after, "#2");
 169                                 }
 170                         });
 171                         Enqueue (() => {
 172                                 Assert.AreEqual (1, before, "#3");
 173                                 Assert.AreEqual (1, after, "#4");
 174
 175                                 // Both handlers should emit again now.
 176                                 TestPanel.Children.Clear ();
 177                                 TestPanel.Children.Add (box);
 178                         });
 179                         Enqueue (() => {
 180                                 Assert.AreEqual (2, before, "#5");
 181                                 Assert.AreEqual (2, after, "#6");
 182                         });
 183                         EnqueueTestComplete ();
 184                 }
 185
 186                 [TestMethod]
 187                 [Asynchronous]
 188                 public void AsyncLoaded ()
 189                 {
 190                         // Attach the handler before adding the control to the tree.
 191                         bool loaded = false;
 192                         Border b = new Border ();
 193
 194                         b.Loaded += delegate { loaded = true; };
 195                         TestPanel.Children.Add (b);
 196
 197                         // Loaded is not raised synchronously
 198                         Assert.IsFalse (loaded, "Not syncronous");
 199
 200                         EnqueueConditional (() => loaded, "Loaded should be raised");
 201                         EnqueueTestComplete ();
 202                 }
 203
 204                 [TestMethod]
 205                 [Asynchronous]
 206                 [ExpectedException (typeof (Exception))]
 207                 public void AsyncLoaded2 ()
 208                 {
 209                         // Attach the handler after the control is added to the tree
 210                         bool loaded = false;
 211                         Border b = new Border ();
 212
 213                         TestPanel.Children.Add (b);
 214                         b.Loaded += delegate { loaded = true; };
 215
 216                         // The handler is never invoked - this is a standard async event.
 217                         Assert.IsFalse (loaded, "Not syncronous");
 218
 219                         EnqueueConditional (() => loaded, TimeSpan.FromSeconds (1), "This should time out");
 220                         EnqueueTestComplete ();
 221                 }
 222
 223                 [TestMethod]
 224                 [Asynchronous]
 225                 public void ChildForcesParentToEmitLoad ()
 226                 {
 227                         ChildForcesParentToEmitLoad_test (false);
 228                 }
 229
 230                 [TestMethod]
 231                 [Asynchronous]
 232                 [MoonlightBug ("see comment in AddThenRemove_test")]
 233                 public void ChildForcesParentToEmitLoad_strictOrdering ()
 234                 {
 235                         ChildForcesParentToEmitLoad_test (true);
 236                 }
 237
 238                 public void ChildForcesParentToEmitLoad_test (bool match_tick_numbers)
 239                 {
 240                         bool loaded = false;
 241                         TestPanel.Loaded += delegate { loaded = true; };
 242                         TestPanel.Children.Add (new ComboBox ());
 243                         Enqueue (() => {
 244                                 if (match_tick_numbers)
 245                                         Assert.IsFalse (loaded, "#1");
 246                         });
 247                         Enqueue (() => {
 248                                 // When the ComboBoxs Template expands, it forces the
 249                                 // canvas to call any unemitted Loaded handlers.
 250                                 Assert.IsTrue (loaded, "#2");
 251                         });
 252                         EnqueueTestComplete ();
 253                 }
 254
 255                 [TestMethod]
 256                 [Asynchronous]
 257                 public void ControlLoaded ()
 258                 {
 259                         bool loaded = false;
 260                         ItemsControl c = new ItemsControl ();
 261                         c.Loaded += delegate { loaded = true; };
 262                         TestPanel.Children.Add (c);
 263                         EnqueueConditional (() => loaded);
 264                         EnqueueTestComplete ();
 265                 }
 266
 267                 [TestMethod]
 268                 [Asynchronous]
 269                 [ExpectedException (typeof (Exception))]
 270                 public void ControlLoaded2 ()
 271                 {
 272                         bool loaded = false;
 273                         ItemsControl c = new ItemsControl ();
 274                         TestPanel.Children.Add (c);
 275                         c.Loaded += delegate { loaded = true; };
 276                         EnqueueConditional (() => loaded);
 277                         EnqueueTestComplete ();
 278                 }
 279
 280                 [TestMethod]
 281                 [Asynchronous]
 282                 public void DefaultStyleApply ()
 283                 {
 284                         ComboBox box = new ComboBox ();
 285                         Assert.IsNull (box.Style, "#1");
 286                         Assert.IsNull (box.Template, "#2");
 287                         TestPanel.Children.Add (box);
 288                         Assert.IsNull (box.Style, "#3");
 289                         Assert.IsNotNull (box.Template, "#4");
 290                         Assert.IsUnset (box, Control.TemplateProperty, "#5");
 291
 292                         Enqueue (() => {
 293                                 Assert.IsNull (box.Style, "#5");
 294                         });
 295                         EnqueueTestComplete ();
 296                 }
 297
 298                 [TestMethod]
 299                 [Asynchronous]
 300                 public void EmitBeforeAndAfter ()
 301                 {
 302                         EmitBeforeAndAfter_test (false);
 303                 }
 304
 305                 [TestMethod]
 306                 [Asynchronous]
 307                 [MoonlightBug ("see comment in AddThenRemove_test")]
 308                 public void EmitBeforeAndAfter_strictOrdering ()
 309                 {
 310                         EmitBeforeAndAfter_test (true);
 311                 }
 312
 313                 public void EmitBeforeAndAfter_test (bool match_tick_numbers)
 314                 {
 315                         // Adding a templated control to the visual tree results in a second Loaded
 316                         // being emitted *after* the template expands for that control.
 317                         bool before_b = false;
 318                         bool before_c = false;
 319                         bool after_b = false;
 320                         bool after_c = false;
 321
 322                         Canvas c = new Canvas ();
 323                         ComboBox b = new ComboBox ();
 324                         c.Children.Add (b);
 325
 326                         c.Loaded += delegate { before_c = true; };
 327                         b.Loaded += delegate { before_b = true; };
 328                         TestPanel.Children.Add (c);
 329                         c.Loaded += delegate { after_c = true; };
 330                         b.Loaded += delegate { after_b = true; };
 331
 332                         Enqueue (() => {
 333                                 Assert.IsTrue (before_b, "#1");
 334                                 Assert.IsTrue (before_c, "#2");
 335                                 if (match_tick_numbers) {
 336                                         Assert.IsFalse (after_b, "#3");
 337                                         Assert.IsFalse (after_c, "#4");
 338                                 }
 339                         });
 340                         Enqueue (() => {
 341                                 Assert.IsTrue (after_b, "#3");
 342                                 Assert.IsTrue (after_c, "#4");
 343                         });
 344                         EnqueueTestComplete ();
 345                 }
 346
 347                 [TestMethod]
 348                 [Asynchronous]
 349                 public void EmitBeforeAndAfter2 ()
 350                 {
 351                         // If we call ApplyTemplate (), the second set of Loaded
 352                         // events is emitted immediately.
 353                         bool before_b = false;
 354                         bool before_c = false;
 355                         bool after_b = false;
 356                         bool after_c = false;
 357
 358                         Canvas c = new Canvas ();
 359                         ComboBox b = new ComboBox ();
 360                         c.Children.Add (b);
 361
 362                         c.Loaded += delegate { before_c = true; };
 363                         b.Loaded += delegate { before_b = true; };
 364                         TestPanel.Children.Add (c);
 365                         c.Loaded += delegate { after_c = true; };
 366                         b.Loaded += delegate { after_b = true; };
 367
 368                         // Calling 'ApplyTemplate' emits the Loaded
 369                         // events for the template, so all handlers will
 370                         // be raised during the next tick.
 371                         b.ApplyTemplate ();
 372
 373                         Enqueue (() => {
 374                                 Assert.IsTrue (before_b, "#1");
 375                                 Assert.IsTrue (before_c, "#2");
 376                                 Assert.IsTrue (after_b, "#3");
 377                                 Assert.IsTrue (after_c, "#4");
 378                         });
 379                         EnqueueTestComplete ();
 380                 }
 381
 382                 [TestMethod]
 383                 [Asynchronous]
 384                 [MoonlightBug ("we don't emit Loaded events in insertion order")]
 385                 public void ForceEventEmission ()
 386                 {
 387                         // If we add a control which does *not* have a loaded handler
 388                         // attached, then we don't force emission of other Loaded handlers in
 389                         // the order in which they're added.
 390                         ForceEventEmissionImpl (false);
 391                 }
 392
 393                 [TestMethod]
 394                 [Asynchronous]
 395                 [MoonlightBug ("we don't emit Loaded events in insertion order")]
 396                 public void ForceEventEmission2 ()
 397                 {
 398                         // If we add a control which *does* have a loaded handler
 399                         // attached, then we force emission of other Loaded handlers in
 400                         // the order in which they're added.
 401                         ForceEventEmissionImpl (true);
 402                 }
 403
 404                 public void ForceEventEmissionImpl (bool attachLoadedHandler)
 405                 {
 406
 407                         string loaded = "";
 408                         Canvas box = new Canvas ();// ComboBox box = new ComboBox { Style = null, Template = null };
 409                         Canvas container = new Canvas ();
 410
 411                         Canvas main = new Canvas ();
 412                         Canvas child = new Canvas ();
 413                         Canvas baby = new Canvas ();
 414
 415                         main.Children.Add (child);
 416                         child.Children.Add (baby);
 417
 418                         EnqueueWaitLoaded (container, "#1");
 419                         EnqueueWaitLoaded (main, "#2");
 420
 421                         TestPanel.Children.Add (container);
 422                         TestPanel.Children.Add (main);
 423
 424                         Enqueue (() => {
 425                                 // NOTE: The normal order of event emission is bottom->top but in
 426                                 // this case the handlers are emitted in the order they're added
 427                                 baby.Loaded += delegate { loaded += "baby"; };
 428                                 main.Loaded += delegate { loaded += "main"; };
 429                                 child.Loaded += delegate { loaded += "child"; };
 430
 431                                 if (attachLoadedHandler)
 432                                         box.Loaded += delegate { };
 433
 434                                 container.Children.Add (box);
 435
 436                                 child.Loaded += delegate { loaded += "baby2"; };
 437                                 main.Loaded += delegate { loaded += "main2"; };
 438                                 baby.Loaded += delegate { loaded += "child2"; };
 439                         });
 440                         Enqueue (() => {
 441                                 Assert.AreEqual (attachLoadedHandler ? "babymainchild" : "", loaded, "#3");
 442                         });
 443                         Enqueue (() => {
 444                                 Assert.AreEqual (attachLoadedHandler ? "babymainchild" : "", loaded, "#4");
 445                                 //And force the second set
 446                                 loaded = "";
 447                                 Canvas c = new Canvas ();
 448                                 c.Loaded += delegate { };
 449                                 TestPanel.Children.Add (c);
 450                         });
 451                         Enqueue (() => {
 452                                 // If the first element had a Loaded handler attached, then we should only get the second set of handlers
 453                                 // Otherwise we get both sets.
 454                                 Assert.AreEqual (attachLoadedHandler ? "baby2main2child2" : "babymainchildbaby2main2child2", loaded, "#5");
 455                         });
 456                         EnqueueTestComplete ();
 457                 }
 458
 459                 [TestMethod]
 460                 [Asynchronous]
 461                 public void ForceEventEmission3 ()
 462                 {
 463                         // Add a canvas to the tree and wait for it to load.
 464                         // Add a second Loaded handler which won't be invoked
 465                         // initially and then poke it til it invokes.
 466
 467                         int count = 0;
 468                         Canvas c = new Canvas ();
 469                         EnqueueWaitLoaded (c, "#1");
 470                         TestPanel.Children.Add (c);
 471
 472                         c.Loaded += delegate { count ++;};
 473
 474                         // Second handler hasn't invoked
 475                         Enqueue (() => Assert.AreEqual (0, count, "#2"));
 476
 477                         Enqueue (() => {
 478                                 // This should not cause the second handler to invoke
 479                                 Assert.AreEqual (0, count, "#3");
 480                                 c = new Canvas ();
 481                                 TestPanel.Children.Add (c);
 482                         });
 483                         Enqueue (() => {
 484                                 // This will cause it to be invoked
 485                                 Assert.AreEqual (0, count, "#4");
 486                                 c = new Canvas ();
 487                                 c.Loaded += delegate { };
 488                                 TestPanel.Children.Add (c);
 489                         });
 490                         Enqueue (() => Assert.AreEqual (1, count, "#5"));
 491                         EnqueueTestComplete ();
 492                 }
 493
 494                 [TestMethod]
 495                 [Asynchronous]
 496                 public void LoadedOrdering ()
 497                 {
 498                         List<string> ordering = new List<string> ();
 499                         RoutedEventHandler loadedHandler = (o, e) => ordering.Add (((FrameworkElement) o).Name);
 500
 501                         Canvas a = new Canvas { Name = "a" };
 502                         Canvas a1 = new Canvas { Name = "a1" };
 503                         a.Children.Add (a1);
 504
 505                         Canvas b = new Canvas { Name = "b" };
 506                         Canvas b1 = new Canvas { Name = "b1" };
 507                         b.Children.Add (b1);
 508
 509                         a.Loaded += loadedHandler;
 510                         a1.Loaded += loadedHandler;
 511                         b.Loaded += loadedHandler;
 512                         b1.Loaded += loadedHandler;
 513
 514                         TestPanel.Children.Add (a);
 515                         a1.Children.Add (b);
 516
 517                         Enqueue (() => {
 518                                 Assert.AreEqual (4, ordering.Count, "#1");
 519                                 Assert.AreEqual ("a1", ordering [0], "#2");
 520                                 Assert.AreEqual ("a", ordering [1], "#3");
 521                                 Assert.AreEqual ("b1", ordering [2], "#4");
 522                                 Assert.AreEqual ("b", ordering [3], "#5");
 523
 524                         });
 525                         EnqueueTestComplete ();
 526                 }
 527
 528                 [TestMethod]
 529                 [Asynchronous]
 530                 [ExpectedException (typeof (Exception))]
 531                 public void LoadedA1 ()
 532                 {
 533                         // Adding the handler after adding the item to the panel will
 534                         // prevent the handler being invoked
 535                         var box = new ItemsControl ();
 536                         TestPanel.Children.Add (box);
 537                         EnqueueWaitLoaded (box, "#1");
 538                         EnqueueTestComplete ();
 539                 }
 540
 541                 [TestMethod]
 542                 [Asynchronous]
 543                 public void LoadedA2 ()
 544                 {
 545                         // If the applied default style contains no 'template', the loaded
 546                         // handler is invoked inside ElementAdded as a regular async event
 547                         var box = new ItemsControl ();
 548                         EnqueueWaitLoaded (box, "#1");
 549                         TestPanel.Children.Add (box);
 550                         Enqueue (() => Assert.IsNull (box.Template, "#2"));
 551                         EnqueueTestComplete ();
 552                 }
 553
 554                 [TestMethod]
 555                 [Asynchronous]
 556                 public void LoadedA3 ()
 557                 {
 558                         // A user set Template should result in standard behaviour
 559                         ItemsControl c = (ItemsControl) XamlReader.Load (@"
 560 <ItemsControl
 561     xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
 562     xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"">
 563         <ItemsControl.Template>
 564                 <ControlTemplate>
 565                         <Grid />
 566                 </ControlTemplate>
 567         </ItemsControl.Template>
 568 </ItemsControl>
 569 ");
 570                         bool loaded = false;
 571                         c.Loaded += (o,e) => { loaded = true; };
 572                         TestPanel.Children.Add (c);
 573                         Assert.IsFalse (loaded, "#1");
 574                         EnqueueWaitLoaded (c, "#2");
 575                         EnqueueTestComplete ();
 576                 }
 577
 578
 579                 [TestMethod]
 580                 [Asynchronous]
 581                 public void LoadedB1 ()
 582                 {
 583                         // The ComboBox default style contains a Template, therefore we delay
 584                         // the WalkTreeForLoaded call until after the default style is applied
 585                         // and then do our tree walk. This allows us to add a handler *after*
 586                         // the element is added to the tree and still have it invoked
 587                         var box = new ComboBox ();
 588                         TestPanel.Children.Add (box);
 589                         EnqueueWaitLoaded (box, "#1");
 590                         Enqueue (() => Assert.IsNotNull (box.Template, "#2"));
 591                         Enqueue (() => Assert.IsUnset (box, Control.TemplateProperty, "#3"));
 592                         EnqueueTestComplete ();
 593                 }
 594
 595                 [TestMethod]
 596                 [Asynchronous]
 597                 [ExpectedException (typeof (Exception))]
 598                 public void LoadedB2 ()
 599                 {
 600                         // If we explicitly put in 'null' as the template, it overrides the one
 601                         // provided in the default style, so we treat this as an untemplated
 602                         // item and do the regular treewalk.
 603                         var box = new ComboBox ();
 604                         box.Template = null;
 605                         TestPanel.Children.Add (box);
 606                         EnqueueWaitLoaded (box, "#1");
 607                         Enqueue (() => Assert.IsNotNull (box.Template, "#2"));
 608                         EnqueueTestComplete ();
 609                 }
 610
 611                 [TestMethod]
 612                 [Asynchronous]
 613                 [ExpectedException (typeof (Exception))]
 614                 [MoonlightBug]
 615                 public void LoadedB3 ()
 616                 {
 617                         // A user set Template should result in standard behaviour
 618                         ComboBox c = (ComboBox) XamlReader.Load (@"
 619 <ComboBox
 620     xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation""
 621     xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"">
 622         <ComboBox.Template>
 623                 <ControlTemplate>
 624                         <Grid />
 625                 </ControlTemplate>
 626         </ComboBox.Template>
 627 </ComboBox>
 628 ");
 629                         TestPanel.Children.Add (c);
 630                         EnqueueWaitLoaded (c, "#1");
 631                         EnqueueTestComplete ();
 632                 }
 633
 634                 [TestMethod]
 635                 [Asynchronous]
 636                 public void LoadedC1 ()
 637                 {
 638                         List<string> ordering = new List<string> ();
 639                         Canvas container = new Canvas ();
 640
 641                         Canvas c = new Canvas ();
 642                         ComboBox b = new ComboBox ();
 643                         b.Loaded += delegate { ordering.Add ("box"); };
 644                         c.Loaded += delegate { ordering.Add ("canvas"); };
 645
 646                         EnqueueWaitLoaded (container, "#1");
 647                         TestPanel.Children.Add (container);
 648
 649                         Enqueue (() => {
 650                                 TestPanel.Children.Add (b);
 651                                 container.Children.Add (c);
 652                         });
 653
 654                         EnqueueWaitLoaded (b, "#2");
 655                         EnqueueWaitLoaded (c, "#3");
 656
 657                         Enqueue (() => {
 658                                 Assert.AreEqual ("box", ordering [0], "#4");
 659                                 Assert.AreEqual ("canvas", ordering [1], "#5");
 660                         });
 661                         EnqueueTestComplete ();
 662                 }
 663
 664                 [TestMethod]
 665                 [Asynchronous]
 666                 public void LoadedC2 ()
 667                 {
 668                         List<string> ordering = new List<string> ();
 669
 670                         Canvas container = new Canvas ();
 671                         Canvas last = new Canvas ();
 672                         Canvas first = new Canvas ();
 673                         ComboBox box = new ComboBox ();
 674
 675
 676                         container.Loaded += (o, e) => ordering.Add ("container");
 677                         last.Loaded += (o, e) => ordering.Add ("last");
 678                         first.Loaded += (o, e) => ordering.Add ("first");
 679                         box.Loaded += (o, e) => ordering.Add ("box");
 680                         container.Children.Add (box);
 681
 682                         TestPanel.Children.Add (first);
 683                         TestPanel.Children.Add (container);
 684                         TestPanel.Children.Add (last);
 685
 686                         EnqueueWaitLoaded (container, "#1");
 687                         EnqueueWaitLoaded (box, "#2");
 688                         Enqueue (() => {
 689                                 Assert.AreEqual ("first", ordering [0], "#3");
 690                                 Assert.AreEqual ("box", ordering [1], "#4");
 691                                 Assert.AreEqual ("container", ordering [2], "#5");
 692                                 Assert.AreEqual ("last", ordering [3], "#6");
 693                         });
 694                         EnqueueTestComplete ();
 695                 }
 696
 697                 [TestMethod]
 698                 [Asynchronous]
 699                 public void LoadedC3 ()
 700                 {
 701                         Canvas c = new Canvas ();
 702                         ComboBox b = new ComboBox ();
 703                         c.Children.Add (b);
 704
 705                         TestPanel.Children.Add (c);
 706                         EnqueueWaitLoaded (c, "#1");
 707                         EnqueueWaitLoaded (b, "#2");
 708                         EnqueueTestComplete ();
 709                 }
 710
 711                 [TestMethod]
 712                 [Asynchronous]
 713                 public void LoadedD ()
 714                 {
 715                         List<string> ordering = new List<string> ();
 716                         Canvas c = new Canvas ();
 717                         ComboBox b = new ComboBox ();
 718
 719                         c.Loaded += delegate { ordering.Add ("canvas"); };
 720                         b.Loaded += delegate { ordering.Add ("box"); };
 721
 722                         EnqueueWaitLoaded (c, "#1");
 723                         EnqueueWaitLoaded (b, "#2");
 724
 725                         TestPanel.Children.Add (b);
 726                         TestPanel.Children.Add (c);
 727
 728                         Enqueue (() => {
 729                                 Assert.AreEqual ("box", ordering [0], "#4");
 730                                 Assert.AreEqual ("canvas", ordering [1], "#3");
 731                         });
 732                         EnqueueTestComplete ();
 733                 }
 734
 735                 [TestMethod]
 736                 [Asynchronous]
 737                 public void RemoveAfterAdded ()
 738                 {
 739                         // See what happens if we add/remove the same element
 740                         // multiple times in a row.
 741                         int loaded = 0;
 742                         ComboBox box = new ComboBox ();
 743
 744                         box.Loaded += delegate { loaded++; };
 745                         TestPanel.Children.Add (box);
 746                         TestPanel.Children.Clear ();
 747                         TestPanel.Children.Add (box);
 748                         TestPanel.Children.Clear ();
 749                         TestPanel.Children.Add (box);
 750
 751                         Enqueue (() => {
 752                                 Assert.AreEqual (3, loaded, "#1");
 753                         });
 754                         EnqueueTestComplete ();
 755                 }
 756
 757                 [TestMethod]
 758                 [Asynchronous]
 759                 public void RemoveAfterTemplateLoaded ()
 760                 {
 761                         RemoveAfterTemplateLoaded_test (false);
 762                 }
 763
 764                 [TestMethod]
 765                 [Asynchronous]
 766                 [MoonlightBug ("see comment in AddThenRemove_test")]
 767                 public void RemoveAfterTemplateLoaded_strictOrdering ()
 768                 {
 769                         RemoveAfterTemplateLoaded_test (true);
 770                 }
 771
 772                 public void RemoveAfterTemplateLoaded_test (bool match_tick_numbers)
 773                 {
 774                         int before = 0;
 775                         int after = 0;
 776                         ComboBox box = new ComboBox ();
 777
 778                         box.Loaded += delegate { before++; };
 779                         TestPanel.Children.Add (box);
 780                         box.Loaded += delegate { after++; };
 781
 782                         Enqueue (() => {
 783                                 Assert.AreEqual (1, before, "#1");
 784                                 if (match_tick_numbers) {
 785                                         Assert.AreEqual (0, after, "#2");
 786                                 }
 787                                 box.ApplyTemplate ();
 788                                 TestPanel.Children.Clear ();
 789                         });
 790                         Enqueue (() => {
 791                                 Assert.AreEqual (1, before, "#3");
 792                                 Assert.AreEqual (1, after, "#4");
 793                         });
 794                         Enqueue (() => {
 795                                 // Make sure that the values really aren't changing
 796                                 Assert.AreEqual (1, before, "#5");
 797                                 Assert.AreEqual (1, after, "#6");
 798                         });
 799
 800                         EnqueueTestComplete ();
 801                 }
 802
 803                 [TestMethod]
 804                 [Asynchronous]
 805                 public void RemoveBeforeTemplateLoaded ()
 806                 {
 807                         int before = 0;
 808                         int after = 0;
 809                         ComboBox box = new ComboBox ();
 810
 811                         box.Loaded += delegate { before++; };
 812                         TestPanel.Children.Add (box);
 813                         box.Loaded += delegate { after++; };
 814                         TestPanel.Children.Clear ();
 815
 816                         Enqueue (() => {
 817                                 Assert.AreEqual (1, before, "#1");
 818                                 Assert.AreEqual (0, after, "#2");
 819                         });
 820                         Enqueue (() => {
 821                                 // Make sure that the second handler definitely hasn't being called
 822                                 Assert.AreEqual (1, before, "#3");
 823                                 Assert.AreEqual (0, after, "#4");
 824
 825                                 // Apply the template and see if this causes Loaded emission
 826                                 Assert.IsTrue (box.ApplyTemplate (), "#5");
 827                         });
 828                         Enqueue (() => {
 829                                 Assert.AreEqual (1, before, "#6");
 830                                 Assert.AreEqual (0, after, "#7");
 831                         });
 832
 833                         EnqueueTestComplete ();
 834                 }
 835         }
 836 }