PageRenderTime 48ms CodeModel.GetById 11ms RepoModel.GetById 0ms app.codeStats 0ms

/mcs/class/System.Xaml/Test/System.Xaml/XamlObjectReaderTest.cs

https://bitbucket.org/danipen/mono
C# | 755 lines | 629 code | 89 blank | 37 comment | 12 complexity | 5de9dba12bee62580aca671f37d22221 MD5 | raw file
Possible License(s): Unlicense, Apache-2.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0
  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.IO;
  28. using System.Linq;
  29. using System.Reflection;
  30. using System.Windows.Markup;
  31. using System.Xaml;
  32. using System.Xaml.Schema;
  33. using System.Xml;
  34. using NUnit.Framework;
  35. using CategoryAttribute = NUnit.Framework.CategoryAttribute;
  36. namespace MonoTests.System.Xaml
  37. {
  38. [TestFixture]
  39. public partial class XamlObjectReaderTest : XamlReaderTestBase
  40. {
  41. [Test]
  42. public void ConstructorNullObject ()
  43. {
  44. // allowed.
  45. new XamlObjectReader (null);
  46. }
  47. [Test]
  48. [ExpectedException (typeof (ArgumentNullException))]
  49. public void ConstructorNullSchemaContext ()
  50. {
  51. new XamlObjectReader ("foo", (XamlSchemaContext) null);
  52. }
  53. [Test]
  54. public void ConstructorNullSettings ()
  55. {
  56. new XamlObjectReader ("foo", (XamlObjectReaderSettings) null);
  57. }
  58. [Test]
  59. [ExpectedException (typeof (ArgumentNullException))]
  60. public void ConstructorNullSchemaContext2 ()
  61. {
  62. new XamlObjectReader ("foo", null, new XamlObjectReaderSettings ());
  63. }
  64. [Test]
  65. public void ConstructorNullSettings2 ()
  66. {
  67. new XamlObjectReader ("foo", new XamlSchemaContext (null, null), null);
  68. }
  69. [Test]
  70. [ExpectedException (typeof (XamlObjectReaderException))]
  71. public void ReadNonConstructible ()
  72. {
  73. // XamlType has no default constructor.
  74. new XamlObjectReader (XamlLanguage.String);
  75. }
  76. [Test]
  77. [ExpectedException (typeof (XamlObjectReaderException))]
  78. public void NonPublicType ()
  79. {
  80. new XamlObjectReader (new TestClass1 ());
  81. }
  82. [Test]
  83. [ExpectedException (typeof (XamlObjectReaderException))]
  84. public void NestedType ()
  85. {
  86. new XamlObjectReader (new TestClass2 ());
  87. }
  88. public class TestClass2
  89. {
  90. }
  91. [Test]
  92. public void ConstructibleType ()
  93. {
  94. new XamlObjectReader (new TestClass3 ());
  95. }
  96. // Based on Common tests
  97. [Test]
  98. public void Read_String ()
  99. {
  100. var r = new XamlObjectReader ("foo");
  101. Read_String (r);
  102. }
  103. [Test]
  104. public void WriteNullMemberAsObject ()
  105. {
  106. var r = new XamlObjectReader (new TestClass4 ());
  107. WriteNullMemberAsObject (r, delegate {
  108. Assert.IsNull (r.Instance, "#x"); }
  109. );
  110. }
  111. [Test]
  112. public void StaticMember ()
  113. {
  114. var r = new XamlObjectReader (new TestClass5 ());
  115. StaticMember (r);
  116. }
  117. [Test]
  118. public void Skip ()
  119. {
  120. var r = new XamlObjectReader ("Foo");
  121. Skip (r);
  122. }
  123. [Test]
  124. public void Skip2 ()
  125. {
  126. var r = new XamlObjectReader ("Foo");
  127. Skip2 (r);
  128. }
  129. [Test]
  130. public void Skip3 ()
  131. {
  132. var r = new XamlObjectReader (new ReadOnlyPropertyContainer () { Foo = "x" });
  133. while (r.NodeType != XamlNodeType.StartMember)
  134. r.Read ();
  135. r.Skip ();
  136. Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#1");
  137. }
  138. [Test]
  139. public void Read_XmlDocument ()
  140. {
  141. var doc = new XmlDocument ();
  142. doc.LoadXml ("<root xmlns='urn:foo'><elem attr='val' /></root>");
  143. var r = new XamlObjectReader (doc);
  144. Read_XmlDocument (r);
  145. }
  146. [Test]
  147. public void Read_NonPrimitive ()
  148. {
  149. var r = new XamlObjectReader (new TestClass3 ());
  150. Read_NonPrimitive (r);
  151. }
  152. [Test]
  153. public void Read_Type ()
  154. {
  155. var r = new XamlObjectReader (typeof (int));
  156. Read_TypeOrTypeExtension (r);
  157. }
  158. [Test]
  159. public void Read_TypeExtension ()
  160. {
  161. var tx = new TypeExtension (typeof (int));
  162. var r = new XamlObjectReader (tx);
  163. Read_TypeOrTypeExtension (r);
  164. }
  165. void Read_TypeOrTypeExtension (XamlObjectReader r)
  166. {
  167. Read_TypeOrTypeExtension (r, delegate {
  168. Assert.IsTrue (r.Instance is TypeExtension, "#26");
  169. }, XamlLanguage.PositionalParameters);
  170. }
  171. [Test]
  172. public void Read_Type2 ()
  173. {
  174. var r = new XamlObjectReader (typeof (TestClass1));
  175. Read_TypeOrTypeExtension2 (r);
  176. }
  177. [Test]
  178. public void Read_TypeExtension2 ()
  179. {
  180. var r = new XamlObjectReader (new TypeExtension (typeof (TestClass1)));
  181. Read_TypeOrTypeExtension2 (r);
  182. }
  183. void Read_TypeOrTypeExtension2 (XamlObjectReader r)
  184. {
  185. Read_TypeOrTypeExtension2 (r, delegate {
  186. Assert.IsTrue (r.Instance is TypeExtension, "#26");
  187. }, XamlLanguage.PositionalParameters);
  188. }
  189. [Test]
  190. public void Read_Reference ()
  191. {
  192. var r = new XamlObjectReader (new Reference ("FooBar"));
  193. Read_Reference (r);
  194. }
  195. [Test]
  196. public void Read_Null ()
  197. {
  198. var r = new XamlObjectReader (null);
  199. Read_NullOrNullExtension (r, (object) null);
  200. }
  201. [Test]
  202. public void Read_NullExtension ()
  203. {
  204. var o = new NullExtension ();
  205. var r = new XamlObjectReader (o);
  206. Read_NullOrNullExtension (r, o);
  207. }
  208. void Read_NullOrNullExtension (XamlObjectReader r, object instance)
  209. {
  210. Read_NullOrNullExtension (r, delegate {
  211. Assert.AreEqual (instance, r.Instance, "#26"); // null and NullExtension are different here.
  212. });
  213. }
  214. [Test]
  215. public void Read_StaticExtension ()
  216. {
  217. var r = new XamlObjectReader (new StaticExtension ("FooBar"));
  218. Read_StaticExtension (r, XamlLanguage.PositionalParameters);
  219. }
  220. [Test]
  221. public void Read_ListInt32 ()
  222. {
  223. var obj = new List<int> (new int [] {5, -3, int.MaxValue, 0});
  224. Read_ListInt32 (obj);
  225. }
  226. [Test]
  227. public void Read_ListInt32_2 ()
  228. {
  229. var obj = new List<int> (new int [0]);
  230. Read_ListInt32 (obj);
  231. }
  232. void Read_ListInt32 (List<int> obj)
  233. {
  234. var r = new XamlObjectReader (obj);
  235. Read_ListInt32 (r, delegate {
  236. Assert.AreEqual (obj, r.Instance, "#26");
  237. }, obj);
  238. }
  239. [Test]
  240. public void Read_ListType ()
  241. {
  242. var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
  243. var r = new XamlObjectReader (obj);
  244. Read_ListType (r, true);
  245. }
  246. [Test]
  247. public void Read_ListArray ()
  248. {
  249. var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
  250. var r = new XamlObjectReader (obj);
  251. Read_ListArray (r);
  252. }
  253. [Test]
  254. public void Read_ArrayList ()
  255. {
  256. var obj = new ArrayList (new int [] {5, -3, 0});
  257. var r = new XamlObjectReader (obj);
  258. Read_ArrayList (r);
  259. }
  260. [Test]
  261. public void Read_Array ()
  262. {
  263. var obj = new int [] {5, -3, 0};
  264. var r = new XamlObjectReader (obj);
  265. Read_ArrayOrArrayExtension (r, obj);
  266. }
  267. [Test]
  268. public void Read_ArrayExtension ()
  269. {
  270. var obj = new ArrayExtension (new int [] {5, -3, 0});
  271. var r = new XamlObjectReader (obj);
  272. Read_ArrayOrArrayExtension (r, obj);
  273. }
  274. [Test]
  275. public void Read_MyArrayExtension ()
  276. {
  277. var obj = new MyArrayExtension (new int [] {5, -3, 0});
  278. var r = new XamlObjectReader (obj);
  279. Read_ArrayOrArrayExtensionOrMyArrayExtension (r, obj, typeof (MyArrayExtension));
  280. }
  281. void Read_ArrayOrArrayExtension (XamlObjectReader r, object instance)
  282. {
  283. Read_ArrayOrArrayExtensionOrMyArrayExtension (r, instance, typeof (ArrayExtension));
  284. }
  285. void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlObjectReader r, object instance, Type extType)
  286. {
  287. Read_ArrayOrArrayExtensionOrMyArrayExtension (r, delegate {
  288. Assert.AreEqual (instance, r.Instance, "#26"); // different between Array and ArrayExtension. Also, different from Type and TypeExtension (Type returns TypeExtension, while Array remains to return Array)
  289. }, extType);
  290. }
  291. [Test]
  292. public void Read_ArrayExtension2 ()
  293. {
  294. var r = new XamlObjectReader (new ArrayExtension (typeof (int)));
  295. Read_ArrayExtension2 (r);
  296. }
  297. [Test]
  298. public void Read_DateTime ()
  299. {
  300. var obj = new DateTime (2010, 4, 15);
  301. var r = new XamlObjectReader (obj);
  302. Read_CommonClrType (r, obj);
  303. Assert.AreEqual ("2010-04-15", Read_Initialization (r, null), "#1");
  304. }
  305. [Test]
  306. public void Read_TimeSpan ()
  307. {
  308. Read_CommonXamlPrimitive (TimeSpan.FromMinutes (4));
  309. }
  310. [Test]
  311. public void Read_Uri ()
  312. {
  313. Read_CommonXamlPrimitive (new Uri ("urn:foo"));
  314. }
  315. [Test]
  316. public void Read_Guid ()
  317. {
  318. var obj = Guid.NewGuid ();
  319. var r = new XamlObjectReader (obj);
  320. Assert.IsNotNull (r.SchemaContext.GetXamlType (typeof (Guid)).TypeConverter, "premise#1");
  321. Read_CommonClrType (r, obj);
  322. Assert.AreEqual (obj.ToString (), Read_Initialization (r, null), "#1");
  323. }
  324. [Test]
  325. [ExpectedException (typeof (XamlObjectReaderException))]
  326. [Category ("NotWorking")]
  327. public void Read_XData ()
  328. {
  329. var r = new XamlObjectReader (new XData () {Text = "xdata text"}); // XmlReader implementation is not visible.
  330. while (!r.IsEof)
  331. r.Read ();
  332. }
  333. [Test]
  334. [ExpectedException (typeof (XamlObjectReaderException))]
  335. [Category ("NotWorking")]
  336. public void Read_XDataWrapper ()
  337. {
  338. var obj = new XDataWrapper () { Markup = new XData () {Text = "<my_xdata/>" } };
  339. var r = new XamlObjectReader (obj);
  340. while (!r.IsEof)
  341. r.Read ();
  342. }
  343. [Test]
  344. public void ReadStandardTypes ()
  345. {
  346. SimpleReadStandardType (new ArrayExtension ());
  347. SimpleReadStandardType (new NullExtension ());
  348. SimpleReadStandardType (new PropertyDefinition ());
  349. SimpleReadStandardType (new Reference ());
  350. SimpleReadStandardType (new StaticExtension ());
  351. SimpleReadStandardType (new TypeExtension ());
  352. }
  353. void SimpleReadStandardType (object instance)
  354. {
  355. var r = new XamlObjectReader (instance);
  356. while (!r.IsEof)
  357. r.Read ();
  358. }
  359. [Test]
  360. public void Read_CustomMarkupExtension ()
  361. {
  362. var r = new XamlObjectReader (new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"});
  363. Read_CustomMarkupExtension (r);
  364. }
  365. [Test]
  366. public void Read_CustomMarkupExtension2 ()
  367. {
  368. var r = new XamlObjectReader (new MyExtension2 () { Foo = typeof (int), Bar = "v2"});
  369. Read_CustomMarkupExtension2 (r);
  370. }
  371. [Test]
  372. public void Read_CustomMarkupExtension3 ()
  373. {
  374. var r = new XamlObjectReader (new MyExtension3 () { Foo = typeof (int), Bar = "v2"});
  375. Read_CustomMarkupExtension3 (r);
  376. }
  377. [Test]
  378. public void Read_CustomMarkupExtension4 ()
  379. {
  380. var r = new XamlObjectReader (new MyExtension4 () { Foo = typeof (int), Bar = "v2"});
  381. Read_CustomMarkupExtension4 (r);
  382. }
  383. [Test]
  384. public void Read_CustomMarkupExtension5 ()
  385. {
  386. // This cannot be written to XamlXmlWriter though...
  387. var r = new XamlObjectReader (new MyExtension5 ("foo", "bar"));
  388. Read_CustomMarkupExtension5 (r);
  389. }
  390. [Test]
  391. public void Read_CustomMarkupExtension6 ()
  392. {
  393. var r = new XamlObjectReader (new MyExtension6 ("foo"));
  394. Read_CustomMarkupExtension6 (r);
  395. }
  396. [Test]
  397. public void Read_ArgumentAttributed ()
  398. {
  399. var obj = new ArgumentAttributed ("foo", "bar");
  400. var r = new XamlObjectReader (obj);
  401. Read_ArgumentAttributed (r, obj);
  402. }
  403. [Test]
  404. public void Read_Dictionary ()
  405. {
  406. var obj = new Dictionary<string,object> ();
  407. obj ["Foo"] = 5.0;
  408. obj ["Bar"] = -6.5;
  409. var r = new XamlObjectReader (obj);
  410. Read_Dictionary (r);
  411. }
  412. [Test]
  413. public void Read_Dictionary2 ()
  414. {
  415. var obj = new Dictionary<string,Type> ();
  416. obj ["Foo"] = typeof (int);
  417. obj ["Bar"] = typeof (Dictionary<Type,XamlType>);
  418. var r = new XamlObjectReader (obj);
  419. Read_Dictionary2 (r, XamlLanguage.PositionalParameters);
  420. }
  421. [Test]
  422. public void PositionalParameters1 ()
  423. {
  424. // Note: this can be read, but cannot be written to XML.
  425. var obj = new PositionalParametersClass1 ("foo", 5);
  426. var r = new XamlObjectReader (obj);
  427. PositionalParameters1 (r);
  428. }
  429. [Test]
  430. public void PositionalParameters2 ()
  431. {
  432. var obj = new PositionalParametersWrapper ("foo", 5);
  433. var r = new XamlObjectReader (obj);
  434. PositionalParameters2 (r);
  435. }
  436. [Test]
  437. public void ComplexPositionalParameters ()
  438. {
  439. var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
  440. var r = new XamlObjectReader (obj);
  441. ComplexPositionalParameters (r);
  442. }
  443. [Test]
  444. public void Read_ListWrapper ()
  445. {
  446. var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}));
  447. var r = new XamlObjectReader (obj);
  448. Read_ListWrapper (r);
  449. }
  450. [Test]
  451. public void Read_ListWrapper2 () // read-write list member.
  452. {
  453. var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}));
  454. var r = new XamlObjectReader (obj);
  455. Read_ListWrapper2 (r);
  456. }
  457. [Test]
  458. public void Read_ContentIncluded ()
  459. {
  460. var obj = new ContentIncludedClass () { Content = "foo" };
  461. var r = new XamlObjectReader (obj);
  462. Read_ContentIncluded (r);
  463. }
  464. [Test]
  465. public void Read_PropertyDefinition ()
  466. {
  467. var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
  468. var r = new XamlObjectReader (obj);
  469. Read_PropertyDefinition (r);
  470. }
  471. [Test]
  472. public void Read_StaticExtensionWrapper ()
  473. {
  474. var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("StaticExtensionWrapper.Foo") };
  475. var r = new XamlObjectReader (obj);
  476. Read_StaticExtensionWrapper (r);
  477. }
  478. [Test]
  479. public void Read_TypeExtensionWrapper ()
  480. {
  481. var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
  482. var r = new XamlObjectReader (obj);
  483. Read_TypeExtensionWrapper (r);
  484. }
  485. [Test]
  486. public void Read_EventContainer ()
  487. {
  488. var obj = new EventContainer ();
  489. obj.Run += delegate { Console.Error.WriteLine ("done"); };
  490. var xr = new XamlObjectReader (obj);
  491. Read_EventContainer (xr);
  492. }
  493. [Test]
  494. public void Read_NamedItems ()
  495. {
  496. // foo
  497. // - bar
  498. // -- foo
  499. // - baz
  500. var obj = new NamedItem ("foo");
  501. var obj2 = new NamedItem ("bar");
  502. obj.References.Add (obj2);
  503. obj.References.Add (new NamedItem ("baz"));
  504. obj2.References.Add (obj);
  505. var xr = new XamlObjectReader (obj);
  506. Read_NamedItems (xr, true);
  507. }
  508. [Test]
  509. public void Read_NamedItems2 ()
  510. {
  511. // i1
  512. // - i2
  513. // -- i3
  514. // - i4
  515. // -- i3
  516. var obj = new NamedItem2 ("i1");
  517. var obj2 = new NamedItem2 ("i2");
  518. var obj3 = new NamedItem2 ("i3");
  519. var obj4 = new NamedItem2 ("i4");
  520. obj.References.Add (obj2);
  521. obj.References.Add (obj4);
  522. obj2.References.Add (obj3);
  523. obj4.References.Add (obj3);
  524. var xr = new XamlObjectReader (obj);
  525. Read_NamedItems2 (xr, true);
  526. }
  527. [Test]
  528. public void Read_XmlSerializableWrapper ()
  529. {
  530. var obj = new XmlSerializableWrapper (new XmlSerializable ("<root/>"));
  531. var xr = new XamlObjectReader (obj);
  532. Read_XmlSerializableWrapper (xr, true);
  533. }
  534. [Test] // If it is root, it is not serialized as IXmlSerializable.
  535. public void Read_XmlSerializable ()
  536. {
  537. var obj = new XmlSerializable ("<root/>");
  538. var xr = new XamlObjectReader (obj);
  539. Read_XmlSerializable (xr);
  540. }
  541. [Test] // List contents are (sort of) treated as top-level too, so it is not serialized as IXmlSerializable(!)
  542. public void Read_ListXmlSerializable ()
  543. {
  544. var obj = new List<XmlSerializable> ();
  545. obj.Add (new XmlSerializable ("<root/>"));
  546. var xr = new XamlObjectReader (obj);
  547. Read_ListXmlSerializable (xr);
  548. }
  549. [Test]
  550. public void Read_AttachedProperty ()
  551. {
  552. var obj = new AttachedWrapper ();
  553. Attachable.SetFoo (obj, "x");
  554. Attachable.SetFoo (obj.Value, "y");
  555. try {
  556. var xr = new XamlObjectReader (obj);
  557. Read_AttachedProperty (xr);
  558. } finally {
  559. Attachable.SetFoo (obj, null);
  560. Attachable.SetFoo (obj.Value, null);
  561. }
  562. }
  563. [Test]
  564. [Ignore ("Foo does not work as attached properties in this test yet")]
  565. public void Read_AttachedProperty2 ()
  566. {
  567. var obj = new AttachedWrapper2 ();
  568. AttachedWrapper2.SetFoo (obj, "x");
  569. AttachedWrapper2.SetFoo (obj.Value, "y");
  570. try {
  571. var xr = new XamlObjectReader (obj);
  572. //while (xr.Read ()) Console.Error.WriteLine ("{0} {1} {2} {3}", xr.NodeType, xr.Type, xr.Member, xr.Value);
  573. } finally {
  574. AttachedWrapper2.SetFoo (obj, null);
  575. AttachedWrapper2.SetFoo (obj.Value, null);
  576. }
  577. }
  578. [Test]
  579. public void Read_AbstractContainer ()
  580. {
  581. var obj = new AbstractContainer () { Value2 = new DerivedObject () { Foo = "x" } };
  582. var xr = new XamlObjectReader (obj);
  583. while (!xr.IsEof)
  584. xr.Read ();
  585. }
  586. [Test]
  587. public void Read_ReadOnlyPropertyContainer ()
  588. {
  589. var obj = new ReadOnlyPropertyContainer () { Foo = "x" };
  590. var xr = new XamlObjectReader (obj);
  591. var xt = xr.SchemaContext.GetXamlType (obj.GetType ());
  592. while (xr.Read ())
  593. if (xr.NodeType == XamlNodeType.StartMember)
  594. break;
  595. Assert.AreEqual (xt.GetMember ("Foo"), xr.Member, "#1");
  596. while (!xr.IsEof)
  597. xr.Read ();
  598. }
  599. [Test]
  600. public void Read_TypeConverterOnListMember ()
  601. {
  602. var obj = new SecondTest.TypeOtherAssembly ();
  603. obj.Values.AddRange (new uint? [] {1, 2, 3});
  604. var xr = new XamlObjectReader (obj);
  605. Read_TypeConverterOnListMember (xr);
  606. }
  607. [Test]
  608. public void Read_EnumContainer ()
  609. {
  610. var obj = new EnumContainer () { EnumProperty = EnumValueType.Two };
  611. var xr = new XamlObjectReader (obj);
  612. Read_EnumContainer (xr);
  613. }
  614. [Test]
  615. public void Read_CollectionContentProperty ()
  616. {
  617. var obj = new CollectionContentProperty ();
  618. for (int i = 0; i < 4; i++)
  619. obj.ListOfItems.Add (new SimpleClass ());
  620. var xr = new XamlObjectReader (obj);
  621. Read_CollectionContentProperty (xr, false);
  622. }
  623. [Test]
  624. public void Read_CollectionContentPropertyX ()
  625. {
  626. var obj = new CollectionContentPropertyX ();
  627. var l = new List<object> ();
  628. obj.ListOfItems.Add (l);
  629. for (int i = 0; i < 4; i++)
  630. l.Add (new SimpleClass ());
  631. var xr = new XamlObjectReader (obj);
  632. Read_CollectionContentPropertyX (xr, false);
  633. }
  634. [Test]
  635. [Category ("NotWorking")] // only member ordering difference, maybe.
  636. public void Read_AmbientPropertyContainer ()
  637. {
  638. var obj = new SecondTest.ResourcesDict ();
  639. var t1 = new SecondTest.TestObject ();
  640. obj.Add ("TestDictItem", t1);
  641. var t2 = new SecondTest.TestObject ();
  642. t2.TestProperty = t1;
  643. obj.Add ("okay", t2);
  644. var xr = new XamlObjectReader (obj);
  645. Read_AmbientPropertyContainer (xr, false);
  646. }
  647. [Test]
  648. [Category ("NotWorking")] // only member ordering difference, maybe.
  649. public void Read_AmbientPropertyContainer2 ()
  650. {
  651. var obj = new SecondTest.ResourcesDict ();
  652. var t1 = new SecondTest.TestObject ();
  653. obj.Add ("TestDictItem", t1);
  654. obj.Add ("okay", new SecondTest.ResourceExtension (t1));
  655. var xr = new XamlObjectReader (obj);
  656. Read_AmbientPropertyContainer (xr, true);
  657. }
  658. [Test]
  659. public void Read_NullableContainer ()
  660. {
  661. var obj = new NullableContainer () { TestProp = 5 };
  662. var xr = new XamlObjectReader (obj);
  663. Read_NullableContainer (xr);
  664. }
  665. }
  666. }