1 // 2 // Copyright (C) 2010 Novell Inc. http://novell.com 3 // 4 // Permission is hereby granted, free of charge, to any person obtaining 5 // a copy of this software and associated documentation files (the 6 // "Software"), to deal in the Software without restriction, including 7 // without limitation the rights to use, copy, modify, merge, publish, 8 // distribute, sublicense, and/or sell copies of the Software, and to 9 // permit persons to whom the Software is furnished to do so, subject to 10 // the following conditions: 11 // 12 // The above copyright notice and this permission notice shall be 13 // included in all copies or substantial portions of the Software. 14 // 15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 22 // 23 using System; 24 using System.Collections; 25 using System.Collections.Generic; 26 using System.ComponentModel; 27 using System.Linq; 28 using System.Reflection; 29 using System.Windows.Markup; 30 using System.Xaml; 31 using System.Xaml.Schema; 32 using System.Xml; 33 using NUnit.Framework; 34 35 using CategoryAttribute = NUnit.Framework.CategoryAttribute; 36 37 namespace MonoTests.System.Xaml 38 { 39 [TestFixture] 40 public class XamlLanguageTest 41 { 42 [Test] XamlNamepaces()43 public void XamlNamepaces () 44 { 45 var l = XamlLanguage.XamlNamespaces; 46 Assert.AreEqual (1, l.Count, "#1"); 47 Assert.AreEqual (XamlLanguage.Xaml2006Namespace, l [0], "#2"); 48 } 49 50 [Test] XmlNamepaces()51 public void XmlNamepaces () 52 { 53 var l = XamlLanguage.XmlNamespaces; 54 Assert.AreEqual (1, l.Count, "#1"); 55 Assert.AreEqual (XamlLanguage.Xml1998Namespace, l [0], "#2"); 56 } 57 58 [Test] AllDirectives()59 public void AllDirectives () 60 { 61 var l = XamlLanguage.AllDirectives; 62 Assert.AreEqual (24, l.Count, "count"); 63 Assert.IsTrue (l.Contains (XamlLanguage.Arguments), "#0"); 64 Assert.IsTrue (l.Contains (XamlLanguage.AsyncRecords), "#1"); 65 Assert.IsTrue (l.Contains (XamlLanguage.Base), "#2"); 66 Assert.IsTrue (l.Contains (XamlLanguage.Class), "#3"); 67 Assert.IsTrue (l.Contains (XamlLanguage.ClassAttributes), "#4"); 68 Assert.IsTrue (l.Contains (XamlLanguage.ClassModifier), "#5"); 69 Assert.IsTrue (l.Contains (XamlLanguage.Code), "#6"); 70 Assert.IsTrue (l.Contains (XamlLanguage.ConnectionId), "#7"); 71 Assert.IsTrue (l.Contains (XamlLanguage.FactoryMethod), "#8"); 72 Assert.IsTrue (l.Contains (XamlLanguage.FieldModifier), "#9"); 73 Assert.IsTrue (l.Contains (XamlLanguage.Initialization), "#10"); 74 Assert.IsTrue (l.Contains (XamlLanguage.Items), "#11"); 75 Assert.IsTrue (l.Contains (XamlLanguage.Key), "#12"); 76 Assert.IsTrue (l.Contains (XamlLanguage.Lang), "#13"); 77 Assert.IsTrue (l.Contains (XamlLanguage.Members), "#14"); 78 Assert.IsTrue (l.Contains (XamlLanguage.Name), "#15"); 79 Assert.IsTrue (l.Contains (XamlLanguage.PositionalParameters), "#16"); 80 Assert.IsTrue (l.Contains (XamlLanguage.Space), "#17"); 81 Assert.IsTrue (l.Contains (XamlLanguage.Subclass), "#18"); 82 Assert.IsTrue (l.Contains (XamlLanguage.SynchronousMode), "#19"); 83 Assert.IsTrue (l.Contains (XamlLanguage.Shared), "#20"); 84 Assert.IsTrue (l.Contains (XamlLanguage.TypeArguments), "#21"); 85 Assert.IsTrue (l.Contains (XamlLanguage.Uid), "#22"); 86 Assert.IsTrue (l.Contains (XamlLanguage.UnknownContent), "#23"); 87 } 88 89 [Test] AllTypes()90 public void AllTypes () 91 { 92 var l = XamlLanguage.AllTypes; 93 Assert.AreEqual (21, l.Count, "count"); 94 Assert.IsTrue (l.Contains (XamlLanguage.Array), "#0"); 95 Assert.IsTrue (l.Contains (XamlLanguage.Boolean), "#1"); 96 Assert.IsTrue (l.Contains (XamlLanguage.Byte), "#2"); 97 Assert.IsTrue (l.Contains (XamlLanguage.Char), "#3"); 98 Assert.IsTrue (l.Contains (XamlLanguage.Decimal), "#4"); 99 Assert.IsTrue (l.Contains (XamlLanguage.Double), "#5"); 100 Assert.IsTrue (l.Contains (XamlLanguage.Int16), "#6"); 101 Assert.IsTrue (l.Contains (XamlLanguage.Int32), "#7"); 102 Assert.IsTrue (l.Contains (XamlLanguage.Int64), "#8"); 103 Assert.IsTrue (l.Contains (XamlLanguage.Member), "#9"); 104 Assert.IsTrue (l.Contains (XamlLanguage.Null), "#10"); 105 Assert.IsTrue (l.Contains (XamlLanguage.Object), "#11"); 106 Assert.IsTrue (l.Contains (XamlLanguage.Property), "#12"); 107 Assert.IsTrue (l.Contains (XamlLanguage.Reference), "#13"); 108 Assert.IsTrue (l.Contains (XamlLanguage.Single), "#14"); 109 Assert.IsTrue (l.Contains (XamlLanguage.Static), "#15"); 110 Assert.IsTrue (l.Contains (XamlLanguage.String), "#16"); 111 Assert.IsTrue (l.Contains (XamlLanguage.TimeSpan), "#17"); 112 Assert.IsTrue (l.Contains (XamlLanguage.Type), "#18"); 113 Assert.IsTrue (l.Contains (XamlLanguage.Uri), "#19"); 114 Assert.IsTrue (l.Contains (XamlLanguage.XData), "#20"); 115 } 116 117 // directive property details 118 119 [Test] Arguments()120 public void Arguments () 121 { 122 var d = XamlLanguage.Arguments; 123 TestXamlDirectiveCommon (d, "Arguments", AllowedMemberLocations.Any, typeof (List<object>)); 124 } 125 126 [Test] AsyncRecords()127 public void AsyncRecords () 128 { 129 var d = XamlLanguage.AsyncRecords; 130 TestXamlDirectiveCommon (d, "AsyncRecords", AllowedMemberLocations.Attribute, typeof (string)); 131 } 132 133 [Test] Base()134 public void Base () 135 { 136 var d = XamlLanguage.Base; 137 TestXamlDirectiveCommon (d, "base", XamlLanguage.Xml1998Namespace, AllowedMemberLocations.Attribute, typeof (string)); 138 } 139 140 [Test] Class()141 public void Class () 142 { 143 var d = XamlLanguage.Class; 144 TestXamlDirectiveCommon (d, "Class", AllowedMemberLocations.Attribute, typeof (string)); 145 } 146 147 [Test] ClassAttributes()148 public void ClassAttributes () 149 { 150 var d = XamlLanguage.ClassAttributes; 151 TestXamlDirectiveCommon (d, "ClassAttributes", AllowedMemberLocations.MemberElement, typeof (List<Attribute>)); 152 } 153 154 [Test] ClassModifier()155 public void ClassModifier () 156 { 157 var d = XamlLanguage.ClassModifier; 158 TestXamlDirectiveCommon (d, "ClassModifier", AllowedMemberLocations.Attribute, typeof (string)); 159 } 160 161 [Test] Code()162 public void Code () 163 { 164 var d = XamlLanguage.Code; 165 TestXamlDirectiveCommon (d, "Code", AllowedMemberLocations.Attribute, typeof (string)); 166 } 167 168 [Test] ConnectionId()169 public void ConnectionId () 170 { 171 var d = XamlLanguage.ConnectionId; 172 TestXamlDirectiveCommon (d, "ConnectionId", AllowedMemberLocations.Any, typeof (string)); 173 } 174 175 [Test] FactoryMethod()176 public void FactoryMethod () 177 { 178 var d = XamlLanguage.FactoryMethod; 179 TestXamlDirectiveCommon (d, "FactoryMethod", AllowedMemberLocations.Any, typeof (string)); 180 } 181 182 [Test] FieldModifier()183 public void FieldModifier () 184 { 185 var d = XamlLanguage.FieldModifier; 186 TestXamlDirectiveCommon (d, "FieldModifier", AllowedMemberLocations.Attribute, typeof (string)); 187 } 188 189 [Test] Initialization()190 public void Initialization () 191 { 192 var d = XamlLanguage.Initialization; 193 // weird name 194 TestXamlDirectiveCommon (d, "_Initialization", AllowedMemberLocations.Any, typeof (object)); 195 } 196 197 [Test] 198 [ExpectedException (typeof (NotSupportedException))] InitializationGetValue()199 public void InitializationGetValue () 200 { 201 XamlLanguage.Initialization.Invoker.GetValue ("foo"); 202 } 203 204 [Test] Items()205 public void Items () 206 { 207 var d = XamlLanguage.Items; 208 // weird name 209 TestXamlDirectiveCommon (d, "_Items", AllowedMemberLocations.Any, typeof (List<object>)); 210 } 211 212 [Test] Key()213 public void Key () 214 { 215 var d = XamlLanguage.Key; 216 TestXamlDirectiveCommon (d, "Key", AllowedMemberLocations.Any, typeof (object)); 217 } 218 219 [Test] Lang()220 public void Lang () 221 { 222 var d = XamlLanguage.Lang; 223 TestXamlDirectiveCommon (d, "lang", XamlLanguage.Xml1998Namespace, AllowedMemberLocations.Attribute, typeof (string)); 224 } 225 226 [Test] Members()227 public void Members () 228 { 229 var d = XamlLanguage.Members; 230 TestXamlDirectiveCommon (d, "Members", AllowedMemberLocations.MemberElement, typeof (List<MemberDefinition>)); 231 } 232 233 [Test] Name()234 public void Name () 235 { 236 var d = XamlLanguage.Name; 237 TestXamlDirectiveCommon (d, "Name", AllowedMemberLocations.Attribute, typeof (string)); 238 } 239 240 [Test] PositionalParameters()241 public void PositionalParameters () 242 { 243 var d = XamlLanguage.PositionalParameters; 244 // weird name 245 TestXamlDirectiveCommon (d, "_PositionalParameters", AllowedMemberLocations.Any, typeof (List<object>)); 246 // LAMESPEC: In [MS-XAML-2009] AllowedLocations is None, unlike this Any value. 247 } 248 249 [Test] Subclass()250 public void Subclass () 251 { 252 var d = XamlLanguage.Subclass; 253 TestXamlDirectiveCommon (d, "Subclass", AllowedMemberLocations.Attribute, typeof (string)); 254 } 255 256 [Test] SynchronousMode()257 public void SynchronousMode () 258 { 259 var d = XamlLanguage.SynchronousMode; 260 TestXamlDirectiveCommon (d, "SynchronousMode", AllowedMemberLocations.Attribute, typeof (string)); 261 } 262 263 [Test] Shared()264 public void Shared () 265 { 266 var d = XamlLanguage.Shared; 267 TestXamlDirectiveCommon (d, "Shared", AllowedMemberLocations.Attribute, typeof (string)); 268 } 269 270 [Test] Space()271 public void Space () 272 { 273 var d = XamlLanguage.Space; 274 TestXamlDirectiveCommon (d, "space", XamlLanguage.Xml1998Namespace, AllowedMemberLocations.Attribute, typeof (string)); 275 } 276 277 [Test] TypeArguments()278 public void TypeArguments () 279 { 280 var d = XamlLanguage.TypeArguments; 281 TestXamlDirectiveCommon (d, "TypeArguments", AllowedMemberLocations.Attribute, typeof (string)); 282 } 283 284 [Test] Uid()285 public void Uid () 286 { 287 var d = XamlLanguage.Uid; 288 TestXamlDirectiveCommon (d, "Uid", AllowedMemberLocations.Attribute, typeof (string)); 289 } 290 291 [Test] UnknownContent()292 public void UnknownContent () 293 { 294 var d = XamlLanguage.UnknownContent; 295 // weird name 296 TestXamlDirectiveCommon (d, "_UnknownContent", XamlLanguage.Xaml2006Namespace, AllowedMemberLocations.MemberElement, typeof (object), true); 297 } 298 TestXamlDirectiveCommon(XamlDirective d, string name, AllowedMemberLocations allowedLocation, Type type)299 void TestXamlDirectiveCommon (XamlDirective d, string name, AllowedMemberLocations allowedLocation, Type type) 300 { 301 TestXamlDirectiveCommon (d, name, XamlLanguage.Xaml2006Namespace, allowedLocation, type); 302 } 303 TestXamlDirectiveCommon(XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type)304 void TestXamlDirectiveCommon (XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type) 305 { 306 TestXamlDirectiveCommon (d, name, ns, allowedLocation, type, false); 307 } 308 TestXamlDirectiveCommon(XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type, bool isUnknown)309 void TestXamlDirectiveCommon (XamlDirective d, string name, string ns, AllowedMemberLocations allowedLocation, Type type, bool isUnknown) 310 { 311 Assert.AreEqual (allowedLocation, d.AllowedLocation, "#1"); 312 Assert.IsNull (d.DeclaringType, "#2"); 313 Assert.IsNotNull (d.Invoker, "#3"); 314 Assert.IsNull (d.Invoker.UnderlyingGetter, "#3-2"); 315 Assert.IsNull (d.Invoker.UnderlyingSetter, "#3-3"); 316 Assert.AreEqual (isUnknown, d.IsUnknown, "#4"); 317 Assert.IsTrue (d.IsReadPublic, "#5"); 318 Assert.IsTrue (d.IsWritePublic, "#6"); 319 Assert.AreEqual (name, d.Name, "#7"); 320 Assert.IsTrue (d.IsNameValid, "#8"); 321 Assert.AreEqual (ns, d.PreferredXamlNamespace, "#9"); 322 Assert.IsNull (d.TargetType, "#10"); 323 Assert.IsNotNull (d.Type, "#11"); 324 Assert.AreEqual (type, d.Type.UnderlyingType, "#11-2"); 325 326 // .NET returns StringConverter, but it should not premise that key must be string (it is object) 327 if (name == "Key") 328 ;//Assert.IsNull (d.TypeConverter, "#12") 329 else if (type.IsGenericType || name == "_Initialization" || name == "_UnknownContent") 330 Assert.IsNull (d.TypeConverter, "#12"); 331 else 332 Assert.IsNotNull (d.TypeConverter, "#12"); 333 Assert.IsNull (d.ValueSerializer, "#13"); 334 Assert.IsNull (d.DeferringLoader, "#14"); 335 Assert.IsNull (d.UnderlyingMember, "#15"); 336 Assert.IsFalse (d.IsReadOnly, "#16"); 337 Assert.IsFalse (d.IsWriteOnly, "#17"); 338 Assert.IsFalse (d.IsAttachable, "#18"); 339 Assert.IsFalse (d.IsEvent, "#19"); 340 Assert.IsTrue (d.IsDirective, "#20"); 341 Assert.IsNotNull (d.DependsOn, "#21"); 342 Assert.AreEqual (0, d.DependsOn.Count, "#21-2"); 343 Assert.IsFalse (d.IsAmbient, "#22"); 344 Assert.AreEqual (DesignerSerializationVisibility.Visible, d.SerializationVisibility, "#23"); 345 } 346 347 // type property details 348 349 // extension types 350 [Test] Array()351 public void Array () 352 { 353 var t = XamlLanguage.Array; 354 TestXamlTypeExtension (t, "ArrayExtension", typeof (ArrayExtension), typeof (Array), true); 355 Assert.IsNotNull (t.ContentProperty, "#27"); 356 Assert.AreEqual ("Items", t.ContentProperty.Name, "#27-2"); 357 358 var l = t.GetAllMembers ().ToArray (); 359 Assert.AreEqual (2, l.Length, "#31"); 360 var items = l.First (m => m.Name == "Items"); 361 Assert.IsFalse (items == XamlLanguage.Items, "#31-2"); 362 l.First (m => m.Name == "Type"); 363 364 l = t.GetAllAttachableMembers ().ToArray (); 365 Assert.AreEqual (0, l.Length, "#32"); 366 } 367 368 [Test] Array_Items()369 public void Array_Items () 370 { 371 var m = XamlLanguage.Array.GetMember ("Items"); 372 TestMemberCommon (m, "Items", typeof (IList), typeof (ArrayExtension), false); 373 } 374 375 [Test] Array_Type()376 public void Array_Type () 377 { 378 var m = XamlLanguage.Array.GetMember ("Type"); 379 TestMemberCommon (m, "Type", typeof (Type), typeof (ArrayExtension), true); 380 } 381 382 [Test] Null()383 public void Null () 384 { 385 var t = XamlLanguage.Null; 386 TestXamlTypeExtension (t, "NullExtension", typeof (NullExtension), typeof (object), true); 387 Assert.IsNull (t.ContentProperty, "#27"); 388 389 var l = t.GetAllMembers ().ToArray (); 390 Assert.AreEqual (0, l.Length, "#31"); 391 392 l = t.GetAllAttachableMembers ().ToArray (); 393 Assert.AreEqual (0, l.Length, "#32"); 394 } 395 396 [Test] Static()397 public void Static () 398 { 399 var t = XamlLanguage.Static; 400 TestXamlTypeExtension (t, "StaticExtension", typeof (StaticExtension), typeof (object), false); 401 var tc = t.TypeConverter.ConverterInstance; 402 Assert.IsNotNull (tc, "#25-2"); 403 Assert.IsFalse (tc.CanConvertFrom (typeof (string)), "#25-3"); 404 Assert.IsTrue (tc.CanConvertTo (typeof (string)), "#25-4"); 405 Assert.IsNull (t.ContentProperty, "#27"); 406 407 var l = t.GetAllMembers ().ToArray (); 408 Assert.AreEqual (2, l.Length, "#31"); 409 l.First (m => m.Name == "Member"); 410 l.First (m => m.Name == "MemberType"); 411 412 l = t.GetAllAttachableMembers ().ToArray (); 413 Assert.AreEqual (0, l.Length, "#32"); 414 } 415 416 [Test] Static_Member()417 public void Static_Member () 418 { 419 var m = XamlLanguage.Static.GetMember ("Member"); 420 TestMemberCommon (m, "Member", typeof (string), typeof (StaticExtension), true); 421 } 422 423 [Test] Static_MemberType()424 public void Static_MemberType () 425 { 426 var m = XamlLanguage.Static.GetMember ("MemberType"); 427 TestMemberCommon (m, "MemberType", typeof (Type), typeof (StaticExtension), true); 428 } 429 430 [Test] Type()431 public void Type () 432 { 433 var t = XamlLanguage.Type; 434 TestXamlTypeExtension (t, "TypeExtension", typeof (TypeExtension), typeof (Type), false); 435 Assert.IsNotNull (t.TypeConverter.ConverterInstance, "#25-2"); 436 Assert.IsNull (t.ContentProperty, "#27"); 437 438 var l = t.GetAllMembers ().ToArray (); 439 Assert.AreEqual (2, l.Length, "#31"); 440 l.First (m => m.Name == "TypeName"); 441 l.First (m => m.Name == "Type"); 442 443 l = t.GetAllAttachableMembers ().ToArray (); 444 Assert.AreEqual (0, l.Length, "#32"); 445 } 446 447 [Test] Type_TypeName()448 public void Type_TypeName () 449 { 450 var m = XamlLanguage.Type.GetMember ("TypeName"); 451 TestMemberCommon (m, "TypeName", typeof (string), typeof (TypeExtension), true); 452 } 453 454 [Test] Type_Type()455 public void Type_Type () 456 { 457 var m = XamlLanguage.Type.GetMember ("Type"); 458 TestMemberCommon (m, "Type", typeof (Type), typeof (TypeExtension), true); 459 Assert.AreNotEqual (XamlLanguage.Type, m.Type, "#1"); 460 } 461 462 // primitive types 463 464 [Test] Byte()465 public void Byte () 466 { 467 var t = XamlLanguage.Byte; 468 TestXamlTypePrimitive (t, "Byte", typeof (byte), false, false); 469 470 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 471 var l = t.GetAllAttachableMembers ().ToArray (); 472 Assert.AreEqual (1, l.Length, "#32"); 473 */ 474 } 475 476 [Test] Char()477 public void Char () 478 { 479 var t = XamlLanguage.Char; 480 TestXamlTypePrimitive (t, "Char", typeof (char), false, false); 481 482 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 483 var l = t.GetAllAttachableMembers ().ToArray (); 484 Assert.AreEqual (3, l.Length, "#32"); 485 l.First (m => m.Name == "UnicodeCategory"); 486 l.First (m => m.Name == "NumericValue"); 487 l.First (m => m.Name == "HashCodeOfPtr"); 488 */ 489 } 490 491 [Test] Decimal()492 public void Decimal () 493 { 494 var t = XamlLanguage.Decimal; 495 TestXamlTypePrimitive (t, "Decimal", typeof (decimal), false, false); 496 497 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 498 var l = t.GetAllAttachableMembers ().ToArray (); 499 Assert.AreEqual (2, l.Length, "#32"); 500 l.First (m => m.Name == "Bits"); 501 l.First (m => m.Name == "HashCodeOfPtr"); 502 */ 503 } 504 505 [Test] Double()506 public void Double () 507 { 508 var t = XamlLanguage.Double; 509 TestXamlTypePrimitive (t, "Double", typeof (double), false, false); 510 511 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 512 var l = t.GetAllAttachableMembers ().ToArray (); 513 Assert.AreEqual (1, l.Length, "#32"); 514 l.First (m => m.Name == "HashCodeOfPtr"); 515 */ 516 } 517 518 [Test] Int16()519 public void Int16 () 520 { 521 var t = XamlLanguage.Int16; 522 TestXamlTypePrimitive (t, "Int16", typeof (short), false, false); 523 524 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 525 var l = t.GetAllAttachableMembers ().ToArray (); 526 Assert.AreEqual (1, l.Length, "#32"); 527 l.First (m => m.Name == "HashCodeOfPtr"); 528 */ 529 } 530 531 [Test] Int32()532 public void Int32 () 533 { 534 var t = XamlLanguage.Int32; 535 TestXamlTypePrimitive (t, "Int32", typeof (int), false, false); 536 537 try { 538 t.Invoker.CreateInstance (new object [] {1}); 539 Assert.Fail ("Should expect .ctor() and fail"); 540 } catch (MissingMethodException) { 541 } 542 543 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 544 var l = t.GetAllAttachableMembers ().ToArray (); 545 Assert.AreEqual (1, l.Length, "#32"); 546 l.First (m => m.Name == "HashCodeOfPtr"); 547 */ 548 } 549 550 [Test] Int64()551 public void Int64 () 552 { 553 var t = XamlLanguage.Int64; 554 TestXamlTypePrimitive (t, "Int64", typeof (long), false, false); 555 556 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 557 var l = t.GetAllAttachableMembers ().ToArray (); 558 Assert.AreEqual (1, l.Length, "#32"); 559 l.First (m => m.Name == "HashCodeOfPtr"); 560 */ 561 } 562 563 [Test] Object()564 public void Object () 565 { 566 var t = XamlLanguage.Object; 567 TestXamlTypePrimitive (t, "Object", typeof (object), true, false); 568 Assert.IsNull (t.BaseType, "#x1"); 569 570 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 571 var l = t.GetAllAttachableMembers ().ToArray (); 572 Assert.AreEqual (0, l.Length, "#32"); 573 */ 574 } 575 576 [Test] Single()577 public void Single () 578 { 579 var t = XamlLanguage.Single; 580 TestXamlTypePrimitive (t, "Single", typeof (float), false, false); 581 582 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 583 var l = t.GetAllAttachableMembers ().ToArray (); 584 Assert.AreEqual (1, l.Length, "#32"); 585 l.First (m => m.Name == "HashCodeOfPtr"); 586 */ 587 } 588 589 [Test] String()590 public void String () 591 { 592 var t = XamlLanguage.String; 593 TestXamlTypePrimitive (t, "String", typeof (string), true, true); 594 Assert.IsNotNull (XamlLanguage.AllTypes.First (tt => tt.Name == "String").ValueSerializer, "#x"); 595 Assert.IsNotNull (XamlLanguage.String.ValueSerializer, "#y"); 596 597 try { 598 t.Invoker.CreateInstance (new object [] {"foo"}); 599 Assert.Fail ("Should expect .ctor() and fail"); 600 } catch (MissingMethodException) { 601 } 602 603 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 604 var l = t.GetAllAttachableMembers ().ToArray (); 605 Assert.AreEqual (0, l.Length, "#32"); 606 */ 607 } 608 609 [Test] TimeSpan()610 public void TimeSpan () 611 { 612 var t = XamlLanguage.TimeSpan; 613 TestXamlTypePrimitive (t, "TimeSpan", typeof (TimeSpan), false, false); 614 615 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 616 var l = t.GetAllAttachableMembers ().ToArray (); 617 Assert.AreEqual (1, l.Length, "#32"); 618 l.First (m => m.Name == "HashCodeOfPtr"); 619 */ 620 } 621 622 [Test] Uri()623 public void Uri () 624 { 625 var t = XamlLanguage.Uri; 626 TestXamlTypePrimitive (t, "Uri", typeof (Uri), true, true); 627 628 /* Those properties are pointless regarding practical use. Those "members" does not participate in serialization. 629 var l = t.GetAllAttachableMembers ().ToArray (); 630 Assert.AreEqual (0, l.Length, "#32"); 631 */ 632 } 633 634 // miscellaneous 635 636 [Test] Member()637 public void Member () 638 { 639 var t = XamlLanguage.Member; 640 TestXamlTypeCommon (t, "Member", typeof (MemberDefinition), true, true, false); 641 Assert.IsNull (t.TypeConverter, "#25"); 642 // FIXME: test remaining members 643 644 var l = t.GetAllMembers ().ToArray (); 645 Assert.AreEqual (1, l.Length, "#31"); 646 l.First (m => m.Name == "Name"); 647 } 648 649 [Test] Member_Name()650 public void Member_Name () 651 { 652 var m = XamlLanguage.Member.GetMember ("Name"); 653 TestMemberCommon (m, "Name", typeof (string), typeof (MemberDefinition), true); 654 } 655 656 [Test] Property()657 public void Property () 658 { 659 var t = XamlLanguage.Property; 660 TestXamlTypeCommon (t, "Property", typeof (PropertyDefinition), true); 661 Assert.IsNull (t.TypeConverter, "#25"); 662 // FIXME: test remaining members 663 664 var l = t.GetAllMembers ().ToArray (); 665 Assert.AreEqual (4, l.Length, "#31"); 666 l.First (m => m.Name == "Name"); 667 l.First (m => m.Name == "Type"); 668 l.First (m => m.Name == "Modifier"); 669 l.First (m => m.Name == "Attributes"); 670 } 671 672 [Test] Property_Name()673 public void Property_Name () 674 { 675 var m = XamlLanguage.Property.GetMember ("Name"); 676 TestMemberCommon (m, "Name", typeof (string), typeof (PropertyDefinition), true); 677 } 678 679 [Test] Property_Type()680 public void Property_Type () 681 { 682 var m = XamlLanguage.Property.GetMember ("Type"); 683 TestMemberCommon (m, "Type", typeof (XamlType), typeof (PropertyDefinition), true); 684 Assert.IsNotNull (m.TypeConverter, "#1"); 685 Assert.IsNull (m.ValueSerializer, "#2"); 686 } 687 688 [Test] Property_Modifier()689 public void Property_Modifier () 690 { 691 var m = XamlLanguage.Property.GetMember ("Modifier"); 692 TestMemberCommon (m, "Modifier", typeof (string), typeof (PropertyDefinition), true); 693 } 694 695 [Test] Property_Attributes()696 public void Property_Attributes () 697 { 698 var m = XamlLanguage.Property.GetMember ("Attributes"); 699 TestMemberCommon (m, "Attributes", typeof (IList<Attribute>), typeof (PropertyDefinition), false); 700 } 701 702 [Test] Reference()703 public void Reference () 704 { 705 var t = XamlLanguage.Reference; 706 TestXamlTypeCommon (t, "Reference", typeof (Reference), true); 707 Assert.IsNull (t.TypeConverter, "#25"); 708 // FIXME: test remaining members 709 710 var l = t.GetAllMembers ().ToArray (); 711 Assert.AreEqual (1, l.Length, "#31"); 712 l.First (m => m.Name == "Name"); 713 Assert.AreEqual (l [0], t.ContentProperty, "#32"); 714 } 715 716 [Test] Reference_Name()717 public void Reference_Name () 718 { 719 var m = XamlLanguage.Reference.GetMember ("Name"); 720 TestMemberCommon (m, "Name", typeof (string), typeof (Reference), true); 721 } 722 723 [Test] XData()724 public void XData () 725 { 726 var t = XamlLanguage.XData; 727 TestXamlTypeCommon (t, "XData", typeof (XData), true); 728 Assert.IsNull (t.TypeConverter, "#25"); 729 // FIXME: test remaining members 730 731 var l = t.GetAllMembers ().ToArray (); 732 Assert.AreEqual (2, l.Length, "#31"); 733 l.First (m => m.Name == "Text"); 734 l.First (m => m.Name == "XmlReader"); 735 } 736 737 [Test] XData_Text()738 public void XData_Text () 739 { 740 var m = XamlLanguage.XData.GetMember ("Text"); 741 TestMemberCommon (m, "Text", typeof (string), typeof (XData), true); 742 } 743 744 [Test] XData_XmlReader()745 public void XData_XmlReader () 746 { 747 var m = XamlLanguage.XData.GetMember ("XmlReader"); 748 // it does not use XmlReader type ... 749 TestMemberCommon (m, "XmlReader", typeof (object), typeof (XData), true); 750 } 751 752 // common test methods 753 TestXamlTypeCommon(XamlType t, string name, Type underlyingType, bool nullable)754 void TestXamlTypeCommon (XamlType t, string name, Type underlyingType, bool nullable) 755 { 756 TestXamlTypeCommon (t, name, underlyingType, nullable, false); 757 } 758 TestXamlTypeCommon(XamlType t, string name, Type underlyingType, bool nullable, bool constructionRequiresArguments)759 void TestXamlTypeCommon (XamlType t, string name, Type underlyingType, bool nullable, bool constructionRequiresArguments) 760 { 761 TestXamlTypeCommon (t, name, underlyingType, nullable, constructionRequiresArguments, true); 762 } 763 TestXamlTypeCommon(XamlType t, string name, Type underlyingType, bool nullable, bool constructionRequiresArguments, bool isConstructible)764 void TestXamlTypeCommon (XamlType t, string name, Type underlyingType, bool nullable, bool constructionRequiresArguments, bool isConstructible) 765 { 766 Assert.IsNotNull (t.Invoker, "#1"); 767 Assert.IsTrue (t.IsNameValid, "#2"); 768 Assert.IsFalse (t.IsUnknown, "#3"); 769 // FIXME: test names (some extension types have wrong name. 770 //Assert.AreEqual (name, t.Name, "#4"); 771 Assert.AreEqual (XamlLanguage.Xaml2006Namespace, t.PreferredXamlNamespace, "#5"); 772 Assert.IsNull (t.TypeArguments, "#6"); 773 Assert.AreEqual (underlyingType, t.UnderlyingType, "#7"); 774 Assert.AreEqual (constructionRequiresArguments, t.ConstructionRequiresArguments, "#8"); 775 Assert.IsFalse (t.IsArray, "#9"); 776 Assert.IsFalse (t.IsCollection, "#10"); 777 // FIXME: test here (very inconsistent with the spec) 778 Assert.AreEqual (isConstructible, t.IsConstructible, "#11"); 779 Assert.IsFalse (t.IsDictionary, "#12"); 780 Assert.IsFalse (t.IsGeneric, "#13"); 781 Assert.IsFalse (t.IsNameScope, "#15"); 782 Assert.AreEqual (nullable, t.IsNullable, "#16"); 783 Assert.IsTrue (t.IsPublic, "#17"); 784 Assert.IsFalse (t.IsUsableDuringInitialization, "#18"); 785 Assert.IsFalse (t.IsWhitespaceSignificantCollection, "#19"); 786 Assert.IsFalse (t.IsXData, "#20"); 787 Assert.IsFalse (t.TrimSurroundingWhitespace, "#21"); 788 Assert.IsFalse (t.IsAmbient, "#22"); 789 Assert.IsNull (t.AllowedContentTypes, "#23"); 790 Assert.IsNull (t.ContentWrappers, "#24"); 791 // string is a special case. 792 if (t == XamlLanguage.String) 793 Assert.IsNotNull (t.ValueSerializer, "#26"); 794 else 795 Assert.IsNull (t.ValueSerializer, "#26"); 796 //Assert.IsNull (t.DeferringLoader, "#28"); 797 } 798 TestXamlTypePrimitive(XamlType t, string name, Type underlyingType, bool nullable, bool constructorRequiresArguments)799 void TestXamlTypePrimitive (XamlType t, string name, Type underlyingType, bool nullable, bool constructorRequiresArguments) 800 { 801 TestXamlTypeCommon (t, name, underlyingType, nullable, constructorRequiresArguments); 802 Assert.IsFalse (t.IsMarkupExtension, "#14"); 803 Assert.IsNotNull (t.TypeConverter, "#25"); 804 Assert.IsNull (t.ContentProperty, "#27"); 805 Assert.IsNull (t.MarkupExtensionReturnType, "#29"); 806 807 var l = t.GetAllMembers ().ToArray (); 808 Assert.AreEqual (0, l.Length, "#31"); 809 } 810 TestXamlTypeExtension(XamlType t, string name, Type underlyingType, Type extReturnType, bool noTypeConverter)811 void TestXamlTypeExtension (XamlType t, string name, Type underlyingType, Type extReturnType, bool noTypeConverter) 812 { 813 TestXamlTypeCommon (t, name, underlyingType, true, false); 814 Assert.IsTrue (t.IsMarkupExtension, "#14"); 815 if (noTypeConverter) 816 Assert.IsNull (t.TypeConverter, "#25"); 817 else 818 Assert.IsNotNull (t.TypeConverter, "#25"); 819 Assert.IsNotNull (t.MarkupExtensionReturnType, "#29"); 820 Assert.AreEqual (extReturnType, t.MarkupExtensionReturnType.UnderlyingType, "#29-2"); 821 Assert.IsNull (t.Invoker.SetMarkupExtensionHandler, "#31"); // orly? 822 } 823 TestMemberCommon(XamlMember m, string name, Type type, Type declType, bool hasSetter)824 void TestMemberCommon (XamlMember m, string name, Type type, Type declType, bool hasSetter) 825 { 826 Assert.IsNotNull (m, "#1"); 827 Assert.IsNotNull (m.DeclaringType, "#2"); 828 Assert.AreEqual (declType, m.DeclaringType.UnderlyingType, "#2-2"); 829 Assert.IsNotNull (m.Invoker, "#3"); 830 Assert.IsNotNull (m.Invoker.UnderlyingGetter, "#3-2"); 831 if (hasSetter) 832 Assert.IsNotNull (m.Invoker.UnderlyingSetter, "#3-3"); 833 else 834 Assert.IsNull (m.Invoker.UnderlyingSetter, "#3-3"); 835 Assert.IsFalse (m.IsUnknown, "#4"); 836 Assert.IsTrue (m.IsReadPublic, "#5"); 837 Assert.AreEqual (hasSetter, m.IsWritePublic, "#6"); 838 Assert.AreEqual (name, m.Name, "#7"); 839 Assert.IsTrue (m.IsNameValid, "#8"); 840 Assert.AreEqual (XamlLanguage.Xaml2006Namespace, m.PreferredXamlNamespace, "#9"); 841 // use declType here (mostly identical to targetType) 842 Assert.AreEqual (new XamlType (declType, m.TargetType.SchemaContext), m.TargetType, "#10"); 843 Assert.IsNotNull (m.Type, "#11"); 844 Assert.AreEqual (type, m.Type.UnderlyingType, "#11-2"); 845 // Property.Type is a special case here. 846 if (name == "Type" && m.DeclaringType != XamlLanguage.Property) 847 Assert.AreEqual (m.Type.TypeConverter, m.TypeConverter, "#12"); 848 // String type is a special case here. 849 if (type == typeof (string)) 850 Assert.AreEqual (m.Type.ValueSerializer, m.ValueSerializer, "#13a"); 851 else 852 Assert.IsNull (m.ValueSerializer, "#13b"); 853 Assert.IsNull (m.DeferringLoader, "#14"); 854 Assert.IsNotNull (m.UnderlyingMember, "#15"); 855 Assert.AreEqual (!hasSetter, m.IsReadOnly, "#16"); 856 Assert.IsFalse (m.IsWriteOnly, "#17"); 857 Assert.IsFalse (m.IsAttachable, "#18"); 858 Assert.IsFalse (m.IsEvent, "#19"); 859 Assert.IsFalse (m.IsDirective, "#20"); 860 Assert.IsNotNull (m.DependsOn, "#21"); 861 Assert.AreEqual (0, m.DependsOn.Count, "#21-2"); 862 Assert.IsFalse (m.IsAmbient, "#22"); 863 } 864 } 865 } 866