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

   1 using System;
   2 using System.Net;
   3 using System.Windows;
   4 using System.Windows.Controls;
   5 using System.Windows.Documents;
   6 using System.Windows.Ink;
   7 using System.Windows.Input;
   8 using System.Windows.Media;
   9 using System.Windows.Media.Animation;
  10 using System.Windows.Shapes;
  11 using System.Collections.Generic;
  12 using Mono.Moonlight.UnitTesting;
  13 using Microsoft.VisualStudio.TestTools.UnitTesting;
  14 using System.Threading;
  15
  16 #pragma warning disable 414
  17 #pragma warning disable 219
  18
  19 namespace MoonTest.System.Windows
  20 {
  21         [TestClass ()]
  22         public class DependencyPropertyAttachedTest
  23         {
  24                 /*
  25                  * Declaring Type _ Property Name _ [index, not included in property name _] _ Property Type
  26                  */
  27                 private DependencyPropertyInfo Canvas_Custom_double;
  28                 private DependencyPropertyInfo Canvas_Custom_Canvas;
  29                 private DependencyPropertyInfo Canvas_Custom_CustomClass;
  30                 private DependencyPropertyInfo Canvas_Custom_CustomCanvasType;
  31
  32                 private DependencyPropertyInfo Canvas_Height_int;
  33                 private DependencyPropertyInfo Canvas_Height_double;
  34                 private DependencyPropertyInfo Canvas_Height_CustomClass;
  35                 private DependencyPropertyInfo Canvas_Height_CustomCanvasType;
  36
  37                 private DependencyPropertyInfo CustomClass_Height_int;
  38                 private DependencyPropertyInfo CustomClass_Height_double;
  39                 private DependencyPropertyInfo CustomClass_Height_CustomClass;
  40                 private DependencyPropertyInfo CustomClass_Height_CustomCanvasType;
  41
  42                 private DependencyPropertyInfo CustomCanvasType_Height_int;
  43                 private DependencyPropertyInfo CustomCanvasType_Height_double;
  44                 private DependencyPropertyInfo CustomCanvasType_Height_void;
  45                 private DependencyPropertyInfo CustomCanvasType_Height_Canvas;
  46                 private DependencyPropertyInfo CustomCanvasType_Height_CustomClass;
  47                 private DependencyPropertyInfo CustomCanvasType_Height_CustomCanvasType;
  48                 private DependencyPropertyInfo CustomCanvasType_Height_CustomInterface;
  49                 private DependencyPropertyInfo CustomCanvasType_Height_CustomStruct;
  50                 private DependencyPropertyInfo CustomCanvasType_Height_CustomEnum;
  51                 private DependencyPropertyInfo CustomCanvasType_Height_CustomDelegate;
  52                 private DependencyPropertyInfo CustomCanvasType_Height_CustomClassCtorA;
  53                 private DependencyPropertyInfo CustomCanvasType_Height_CustomClassCtorB;
  54
  55                 private DependencyPropertyInfo CustomCanvasType2_Height_double;
  56
  57                 // These are interesting because Height is already defined on FrameworkElement
  58                 private DependencyPropertyInfo FrameworkElement_Height_int;
  59                 private DependencyPropertyInfo FrameworkElement_Height_double;
  60                 private DependencyPropertyInfo FrameworkElement_Height_CustomClass;
  61
  62                 [TestMethod ()]
  63                 public void Register_NullParametersTest ()
  64                 {
  65                         Assert.Throws (delegate { DependencyProperty.RegisterAttached (null, typeof (int), typeof (Canvas), new PropertyMetadata (null)); }, typeof (ArgumentNullException));
  66                         Assert.Throws (delegate { DependencyProperty.RegisterAttached (string.Empty, typeof (int), typeof (Canvas), new PropertyMetadata (null)); }, typeof (ArgumentException));
  67                         Assert.Throws (delegate { DependencyProperty.RegisterAttached ("a", null, typeof (Canvas), new PropertyMetadata (null)); }, typeof (ArgumentNullException));
  68                         Assert.Throws (delegate { DependencyProperty.RegisterAttached ("a", typeof (int), null, new PropertyMetadata (null)); }, typeof (ArgumentNullException));
  69                         // null PropertyMetadata shouldn't throw.
  70                         DependencyProperty.RegisterAttached ("a", typeof (int), typeof (Canvas), null);
  71                 }
  72
  73                 [TestMethod ()]
  74                 public void Register_HuhTest1 ()
  75                 {
  76                         DependencyPropertyInfo info = new DependencyPropertyInfo ("Custom", typeof (InkPresenter), typeof (int), true);
  77                         DependencyProperty property = info.Property;
  78                         Canvas canvas = new Canvas ();
  79
  80                         canvas.GetValue (property); // This should throw, the property doesn't exist on the canvas.
  81
  82                         Assert.Throws (delegate { canvas.GetValue (InkPresenter.StrokesProperty); }, typeof (Exception)); // And this throws a catastrophic error.
  83                 }
  84
  85                 [TestMethod ()]
  86                 public void Check_Default ()
  87                 {
  88                         DependencyProperty property = DependencyProperty.Register ("MyProp", typeof (int), typeof(Rectangle), new PropertyMetadata (100));
  89                         Rectangle r = new Rectangle ();
  90                         r.SetValue (property, 10);
  91                         Assert.AreEqual (10, r.GetValue (property), "#1");
  92                         r.ClearValue (property);
  93                         Assert.AreEqual (100, r.GetValue (property), "#2");
  94                 }
  95
  96                 object triggered;
  97                 [TestMethod()]
  98                 public void Register_Callback()
  99                 {
 100                         ManualResetEvent handle = new ManualResetEvent(false);
 101                         DependencyProperty prop = DependencyProperty.Register("Callback", typeof(int), typeof(Rectangle),
 102                                                                                 new PropertyMetadata((PropertyChangedCallback)delegate { triggered = new object(); }));
 103                         Rectangle r = new Rectangle();
 104                         r.SetValue(prop, 5);
 105                         Assert.IsNotNull(triggered);
 106                 }
 107
 108                 [TestMethod ()]
 109                 public void Check_Default_Nullable ()
 110                 {
 111                         DependencyProperty property = DependencyProperty.Register ("MyPropNullable", typeof (int?), typeof(Rectangle), null);
 112                         Rectangle r = new Rectangle ();
 113                         r.SetValue (property, 10);
 114                         Assert.AreEqual (10, r.GetValue (property), "#1");
 115                         r.ClearValue (property);
 116                         Assert.AreEqual (null, r.GetValue (property), "#2");
 117                 }
 118
 119                 #region Canvas Custom
 120                 [TestMethod ()]
 121                 public void Register_Canvas_Custom_double ()
 122                 {
 123                         Canvas canvas = new Canvas ();
 124                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 125                         DependencyProperty property;
 126                         DependencyPropertyInfo info;
 127                         DependencyPropertyInfo.ChangedInfo changed_info;
 128                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 129                         object actual_value;
 130                         object previous_expected_value = (double) 0;
 131                         int iterations = 0;
 132                         int changes = 0;
 133
 134                         Canvas_Custom_double = new DependencyPropertyInfo ("Custom", typeof (Canvas), typeof (double), true);
 135                         info = Canvas_Custom_double;
 136
 137                         property = info.Property;
 138
 139                         Assert.AreEqual (0.0, (double) canvas.GetValue (property));
 140
 141                         Assert.AreEqual (0.0, (double) ink.GetValue (property));
 142
 143                         Assert.Throws (delegate { canvas.SetValue (property, 1); }, typeof (ArgumentException));
 144                         Assert.Throws (delegate { canvas.SetValue (property, ""); }, typeof (ArgumentException));
 145                         Assert.Throws (delegate { canvas.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 146                         Assert.Throws (delegate { canvas.SetValue (property, null); }, typeof (ArgumentException));
 147                         Assert.Throws (delegate { canvas.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 148
 149                         foreach (object expected_value in new object [] { 1.1 }) {
 150                                 iterations++;
 151
 152                                 canvas.SetValue (property, expected_value);
 153                                 actual_value = canvas.GetValue (property);
 154
 155                                 if ((double) expected_value != (double) previous_expected_value) {
 156                                         changes++;
 157                                         changed_info = info.Changes [info.Changes.Count - 1];
 158                                         Assert.AreEqual ((double) changed_info.args.OldValue, (double) previous_expected_value);
 159                                         Assert.AreEqual ((double) changed_info.args.NewValue, (double) expected_value);
 160                                         Assert.AreSame (changed_info.obj, canvas);
 161                                 }
 162
 163                                 previous_expected_value = expected_value;
 164
 165                                 Assert.AreEqual ((double) expected_value, (double) actual_value, "Iteration #{0}", iterations);
 166                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 167                         }
 168                 }
 169
 170                 [TestMethod ()]
 171                 public void Register_Canvas_Custom_CustomClass ()
 172                 {
 173                         Canvas_Custom_CustomClass = new DependencyPropertyInfo ("Custom", typeof (Canvas), typeof (CustomClass), true);
 174                 }
 175
 176                 [TestMethod ()]
 177                 public void Register_Canvas_Custom_Canvas ()
 178                 {
 179                         Canvas canvas = new Canvas ();
 180                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 181                         DependencyProperty property;
 182                         DependencyPropertyInfo info;
 183                         DependencyPropertyInfo.ChangedInfo changed_info;
 184                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 185                         object actual_value;
 186                         object previous_expected_value = null;
 187                         int iterations = 0;
 188                         int changes = 0;
 189
 190                         Canvas_Custom_Canvas = new DependencyPropertyInfo ("Custom", typeof (Canvas), typeof (Canvas), true);
 191                         info = Canvas_Custom_Canvas;
 192
 193                         property = info.Property;
 194
 195                         Assert.IsNull (canvas.GetValue (property));
 196                         Assert.IsNull (ink.GetValue (property));
 197
 198                         Assert.Throws (delegate { canvas.SetValue (property, 1); }, typeof (ArgumentException));
 199                         Assert.Throws (delegate { canvas.SetValue (property, ""); }, typeof (ArgumentException));
 200                         Assert.Throws (delegate { canvas.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 201
 202                         foreach (object expected_value in new object [] { null, new Canvas (), null, canvas, canvas, null, new CustomCanvasType (), custom_canvas, custom_canvas, ink }) {
 203                                 iterations++;
 204
 205                                 canvas.SetValue (property, expected_value);
 206                                 actual_value = canvas.GetValue (property);
 207
 208                                 if (expected_value != previous_expected_value) {
 209                                         changes++;
 210                                         changed_info = info.Changes [info.Changes.Count - 1];
 211                                         Assert.AreSame (changed_info.args.OldValue, previous_expected_value);
 212                                         Assert.AreSame (changed_info.args.NewValue, expected_value);
 213                                         Assert.AreSame (changed_info.obj, canvas);
 214                                 }
 215
 216                                 previous_expected_value = expected_value;
 217
 218                                 Assert.AreSame (expected_value, actual_value, "Iteration #{0}", iterations);
 219                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 220                         }
 221                 }
 222
 223                 [TestMethod ()]
 224                 public void Register_Canvas_Custom_CustomCanvasType ()
 225                 {
 226                         Canvas_Custom_CustomCanvasType = new DependencyPropertyInfo ("Custom", typeof (Canvas), typeof (CustomCanvasType), true);
 227                 }
 228                 #endregion
 229                 #region Canvas Height
 230                 [TestMethod ()]
 231                 public void Register_Canvas_Height_int ()
 232                 {
 233                         // Register a custom property with the same name and type as an existing builtin property
 234                         Canvas_Height_int = new DependencyPropertyInfo ("Height", typeof (Canvas), typeof (int), true);
 235                 }
 236
 237                 [TestMethod ()]
 238                 public void Register_Canvas_Height_double ()
 239                 {
 240                         // Register a custom property with the same name and type as an existing builtin property
 241                         Canvas_Height_double = new DependencyPropertyInfo ("Height", typeof (Canvas), typeof (double), true);
 242                 }
 243
 244                 [TestMethod ()]
 245                 public void Register_Canvas_Height_CustomClass ()
 246                 {
 247                         // Register a custom property with the same name (but not type) as an existing builtin AND another custom property
 248                         Canvas_Height_CustomClass = new DependencyPropertyInfo ("Height", typeof (Canvas), typeof (CustomClass), true);
 249                 }
 250
 251                 [TestMethod ()]
 252                 public void Register_Canvas_Height_CustomCanvasType ()
 253                 {
 254                         // Register a custom property with the same name (but not type) as an existing builtin AND another custom property
 255                         Canvas_Height_CustomCanvasType = new DependencyPropertyInfo ("Height", typeof (Canvas), typeof (CustomCanvasType), true);
 256                 }
 257                 #endregion
 258                 #region CustomClass Height
 259                 [TestMethod ()]
 260                 public void Register_CustomClass_Height_int ()
 261                 {
 262                         CustomClass_Height_int = new DependencyPropertyInfo ("Height", typeof (CustomClass), typeof (int), true);
 263                 }
 264
 265                 [TestMethod ()]
 266                 public void Register_CustomClass_Height_double ()
 267                 {
 268                         CustomClass_Height_double = new DependencyPropertyInfo ("Height", typeof (CustomClass), typeof (double), true);
 269                 }
 270
 271                 [TestMethod ()]
 272                 public void Register_CustomClass_Height_CustomClass ()
 273                 {
 274                         CustomClass_Height_CustomClass = new DependencyPropertyInfo ("Height", typeof (CustomClass), typeof (CustomClass), true);
 275                 }
 276
 277                 [TestMethod ()]
 278                 public void Register_CustomClass_Height_CustomCanvasType ()
 279                 {
 280                         CustomClass_Height_CustomCanvasType = new DependencyPropertyInfo ("Height", typeof (CustomClass), typeof (CustomCanvasType), true);
 281                 }
 282                 #endregion
 283                 #region CustomCanvasType Height
 284                 [TestMethod ()]
 285                 public void Register_CustomCanvasType_Height_int ()
 286                 {
 287                         CustomCanvasType the_object = new CustomCanvasType ();
 288                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 289                         Canvas canvas = new Canvas ();
 290                         DependencyProperty property;
 291                         DependencyPropertyInfo info;
 292                         DependencyPropertyInfo.ChangedInfo changed_info;
 293                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 294                         object actual_value;
 295                         object previous_expected_value = (int) 0;
 296                         int iterations = 0;
 297                         int changes = 0;
 298
 299                         CustomCanvasType_Height_int = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (int), true);
 300                         info = CustomCanvasType_Height_int;
 301
 302                         property = info.Property;
 303
 304                         Assert.AreEqual (0, (int) the_object.GetValue (property));
 305                         Assert.AreEqual (0, (int) ink.GetValue (property));
 306
 307                         Assert.Throws (delegate { the_object.SetValue (property, 1.1); }, typeof (ArgumentException));
 308                         Assert.Throws (delegate { the_object.SetValue (property, "1"); }, typeof (ArgumentException));
 309                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 310                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 311                         Assert.Throws (delegate { the_object.SetValue (property, null); }, typeof (ArgumentException));
 312                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 313
 314                         foreach (object expected_value in new object [] { 1, 1, 2 }) {
 315                                 iterations++;
 316
 317                                 the_object.SetValue (property, expected_value);
 318                                 actual_value = the_object.GetValue (property);
 319
 320                                 if ((int) expected_value != (int) previous_expected_value) {
 321                                         changes++;
 322                                         changed_info = info.Changes [info.Changes.Count - 1];
 323                                         Assert.AreEqual ((int) changed_info.args.OldValue, (int) previous_expected_value);
 324                                         Assert.AreEqual ((int) changed_info.args.NewValue, (int) expected_value);
 325                                         Assert.AreSame (changed_info.obj, the_object);
 326                                 }
 327
 328                                 previous_expected_value = expected_value;
 329
 330                                 Assert.AreEqual ((int) expected_value, (int) actual_value, "Iteration #{0}", iterations);
 331                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 332                         }
 333                 }
 334
 335                 [TestMethod ()]
 336                 public void Register_CustomCanvasType_Height_double ()
 337                 {
 338                         CustomCanvasType the_object = new CustomCanvasType ();
 339                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 340                         Canvas canvas = new Canvas ();
 341                         DependencyProperty property;
 342                         DependencyPropertyInfo info;
 343                         DependencyPropertyInfo.ChangedInfo changed_info;
 344                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 345                         object actual_value;
 346                         object previous_expected_value = (double) 0;
 347                         int iterations = 0;
 348                         int changes = 0;
 349
 350                         CustomCanvasType_Height_double = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (double), true);
 351                         info = CustomCanvasType_Height_double;
 352
 353                         property = info.Property;
 354
 355                         Assert.AreEqual (0.0, (double) the_object.GetValue (property));
 356                         Assert.AreEqual (0.0, (double) ink.GetValue (property));
 357
 358                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 359                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 360                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 361                         Assert.Throws (delegate { the_object.SetValue (property, null); }, typeof (ArgumentException));
 362                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 363
 364                         foreach (object expected_value in new object [] { 1.1, 1.1, 2.2 }) {
 365                                 iterations++;
 366
 367                                 the_object.SetValue (property, expected_value);
 368                                 actual_value = the_object.GetValue (property);
 369
 370                                 if ((double) expected_value != (double) previous_expected_value) {
 371                                         changes++;
 372                                         changed_info = info.Changes [info.Changes.Count - 1];
 373                                         Assert.AreEqual ((double) changed_info.args.OldValue, (double) previous_expected_value);
 374                                         Assert.AreEqual ((double) changed_info.args.NewValue, (double) expected_value);
 375                                         Assert.AreSame (changed_info.obj, the_object);
 376                                 }
 377
 378                                 previous_expected_value = expected_value;
 379
 380                                 Assert.AreEqual ((double) expected_value, (double) actual_value, "Iteration #{0}", iterations);
 381                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 382                         }
 383                 }
 384
 385                 [TestMethod ()]
 386                 public void Register_CustomCanvasType_Height_void ()
 387                 {
 388                         Assert.Throws (delegate { CustomCanvasType_Height_void = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (void), true); }, typeof (NotSupportedException));
 389                 }
 390
 391                 [TestMethod ()]
 392                 public void Register_CustomCanvasType_Height_Canvas ()
 393                 {
 394                         CustomCanvasType_Height_Canvas = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (Canvas), true);
 395                 }
 396
 397                 [TestMethod ()]
 398                 public void Register_CustomCanvasType_Height_CustomClass ()
 399                 {
 400                         CustomCanvasType_Height_CustomClass = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomClass), true);
 401                 }
 402
 403                 [TestMethod ()]
 404                 public void Register_CustomCanvasType_Height_CustomCanvasType ()
 405                 {
 406                         CustomCanvasType_Height_CustomCanvasType = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomCanvasType), true);
 407                 }
 408
 409                 [TestMethod ()]
 410                 public void Register_CustomCanvasType_Height_CustomInterface ()
 411                 {
 412                         CustomCanvasType the_object = new CustomCanvasType ();
 413                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 414                         Canvas canvas = new Canvas ();
 415                         CustomStruct custom_struct_1 = new CustomStruct (1);
 416                         CustomEnum custom_enum = CustomEnum.EnumValue1;
 417                         CustomDelegate custom_delegate = delegate { };
 418                         CustomInterface custom_interface_a = new CustomInterfaceImplA ();
 419                         CustomInterface custom_interface_b = new CustomInterfaceImplB ();
 420                         DependencyProperty property;
 421                         DependencyPropertyInfo info;
 422                         DependencyPropertyInfo.ChangedInfo changed_info;
 423                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 424                         object actual_value;
 425                         object previous_expected_value = null;
 426                         int iterations = 0;
 427                         int changes = 0;
 428
 429                         CustomCanvasType_Height_CustomInterface = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomInterface), true);
 430                         info = CustomCanvasType_Height_CustomInterface;
 431
 432                         property = info.Property;
 433
 434                         Assert.AreEqual (null, the_object.GetValue (property), "Default value 1");
 435                         Assert.AreEqual (null, ink.GetValue (property), "Default value 2");
 436
 437                         Assert.Throws (delegate { the_object.SetValue (property, 0); }, typeof (ArgumentException));
 438                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 439                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 440                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 441                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 442                         Assert.Throws (delegate { the_object.SetValue (property, custom_enum); }, typeof (ArgumentException));
 443
 444                         foreach (object expected_value in new object [] { null, custom_interface_a, null, custom_interface_b, custom_interface_b, null }) {
 445                                 iterations++;
 446
 447                                 the_object.SetValue (property, expected_value);
 448                                 actual_value = the_object.GetValue (property);
 449
 450                                 if (!object.Equals (expected_value, previous_expected_value)) {
 451                                         changes++;
 452                                         changed_info = info.Changes [info.Changes.Count - 1];
 453                                         Assert.AreEqual (changed_info.args.OldValue, previous_expected_value, "OldValue");
 454                                         Assert.AreEqual (changed_info.args.NewValue, expected_value, "NewValue");
 455                                         Assert.AreSame (changed_info.obj, the_object);
 456                                 }
 457
 458                                 previous_expected_value = expected_value;
 459
 460                                 Assert.AreEqual (expected_value, actual_value, "Iteration #{0}", iterations);
 461                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 462                         }
 463                 }
 464
 465                 [TestMethod ()]
 466                 public void Register_CustomCanvasType_Height_CustomStruct ()
 467                 {
 468                         CustomCanvasType the_object = new CustomCanvasType ();
 469                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 470                         Canvas canvas = new Canvas ();
 471                         CustomStruct custom_struct_1 = new CustomStruct (1);
 472                         DependencyProperty property;
 473                         DependencyPropertyInfo info;
 474                         DependencyPropertyInfo.ChangedInfo changed_info;
 475                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 476                         object actual_value;
 477                         object previous_expected_value = new CustomStruct ();
 478                         int iterations = 0;
 479                         int changes = 0;
 480
 481                         CustomCanvasType_Height_CustomStruct = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomStruct), true);
 482                         info = CustomCanvasType_Height_CustomStruct;
 483
 484                         property = info.Property;
 485
 486                         Assert.AreEqual (new CustomStruct (), (CustomStruct) the_object.GetValue (property));
 487                         Assert.AreEqual (new CustomStruct (), (CustomStruct) ink.GetValue (property));
 488
 489                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 490                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 491                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 492                         Assert.Throws (delegate { the_object.SetValue (property, null); }, typeof (ArgumentException));
 493                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 494
 495                         foreach (object expected_value in new object [] { custom_struct_1, custom_struct_1, new CustomStruct (), new CustomStruct () }) {
 496                                 iterations++;
 497
 498                                 the_object.SetValue (property, expected_value);
 499                                 actual_value = the_object.GetValue (property);
 500
 501                                 if (!object.Equals (expected_value, previous_expected_value)) {
 502                                         changes++;
 503                                         changed_info = info.Changes [info.Changes.Count - 1];
 504                                         Assert.AreEqual (changed_info.args.OldValue, previous_expected_value);
 505                                         Assert.AreEqual (changed_info.args.NewValue, expected_value);
 506                                         Assert.AreSame (changed_info.obj, the_object);
 507                                 }
 508
 509                                 previous_expected_value = expected_value;
 510
 511                                 Assert.AreEqual (expected_value, actual_value, "Iteration #{0}", iterations);
 512                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 513                         }
 514                 }
 515
 516                 [TestMethod ()]
 517                 public void Register_CustomCanvasType_Height_CustomEnum ()
 518                 {
 519                         CustomCanvasType the_object = new CustomCanvasType ();
 520                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 521                         Canvas canvas = new Canvas ();
 522                         CustomStruct custom_struct_1 = new CustomStruct (1);
 523                         CustomEnum custom_enum = CustomEnum.EnumValue1;
 524                         DependencyProperty property;
 525                         DependencyPropertyInfo info;
 526                         DependencyPropertyInfo.ChangedInfo changed_info;
 527                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 528                         object actual_value;
 529                         object previous_expected_value = (CustomEnum) 0;
 530                         int iterations = 0;
 531                         int changes = 0;
 532
 533                         CustomCanvasType_Height_CustomEnum = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomEnum), true);
 534                         info = CustomCanvasType_Height_CustomEnum;
 535
 536                         property = info.Property;
 537
 538                         Assert.AreEqual ((CustomEnum) 0, the_object.GetValue (property), "Default value 1");
 539                         Assert.AreEqual ((CustomEnum) 0, ink.GetValue (property), "Default value 2");
 540
 541                         Assert.Throws (delegate { the_object.SetValue (property, 0); }, typeof (ArgumentException));
 542                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 543                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 544                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 545                         Assert.Throws (delegate { the_object.SetValue (property, null); }, typeof (ArgumentException));
 546                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 547
 548                         foreach (object expected_value in new object [] { CustomEnum.EnumValue1, CustomEnum.EnumValue1, CustomEnum.EnumValue2, (CustomEnum) 0, custom_enum, custom_enum }) {
 549                                 iterations++;
 550
 551                                 the_object.SetValue (property, expected_value);
 552                                 actual_value = the_object.GetValue (property);
 553
 554                                 if (!object.Equals (expected_value, previous_expected_value)) {
 555                                         changes++;
 556                                         changed_info = info.Changes [info.Changes.Count - 1];
 557                                         Assert.AreEqual (changed_info.args.OldValue, previous_expected_value, "OldValue");
 558                                         Assert.AreEqual (changed_info.args.NewValue, expected_value, "NewValue");
 559                                         Assert.AreSame (changed_info.obj, the_object);
 560                                 }
 561
 562                                 previous_expected_value = expected_value;
 563
 564                                 Assert.AreEqual (expected_value, actual_value, "Iteration #{0}", iterations);
 565                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 566                         }
 567                 }
 568
 569                 [TestMethod ()]
 570                 public void Register_CustomCanvasType_Height_CustomDelegate ()
 571                 {
 572                         CustomCanvasType the_object = new CustomCanvasType ();
 573                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 574                         Canvas canvas = new Canvas ();
 575                         CustomStruct custom_struct_1 = new CustomStruct (1);
 576                         CustomEnum custom_enum = CustomEnum.EnumValue1;
 577                         CustomDelegate custom_delegate = delegate { };
 578                         DependencyProperty property;
 579                         DependencyPropertyInfo info;
 580                         DependencyPropertyInfo.ChangedInfo changed_info;
 581                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 582                         object actual_value;
 583                         object previous_expected_value = null;
 584                         int iterations = 0;
 585                         int changes = 0;
 586
 587                         CustomCanvasType_Height_CustomDelegate = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomDelegate), true);
 588                         info = CustomCanvasType_Height_CustomDelegate;
 589
 590                         property = info.Property;
 591
 592                         Assert.AreEqual (null, the_object.GetValue (property), "Default value 1");
 593                         Assert.AreEqual (null, ink.GetValue (property), "Default value 2");
 594
 595                         Assert.Throws (delegate { the_object.SetValue (property, 0); }, typeof (ArgumentException));
 596                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 597                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 598                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 599                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 600
 601                         foreach (object expected_value in new CustomDelegate [] { null, delegate { }, delegate { }, custom_delegate, custom_delegate }) {
 602                                 iterations++;
 603
 604                                 the_object.SetValue (property, expected_value);
 605                                 actual_value = the_object.GetValue (property);
 606
 607                                 if (!object.Equals (expected_value, previous_expected_value)) {
 608                                         changes++;
 609                                         changed_info = info.Changes [info.Changes.Count - 1];
 610                                         Assert.AreEqual (changed_info.args.OldValue, previous_expected_value, "OldValue");
 611                                         Assert.AreEqual (changed_info.args.NewValue, expected_value, "NewValue");
 612                                         Assert.AreSame (changed_info.obj, the_object);
 613                                 }
 614
 615                                 previous_expected_value = expected_value;
 616
 617                                 Assert.AreEqual (expected_value, actual_value, "Iteration #{0}", iterations);
 618                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 619                         }
 620                 }
 621
 622                 [TestMethod ()]
 623                 public void Register_CustomCanvasType_Height_CustomClassCtorA ()
 624                 {
 625                         CustomCanvasType_Height_CustomClassCtorA = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomClassCtorA), true);
 626                 }
 627
 628                 [TestMethod ()]
 629                 public void Register_CustomCanvasType_Height_CustomClassCtorB ()
 630                 {
 631                         CustomCanvasType_Height_CustomClassCtorB = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType), typeof (CustomClassCtorB), true);
 632                 }
 633
 634                 ///////////////////////////////////////////////////////
 635
 636                 #endregion
 637                 #region CustomCanvasType2 Height
 638
 639                 [TestMethod ()]
 640                 public void Register_CustomCanvasType2_Height_double ()
 641                 {
 642                         CustomCanvasType2 the_object = new CustomCanvasType2 ();
 643                         CustomCanvasType custom_canvas = new CustomCanvasType ();
 644                         Canvas canvas = new Canvas ();
 645                         DependencyProperty property;
 646                         DependencyPropertyInfo info;
 647                         DependencyPropertyInfo.ChangedInfo changed_info;
 648                         InkPresenter ink = new InkPresenter (); // The only builtin type derived from Canvas
 649                         object actual_value;
 650                         object previous_expected_value = (double) 0;
 651                         int iterations = 0;
 652                         int changes = 0;
 653
 654                         CustomCanvasType2_Height_double = new DependencyPropertyInfo ("Height", typeof (CustomCanvasType2), typeof (double), true);
 655                         info = CustomCanvasType2_Height_double;
 656
 657                         property = info.Property;
 658
 659                         Assert.AreEqual (0.0, (double) the_object.GetValue (property));
 660                         Assert.AreEqual (0.0, (double) ink.GetValue (property));
 661                         Assert.AreEqual (0.0, (double) custom_canvas.GetValue (property));
 662
 663                         Assert.Throws (delegate { the_object.SetValue (property, 1); }, typeof (ArgumentException));
 664                         Assert.Throws (delegate { the_object.SetValue (property, ""); }, typeof (ArgumentException));
 665                         Assert.Throws (delegate { the_object.SetValue (property, new CustomClass ()); }, typeof (ArgumentException));
 666                         Assert.Throws (delegate { the_object.SetValue (property, null); }, typeof (ArgumentException));
 667                         Assert.Throws (delegate { the_object.SetValue (property, new Canvas ()); }, typeof (ArgumentException));
 668
 669                         //Assert.Throws (delegate { custom_canvas.SetValue (property, 1.1); }, typeof (ArgumentException));
 670
 671                         foreach (object expected_value in new object [] { 1.1 }) {
 672                                 iterations++;
 673
 674                                 the_object.SetValue (property, expected_value);
 675                                 actual_value = the_object.GetValue (property);
 676
 677                                 if ((double) expected_value != (double) previous_expected_value) {
 678                                         changes++;
 679                                         changed_info = info.Changes [info.Changes.Count - 1];
 680                                         Assert.AreEqual ((double) changed_info.args.OldValue, (double) previous_expected_value);
 681                                         Assert.AreEqual ((double) changed_info.args.NewValue, (double) expected_value);
 682                                         Assert.AreSame (changed_info.obj, the_object);
 683                                 }
 684
 685                                 previous_expected_value = expected_value;
 686
 687                                 Assert.AreEqual ((double) expected_value, (double) actual_value, "Iteration #{0}", iterations);
 688                                 Assert.AreEqual (changes, info.Changes.Count, "Iteration #{0} there should be {1} changes, but there were {2} changes", iterations, changes, info.Changes.Count);
 689                         }
 690                 }
 691                 #endregion
 692                 #region FrameworkElement Height
 693                 [TestMethod ()]
 694                 public void Register_FrameworkElement_Height_int ()
 695                 {
 696                         FrameworkElement_Height_int = new DependencyPropertyInfo ("Height", typeof (FrameworkElement), typeof (int), true);
 697                 }
 698
 699                 [TestMethod ()]
 700                 public void Register_FrameworkElement_Height_double ()
 701                 {
 702                         FrameworkElement_Height_double = new DependencyPropertyInfo ("Height", typeof (FrameworkElement), typeof (double), true);
 703                 }
 704
 705                 [TestMethod ()]
 706                 public void Register_FrameworkElement_Height_CustomClass ()
 707                 {
 708                         FrameworkElement_Height_CustomClass = new DependencyPropertyInfo ("Height", typeof (FrameworkElement), typeof (CustomClass), true);
 709                 }
 710                 #endregion
 711
 712                 #region Custom types, etc
 713                 public class CustomCanvasType : Canvas
 714                 {
 715                 }
 716                 public class CustomCanvasType2 : Canvas
 717                 {
 718                 }
 719                 public class CustomDerivedClass : CustomClass
 720                 {
 721                 }
 722
 723                 public class CustomClass
 724                 {
 725                 }
 726                 public struct CustomStruct
 727                 {
 728                         public int value;
 729
 730                         public CustomStruct (int v) { this.value = v; }
 731
 732                         public override string ToString ()
 733                         {
 734                                 return "<CustomStruct (" + value.ToString () + ")>";
 735                         }
 736                 }
 737                 public interface CustomInterface
 738                 {
 739                         void Method ();
 740                 }
 741                 public class CustomInterfaceImplA : CustomInterface
 742                 {
 743                         public void Method ()
 744                         {
 745                                 throw new NotImplementedException ();
 746                         }
 747                 }
 748                 public class CustomInterfaceImplB : CustomInterface
 749                 {
 750                         public void Method ()
 751                         {
 752                                 throw new NotImplementedException ();
 753                         }
 754                 }
 755
 756                 public delegate void CustomDelegate ();
 757                 public enum CustomEnum
 758                 {
 759                         EnumValue1 = 1,
 760                         EnumValue2 = 2
 761                 }
 762                 // A class with no default ctor
 763                 public class CustomClassCtorA
 764                 {
 765                         public CustomClassCtorA (string an_argument) { }
 766                 }
 767                 // A class with a private default ctor
 768                 public class CustomClassCtorB
 769                 {
 770                         private CustomClassCtorB () { }
 771                 }
 772                 #endregion
 773         }
 774 }