PageRenderTime 58ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://bitbucket.org/danipen/mono
C# | 1519 lines | 1281 code | 145 blank | 93 comment | 3 complexity | 8585dbd643d3750a23c347ec782d6fe9 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 class XamlObjectWriterTest
  40. {
  41. PropertyInfo str_len = typeof (string).GetProperty ("Length");
  42. XamlSchemaContext sctx = new XamlSchemaContext (null, null);
  43. XamlType xt, xt2, xt3, xt4;
  44. XamlMember xm, xm2, xm3;
  45. public XamlObjectWriterTest ()
  46. {
  47. xt = new XamlType (typeof (string), sctx);
  48. xt2 = new XamlType (typeof (List<int>), sctx);
  49. xt3 = new XamlType (typeof (TestClass1), sctx);
  50. xt4 = new XamlType (typeof (Foo), sctx);
  51. xm = new XamlMember (str_len, sctx);
  52. xm2 = new XamlMember (typeof (TestClass1).GetProperty ("TestProp1"), sctx);
  53. xm3 = new XamlMember (typeof (TestClass1).GetProperty ("TestProp2"), sctx);
  54. }
  55. public class TestClass1
  56. {
  57. public TestClass1 ()
  58. {
  59. TestProp3 = "foobar";
  60. }
  61. public string TestProp1 { get; set; }
  62. // nested.
  63. public TestClass1 TestProp2 { get; set; }
  64. public string TestProp3 { get; set; }
  65. public int TestProp4 { get; set; }
  66. }
  67. public class Foo : List<int>
  68. {
  69. public Foo ()
  70. {
  71. Bar = new List<string> ();
  72. }
  73. public List<string> Bar { get; private set; }
  74. public List<string> Baz { get; set; }
  75. public string Ext { get; set; }
  76. }
  77. [Test]
  78. [ExpectedException (typeof (ArgumentNullException))]
  79. public void SchemaContextNull ()
  80. {
  81. new XamlObjectWriter (null);
  82. }
  83. [Test]
  84. public void SettingsNull ()
  85. {
  86. // allowed.
  87. var w = new XamlObjectWriter (sctx, null);
  88. Assert.AreEqual (sctx, w.SchemaContext, "#1");
  89. }
  90. [Test]
  91. [ExpectedException (typeof (XamlObjectWriterException))]
  92. public void InitWriteEndMember ()
  93. {
  94. new XamlObjectWriter (sctx, null).WriteEndMember ();
  95. }
  96. [Test]
  97. [ExpectedException (typeof (XamlObjectWriterException))]
  98. public void InitWriteEndObject ()
  99. {
  100. new XamlObjectWriter (sctx, null).WriteEndObject ();
  101. }
  102. [Test]
  103. [ExpectedException (typeof (XamlObjectWriterException))]
  104. public void InitWriteGetObject ()
  105. {
  106. new XamlObjectWriter (sctx, null).WriteGetObject ();
  107. }
  108. [Test]
  109. [ExpectedException (typeof (XamlObjectWriterException))]
  110. public void InitWriteValue ()
  111. {
  112. new XamlObjectWriter (sctx, null).WriteValue ("foo");
  113. }
  114. [Test]
  115. [ExpectedException (typeof (XamlObjectWriterException))]
  116. public void InitWriteStartMember ()
  117. {
  118. new XamlObjectWriter (sctx, null).WriteStartMember (new XamlMember (str_len, sctx));
  119. }
  120. [Test]
  121. public void InitWriteNamespace ()
  122. {
  123. var xw = new XamlObjectWriter (sctx, null);
  124. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "x")); // ignored.
  125. xw.Close ();
  126. Assert.IsNull (xw.Result, "#1");
  127. }
  128. [Test]
  129. [ExpectedException (typeof (ArgumentNullException))]
  130. public void WriteNamespaceNull ()
  131. {
  132. new XamlObjectWriter (sctx, null).WriteNamespace (null);
  133. }
  134. [Test]
  135. public void InitWriteStartObject ()
  136. {
  137. var xw = new XamlObjectWriter (sctx, null);
  138. xw.WriteStartObject (new XamlType (typeof (int), sctx));
  139. xw.Close ();
  140. Assert.AreEqual (0, xw.Result, "#1");
  141. }
  142. [Test]
  143. [ExpectedException (typeof (XamlObjectWriterException))]
  144. public void GetObjectAfterStartObject ()
  145. {
  146. var xw = new XamlObjectWriter (sctx, null);
  147. xw.WriteStartObject (xt3);
  148. xw.WriteGetObject ();
  149. }
  150. [Test]
  151. //[ExpectedException (typeof (XamlObjectWriterException))]
  152. public void WriteStartObjectAfterTopLevel ()
  153. {
  154. var xw = new XamlObjectWriter (sctx, null);
  155. xw.WriteStartObject (xt3);
  156. xw.WriteEndObject ();
  157. // writing another root is <del>not</del> allowed.
  158. xw.WriteStartObject (xt3);
  159. }
  160. [Test]
  161. [ExpectedException (typeof (XamlObjectWriterException))]
  162. public void WriteEndObjectExcess ()
  163. {
  164. var xw = new XamlObjectWriter (sctx, null);
  165. xw.WriteStartObject (xt3);
  166. xw.WriteEndObject ();
  167. xw.WriteEndObject ();
  168. }
  169. [Test]
  170. [ExpectedException (typeof (XamlObjectWriterException))]
  171. public void StartObjectWriteEndMember ()
  172. {
  173. var xw = new XamlObjectWriter (sctx, null);
  174. xw.WriteStartObject (xt3);
  175. xw.WriteEndMember ();
  176. }
  177. [Test]
  178. public void WriteObjectAndMember ()
  179. {
  180. var xw = new XamlObjectWriter (sctx, null);
  181. xw.WriteStartObject (xt3);
  182. xw.WriteStartMember (xm2);
  183. xw.WriteValue ("foo");
  184. xw.WriteEndMember ();
  185. xw.Close ();
  186. }
  187. [Test]
  188. public void StartMemberWriteEndMember ()
  189. {
  190. var xw = new XamlObjectWriter (sctx, null);
  191. xw.WriteStartObject (xt3);
  192. xw.WriteStartMember (xm3);
  193. xw.WriteEndMember (); // unlike XamlXmlWriter, it is not treated as an error...
  194. xw.Close ();
  195. }
  196. [Test]
  197. [ExpectedException (typeof (XamlObjectWriterException))]
  198. public void StartMemberWriteStartMember ()
  199. {
  200. var xw = new XamlObjectWriter (sctx, null);
  201. xw.WriteStartObject (xt3);
  202. xw.WriteStartMember (xm3);
  203. xw.WriteStartMember (xm3);
  204. }
  205. [Test]
  206. public void WriteObjectInsideMember ()
  207. {
  208. var xw = new XamlObjectWriter (sctx, null);
  209. xw.WriteStartObject (xt3);
  210. xw.WriteStartMember (xm3);
  211. xw.WriteStartObject (xt3);
  212. xw.WriteEndObject ();
  213. xw.WriteEndMember ();
  214. xw.Close ();
  215. }
  216. [Test]
  217. [ExpectedException (typeof (XamlDuplicateMemberException))]
  218. public void ValueAfterObject ()
  219. {
  220. var xw = new XamlObjectWriter (sctx, null);
  221. xw.WriteStartObject (xt3);
  222. xw.WriteStartMember (xm3);
  223. xw.WriteStartObject (xt3);
  224. xw.WriteEndObject ();
  225. // passes here, but ...
  226. xw.WriteValue ("foo");
  227. // rejected here, unlike XamlXmlWriter.
  228. xw.WriteEndMember ();
  229. }
  230. [Test]
  231. [ExpectedException (typeof (XamlDuplicateMemberException))]
  232. public void ValueAfterObject2 ()
  233. {
  234. var xw = new XamlObjectWriter (sctx, null);
  235. xw.WriteStartObject (xt3);
  236. xw.WriteStartMember (xm3);
  237. xw.WriteStartObject (xt3);
  238. xw.WriteEndObject ();
  239. // passes here, but should be rejected later.
  240. xw.WriteValue ("foo");
  241. xw.WriteEndMember (); // Though this raises an error.
  242. }
  243. [Test]
  244. [ExpectedException (typeof (XamlDuplicateMemberException))]
  245. public void DuplicateAssignment ()
  246. {
  247. var xw = new XamlObjectWriter (sctx, null);
  248. xw.WriteStartObject (xt3);
  249. xw.WriteStartMember (xm3);
  250. xw.WriteStartObject (xt3);
  251. xw.WriteEndObject ();
  252. xw.WriteValue ("foo"); // causes duplicate assignment.
  253. xw.WriteEndMember ();
  254. }
  255. [Test]
  256. [ExpectedException (typeof (XamlDuplicateMemberException))]
  257. public void DuplicateAssignment2 ()
  258. {
  259. var xw = new XamlObjectWriter (sctx, null);
  260. xw.WriteStartObject (xt3);
  261. xw.WriteStartMember (xm3);
  262. xw.WriteStartObject (xt3);
  263. xw.WriteEndObject ();
  264. xw.WriteEndMember ();
  265. xw.WriteStartMember (xm3);
  266. }
  267. [Test]
  268. //[ExpectedException (typeof (ArgumentException))] // oh? XamlXmlWriter raises this.
  269. [Category ("NotWorking")] // so, it's not worthy of passing.
  270. public void WriteValueTypeMismatch ()
  271. {
  272. var xw = new XamlObjectWriter (sctx, null);
  273. xw.WriteStartObject (xt);
  274. xw.WriteStartMember (XamlLanguage.Initialization);
  275. xw.WriteValue (new TestClass1 ());
  276. xw.WriteEndMember ();
  277. xw.Close ();
  278. Assert.IsNotNull (xw.Result, "#1");
  279. Assert.AreEqual (typeof (TestClass1), xw.Result.GetType (), "#2");
  280. }
  281. [Test]
  282. [ExpectedException (typeof (XamlObjectWriterException))] // it fails to convert type and set property value.
  283. public void WriteValueTypeMismatch2 ()
  284. {
  285. var xw = new XamlObjectWriter (sctx, null);
  286. xw.WriteStartObject (xt3);
  287. xw.WriteStartMember (xm3);
  288. xw.WriteValue ("foo");
  289. xw.WriteEndMember ();
  290. }
  291. [Test]
  292. public void WriteValueTypeOK ()
  293. {
  294. var xw = new XamlObjectWriter (sctx, null);
  295. xw.WriteStartObject (xt);
  296. xw.WriteStartMember (XamlLanguage.Initialization);
  297. xw.WriteValue ("foo");
  298. xw.WriteEndMember ();
  299. xw.Close ();
  300. Assert.AreEqual ("foo", xw.Result, "#1");
  301. }
  302. [Test]
  303. // This behavior is different from XamlXmlWriter. Compare to XamlXmlWriterTest.WriteValueList().
  304. [Category ("NotWorking")] // not worthy of passing
  305. public void WriteValueList ()
  306. {
  307. var xw = new XamlObjectWriter (sctx, null);
  308. xw.WriteStartObject (new XamlType (typeof (List<string>), sctx));
  309. xw.WriteStartMember (XamlLanguage.Items);
  310. xw.WriteValue ("foo");
  311. xw.WriteValue ("bar");
  312. xw.WriteEndMember ();
  313. xw.Close ();
  314. var l = xw.Result as List<string>;
  315. Assert.IsNotNull (l, "#1");
  316. Assert.AreEqual ("foo", l [0], "#2");
  317. Assert.AreEqual ("bar", l [1], "#3");
  318. }
  319. // I believe .NET XamlObjectWriter.Dispose() is hack and should
  320. // be fixed to exactly determine which of End (member or object)
  321. // to call that results in this ExpectedException.
  322. // Surprisingly, PositionalParameters is allowed to be closed
  323. // without EndMember. So it smells that .NET is hacky.
  324. // We should disable this test and introduce better code (which
  325. // is already in XamlWriterInternalBase).
  326. [Test]
  327. [ExpectedException (typeof (XamlObjectWriterException))]
  328. [Ignore ("See the comment in XamlObjectWriterTest.cs")]
  329. public void CloseWithoutEndMember ()
  330. {
  331. var xw = new XamlObjectWriter (sctx, null);
  332. xw.WriteStartObject (xt);
  333. xw.WriteStartMember (XamlLanguage.Initialization);
  334. xw.WriteValue ("foo");
  335. xw.Close ();
  336. }
  337. [Test]
  338. [ExpectedException (typeof (XamlObjectWriterException))]
  339. public void WriteValueAfterValue ()
  340. {
  341. var xw = new XamlObjectWriter (sctx, null);
  342. xw.WriteStartObject (xt);
  343. xw.WriteValue ("foo");
  344. xw.WriteValue ("bar");
  345. }
  346. [Test]
  347. [ExpectedException (typeof (XamlObjectWriterException))]
  348. public void WriteValueAfterNullValue ()
  349. {
  350. var xw = new XamlObjectWriter (sctx, null);
  351. xw.WriteStartObject (xt);
  352. xw.WriteValue (null);
  353. xw.WriteValue ("bar");
  354. }
  355. [ExpectedException (typeof (XamlObjectWriterException))]
  356. public void StartMemberWriteEndObject ()
  357. {
  358. var xw = new XamlObjectWriter (sctx, null);
  359. xw.WriteStartObject (xt3);
  360. xw.WriteStartMember (xm3);
  361. xw.WriteEndObject ();
  362. }
  363. [Test]
  364. public void WriteNamespace ()
  365. {
  366. var xw = new XamlObjectWriter (sctx, null);
  367. xw.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"));
  368. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  369. xw.WriteStartObject (xt3);
  370. xw.WriteEndObject ();
  371. xw.Close ();
  372. var ret = xw.Result;
  373. Assert.IsTrue (ret is TestClass1, "#1");
  374. }
  375. [Test]
  376. [ExpectedException (typeof (XamlObjectWriterException))]
  377. public void StartObjectStartObject ()
  378. {
  379. var xw = new XamlObjectWriter (sctx, null);
  380. xw.WriteStartObject (xt3);
  381. xw.WriteStartObject (xt3);
  382. }
  383. [Test]
  384. [ExpectedException (typeof (XamlObjectWriterException))]
  385. public void StartObjectValue ()
  386. {
  387. var xw = new XamlObjectWriter (sctx, null);
  388. xw.WriteStartObject (xt3);
  389. xw.WriteValue ("foo");
  390. }
  391. [Test]
  392. [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
  393. public void ObjectContainsObjectAndObject ()
  394. {
  395. var xw = new XamlObjectWriter (sctx, null);
  396. xw.WriteStartObject (xt3);
  397. xw.WriteStartMember (xm3);
  398. xw.WriteStartObject (xt3);
  399. xw.WriteEndObject ();
  400. xw.WriteStartObject (xt3);
  401. xw.WriteEndObject (); // the exception happens *here*
  402. // FIXME: so, WriteEndMember() should not be required, but we fail here. Practically this difference should not matter.
  403. xw.WriteEndMember (); // of xm3
  404. }
  405. [Test]
  406. [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
  407. public void ObjectContainsObjectAndValue ()
  408. {
  409. var xw = new XamlObjectWriter (sctx, null);
  410. xw.WriteStartObject (xt3);
  411. xw.WriteStartMember (xm3);
  412. xw.WriteStartObject (xt3);
  413. xw.WriteEndObject ();
  414. xw.WriteValue ("foo"); // but this is allowed ...
  415. xw.WriteEndMember (); // Though this raises an error.
  416. }
  417. [Test]
  418. [ExpectedException (typeof (XamlDuplicateMemberException))] // duplicate member assignment
  419. public void ObjectContainsObjectAndValue2 ()
  420. {
  421. var xw = new XamlObjectWriter (sctx, null);
  422. xw.WriteStartObject (xt3);
  423. xw.WriteStartMember (xm3);
  424. xw.WriteStartObject (xt3);
  425. xw.WriteEndObject ();
  426. xw.WriteValue ("foo");
  427. xw.WriteEndMember (); // ... until here.
  428. }
  429. [Test]
  430. [ExpectedException (typeof (XamlObjectWriterException))] // unlike XamlXmlWriter (IOE)
  431. public void EndObjectAfterNamespace ()
  432. {
  433. var xw = new XamlObjectWriter (sctx, null);
  434. xw.WriteStartObject (xt3);
  435. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  436. xw.WriteEndObject ();
  437. }
  438. [Test]
  439. [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (throws IOE)
  440. public void WriteValueAfterNamespace ()
  441. {
  442. var xw = new XamlObjectWriter (sctx, null);
  443. xw.WriteStartObject (xt);
  444. xw.WriteStartMember (XamlLanguage.Initialization);
  445. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  446. xw.WriteValue ("foo");
  447. }
  448. [Test]
  449. [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (allowed)
  450. public void ValueThenStartObject ()
  451. {
  452. var xw = new XamlObjectWriter (sctx, null);
  453. xw.WriteStartObject (xt3);
  454. xw.WriteStartMember (xm2);
  455. xw.WriteValue ("foo");
  456. xw.WriteStartObject (xt3);
  457. xw.Close ();
  458. }
  459. [Test]
  460. [ExpectedException (typeof (XamlObjectWriterException))] // ... unlike XamlXmlWriter (allowed, as it allows StartObject after Value)
  461. public void ValueThenNamespace ()
  462. {
  463. var xw = new XamlObjectWriter (sctx, null);
  464. xw.WriteStartObject (xt3);
  465. xw.WriteStartMember (xm2);
  466. xw.WriteValue ("foo");
  467. xw.WriteNamespace (new NamespaceDeclaration ("y", "urn:foo")); // this does not raise an error (since it might start another object)
  468. }
  469. [Test]
  470. [ExpectedException (typeof (XamlObjectWriterException))] // strange, this does *not* result in IOE...
  471. public void ValueThenNamespaceThenEndMember ()
  472. {
  473. var xw = new XamlObjectWriter (sctx, null);
  474. xw.WriteStartObject (xt3);
  475. xw.WriteStartMember (xm2);
  476. xw.WriteValue ("foo");
  477. xw.WriteNamespace (new NamespaceDeclaration ("y", "urn:foo"));
  478. xw.WriteEndMember ();
  479. }
  480. [Test]
  481. [ExpectedException (typeof (XamlObjectWriterException))] // This is also very different, requires exactly opposite namespace output manner to XamlXmlWriter (namespace first, object follows).
  482. public void StartMemberAfterNamespace ()
  483. {
  484. var xw = new XamlObjectWriter (sctx, null);
  485. xw.WriteStartObject (xt3);
  486. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  487. }
  488. [Test]
  489. [Category ("NotWorking")] // not worthy of passing
  490. public void StartMemberBeforeNamespace ()
  491. {
  492. var xw = new XamlObjectWriter (sctx, null);
  493. xw.WriteStartObject (xt3);
  494. xw.WriteStartMember (xm2); // note that it should be done *after* WriteNamespace in XamlXmlWriter. SO inconsistent.
  495. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  496. xw.WriteEndMember ();
  497. xw.Close ();
  498. }
  499. [Test]
  500. [ExpectedException (typeof (XamlObjectWriterException))]
  501. public void StartMemberBeforeNamespace2 ()
  502. {
  503. var xw = new XamlObjectWriter (sctx, null);
  504. xw.WriteStartObject (xt3);
  505. xw.WriteStartMember (xm2);
  506. xw.WriteNamespace (new NamespaceDeclaration ("urn:foo", "y"));
  507. // and here, NamespaceDeclaration is written as if it
  508. // were another value object( unlike XamlXmlWriter)
  509. // and rejects further value.
  510. xw.WriteValue ("foo");
  511. }
  512. [Test]
  513. [ExpectedException (typeof (XamlObjectWriterException))]
  514. public void EndMemberThenStartObject ()
  515. {
  516. var xw = new XamlObjectWriter (sctx, null);
  517. xw.WriteStartObject (xt3);
  518. xw.WriteStartMember (xm2);
  519. xw.WriteValue ("foo");
  520. xw.WriteEndMember ();
  521. xw.WriteStartObject (xt3);
  522. }
  523. // The semantics on WriteGetObject() is VERY different from XamlXmlWriter.
  524. [Test]
  525. [ExpectedException (typeof (XamlObjectWriterException))]
  526. public void GetObjectOnNullValue ()
  527. {
  528. var xw = new XamlObjectWriter (sctx, null);
  529. xw.WriteStartObject (xt3);
  530. xw.WriteStartMember (xm2);
  531. xw.WriteGetObject ();
  532. }
  533. [Test]
  534. [ExpectedException (typeof (XamlObjectWriterException))]
  535. public void GetObjectOnNullValue2 ()
  536. {
  537. var xw = new XamlObjectWriter (sctx, null);
  538. xw.WriteStartObject (xt4);
  539. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Baz"), sctx)); // unlike Bar, Baz is not initialized.
  540. xw.WriteGetObject (); // fails, because it is null.
  541. }
  542. [Test]
  543. public void GetObjectOnIntValue ()
  544. {
  545. var xw = new XamlObjectWriter (sctx, null);
  546. xw.WriteStartObject (xt3);
  547. xw.WriteStartMember (xt3.GetMember ("TestProp4")); // int
  548. xw.WriteGetObject (); // passes!!! WTF
  549. xw.WriteEndObject ();
  550. }
  551. [Test]
  552. // String is not treated as a collection on XamlXmlWriter, while this XamlObjectWriter does.
  553. public void GetObjectOnNonNullString ()
  554. {
  555. var xw = new XamlObjectWriter (sctx, null);
  556. xw.WriteStartObject (xt3);
  557. Assert.IsNull (xw.Result, "#1");
  558. xw.WriteStartMember (xt3.GetMember ("TestProp3"));
  559. xw.WriteGetObject ();
  560. Assert.IsNull (xw.Result, "#2");
  561. }
  562. [Test]
  563. public void GetObjectOnCollection ()
  564. {
  565. var xw = new XamlObjectWriter (sctx, null);
  566. xw.WriteStartObject (xt4);
  567. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
  568. xw.WriteGetObject ();
  569. xw.Close ();
  570. }
  571. [Test]
  572. [ExpectedException (typeof (XamlObjectWriterException))]
  573. public void ValueAfterGetObject ()
  574. {
  575. var xw = new XamlObjectWriter (sctx, null);
  576. xw.WriteStartObject (xt4);
  577. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
  578. xw.WriteGetObject ();
  579. xw.WriteValue ("foo");
  580. }
  581. [Test]
  582. [ExpectedException (typeof (XamlObjectWriterException))]
  583. public void StartObjectAfterGetObject ()
  584. {
  585. var xw = new XamlObjectWriter (sctx, null);
  586. xw.WriteStartObject (xt4);
  587. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
  588. xw.WriteGetObject ();
  589. xw.WriteStartObject (xt);
  590. }
  591. [Test]
  592. [ExpectedException (typeof (XamlObjectWriterException))]
  593. public void EndMemberAfterGetObject ()
  594. {
  595. var xw = new XamlObjectWriter (sctx, null);
  596. xw.WriteStartObject (xt4);
  597. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
  598. xw.WriteGetObject ();
  599. xw.WriteEndMember (); // ...!?
  600. }
  601. [Test]
  602. public void StartMemberAfterGetObject ()
  603. {
  604. var xw = new XamlObjectWriter (sctx, null);
  605. xw.WriteStartObject (xt4);
  606. var xmm = xt4.GetMember ("Bar");
  607. xw.WriteStartMember (xmm); // <List.Bar>
  608. xw.WriteGetObject (); // shifts current member to List<T>.
  609. xw.WriteStartMember (xmm.Type.GetMember ("Capacity"));
  610. xw.WriteValue (5);
  611. xw.WriteEndMember ();
  612. /*
  613. xw.WriteEndObject (); // got object
  614. xw.WriteEndMember (); // Bar
  615. xw.WriteEndObject (); // started object
  616. */
  617. xw.Close ();
  618. }
  619. [Test]
  620. public void EndObjectAfterGetObject ()
  621. {
  622. var xw = new XamlObjectWriter (sctx, null);
  623. xw.WriteStartObject (xt4);
  624. xw.WriteStartMember (new XamlMember (typeof (Foo).GetProperty ("Bar"), sctx));
  625. xw.WriteGetObject ();
  626. xw.WriteEndObject ();
  627. }
  628. [Test]
  629. public void WriteAttachableProperty ()
  630. {
  631. Attached2 result = null;
  632. var rsettings = new XamlXmlReaderSettings ();
  633. using (var reader = new XamlXmlReader (new StringReader (String.Format (@"<Attached2 AttachedWrapper3.Property=""Test"" xmlns=""clr-namespace:MonoTests.System.Xaml;assembly={0}""></Attached2>", typeof (AttachedWrapper3).Assembly.GetName ().Name)), rsettings)) {
  634. var wsettings = new XamlObjectWriterSettings ();
  635. using (var writer = new XamlObjectWriter (reader.SchemaContext, wsettings)) {
  636. XamlServices.Transform (reader, writer, false);
  637. result = (Attached2) writer.Result;
  638. }
  639. }
  640. Assert.AreEqual ("Test", result.Property, "#1");
  641. }
  642. [Test]
  643. public void OnSetValueAndHandledFalse () // part of bug #3003
  644. {
  645. #if NET_4_5
  646. string ver = "net_4_5";
  647. #else
  648. string ver = "net_4_0";
  649. #endif
  650. /*
  651. var obj = new TestClass3 ();
  652. obj.Nested = new TestClass3 ();
  653. var sw = new StringWriter ();
  654. var xxw = new XamlXmlWriter (XmlWriter.Create (sw), new XamlSchemaContext ());
  655. XamlServices.Transform (new XamlObjectReader (obj), xxw);
  656. Console.Error.WriteLine (sw);
  657. */
  658. var xml = "<TestClass3 xmlns='clr-namespace:MonoTests.System.Xaml;assembly=System.Xaml_test_net_4_0' xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'><TestClass3.Nested><TestClass3 Nested='{x:Null}' /></TestClass3.Nested></TestClass3>".Replace ("net_4_0", ver);
  659. var settings = new XamlObjectWriterSettings ();
  660. bool invoked = false;
  661. settings.XamlSetValueHandler = (sender, e) => {
  662. invoked = true;
  663. Assert.IsNotNull (sender, "#1");
  664. Assert.AreEqual (typeof (TestClass3), sender.GetType (), "#2");
  665. Assert.AreEqual ("Nested", e.Member.Name, "#3");
  666. Assert.IsTrue (sender != e.Member.Invoker.GetValue (sender), "#4");
  667. Assert.IsFalse (e.Handled, "#5");
  668. // ... and leave Handled as false, to invoke the actual setter
  669. };
  670. var xow = new XamlObjectWriter (new XamlSchemaContext (), settings);
  671. var xxr = new XamlXmlReader (XmlReader.Create (new StringReader (xml)));
  672. XamlServices.Transform (xxr, xow);
  673. Assert.IsTrue (invoked, "#6");
  674. Assert.IsNotNull (xow.Result, "#7");
  675. var ret = xow.Result as TestClass3;
  676. Assert.IsNotNull (ret.Nested, "#8");
  677. }
  678. [Test] // bug #3003 repro
  679. public void EventsAndProcessingOrder ()
  680. {
  681. var asm = Assembly.GetExecutingAssembly ();
  682. var context = new XamlSchemaContext (new Assembly [] { asm });
  683. var output = XamarinBug3003.TestContext.Writer;
  684. output.WriteLine ();
  685. var reader = new XamlXmlReader (XmlReader.Create (new StringReader (XamarinBug3003.TestContext.XmlInput)), context);
  686. var writerSettings = new XamlObjectWriterSettings ();
  687. writerSettings.AfterBeginInitHandler = (sender, e) => {
  688. output.WriteLine ("XamlObjectWriterSettings.AfterBeginInit: {0}", e.Instance);
  689. };
  690. writerSettings.AfterEndInitHandler = (sender, e) => {
  691. output.WriteLine ("XamlObjectWriterSettings.AfterEndInit: {0}", e.Instance);
  692. };
  693. writerSettings.BeforePropertiesHandler = (sender, e) => {
  694. output.WriteLine ("XamlObjectWriterSettings.BeforeProperties: {0}", e.Instance);
  695. };
  696. writerSettings.AfterPropertiesHandler = (sender, e) => {
  697. output.WriteLine ("XamlObjectWriterSettings.AfterProperties: {0}", e.Instance);
  698. };
  699. writerSettings.XamlSetValueHandler = (sender, e) => {
  700. output.WriteLine ("XamlObjectWriterSettings.XamlSetValue: {0}, Member: {1}", e.Value, e.Member.Name);
  701. };
  702. var writer = new XamlObjectWriter (context, writerSettings);
  703. XamlServices.Transform (reader, writer);
  704. var obj = writer.Result as XamarinBug3003.Parent;
  705. output.WriteLine ("Loaded {0}", obj);
  706. Assert.AreEqual (XamarinBug3003.TestContext.ExpectedResult.Replace ("\r\n", "\n"), output.ToString ().Replace ("\r\n", "\n"), "#1");
  707. Assert.AreEqual (2, obj.Children.Count, "#2");
  708. }
  709. // extra use case based tests.
  710. [Test]
  711. public void WriteEx_Type_WriteString ()
  712. {
  713. var ow = new XamlObjectWriter (sctx);
  714. ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
  715. ));
  716. ow.WriteStartObject (XamlLanguage.Type);
  717. ow.WriteStartMember (XamlLanguage.PositionalParameters);
  718. ow.WriteValue ("x:Int32");
  719. ow.Close ();
  720. Assert.AreEqual (typeof (int), ow.Result, "#1");
  721. }
  722. [Test]
  723. public void WriteEx_Type_WriteType ()
  724. {
  725. var ow = new XamlObjectWriter (sctx);
  726. ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
  727. ));
  728. ow.WriteStartObject (XamlLanguage.Type);
  729. ow.WriteStartMember (XamlLanguage.PositionalParameters);
  730. ow.WriteValue (typeof (int));
  731. ow.Close ();
  732. Assert.AreEqual (typeof (int), ow.Result, "#1");
  733. }
  734. [Test]
  735. public void LookupCorrectEventBoundMethod ()
  736. {
  737. var o = (XamarinBug2927.MyRootClass) XamlServices.Load (GetReader ("LookupCorrectEvent.xml"));
  738. o.Child.Descendant.Work ();
  739. Assert.IsTrue (o.Invoked, "#1");
  740. Assert.IsFalse (o.Child.Invoked, "#2");
  741. Assert.IsFalse (o.Child.Descendant.Invoked, "#3");
  742. }
  743. [Test]
  744. [ExpectedException (typeof (XamlObjectWriterException))]
  745. public void LookupCorrectEventBoundMethod2 ()
  746. {
  747. XamlServices.Load (GetReader ("LookupCorrectEvent2.xml"));
  748. }
  749. [Test]
  750. public void LookupCorrectEventBoundMethod3 ()
  751. {
  752. XamlServices.Load (GetReader ("LookupCorrectEvent3.xml"));
  753. }
  754. // common use case based tests (to other readers/writers).
  755. XamlReader GetReader (string filename)
  756. {
  757. #if NET_4_5
  758. string ver = "net_4_5";
  759. #else
  760. string ver = "net_4_0";
  761. #endif
  762. string xml = File.ReadAllText (Path.Combine ("Test/XmlFiles", filename)).Replace ("net_4_0", ver);
  763. return new XamlXmlReader (XmlReader.Create (new StringReader (xml)));
  764. }
  765. [Test]
  766. public void Write_String ()
  767. {
  768. using (var xr = GetReader ("String.xml")) {
  769. var des = XamlServices.Load (xr);
  770. Assert.AreEqual ("foo", des, "#1");
  771. }
  772. }
  773. [Test]
  774. public void Write_Int32 ()
  775. {
  776. using (var xr = GetReader ("Int32.xml")) {
  777. var des = XamlServices.Load (xr);
  778. Assert.AreEqual (5, des, "#1");
  779. }
  780. }
  781. [Test]
  782. public void Write_DateTime ()
  783. {
  784. using (var xr = GetReader ("DateTime.xml")) {
  785. var des = XamlServices.Load (xr);
  786. Assert.AreEqual (new DateTime (2010, 4, 14), des, "#1");
  787. }
  788. }
  789. [Test]
  790. public void Write_TimeSpan ()
  791. {
  792. using (var xr = GetReader ("TimeSpan.xml")) {
  793. var des = XamlServices.Load (xr);
  794. Assert.AreEqual (TimeSpan.FromMinutes (7), des, "#1");
  795. }
  796. }
  797. [Test]
  798. public void Write_Uri ()
  799. {
  800. using (var xr = GetReader ("Uri.xml")) {
  801. var des = XamlServices.Load (xr);
  802. Assert.AreEqual (new Uri ("urn:foo"), des, "#1");
  803. }
  804. }
  805. [Test]
  806. public void Write_Null ()
  807. {
  808. using (var xr = GetReader ("NullExtension.xml")) {
  809. var des = XamlServices.Load (xr);
  810. Assert.IsNull (des, "#1");
  811. }
  812. }
  813. [Test]
  814. public void Write_Type ()
  815. {
  816. using (var xr = GetReader ("Type.xml")) {
  817. var des = XamlServices.Load (xr);
  818. Assert.AreEqual (typeof (int), des, "#1");
  819. }
  820. }
  821. [Test]
  822. public void Write_Type2 ()
  823. {
  824. var obj = typeof (MonoTests.System.Xaml.TestClass1);
  825. using (var xr = GetReader ("Type2.xml")) {
  826. var des = XamlServices.Load (xr);
  827. Assert.AreEqual (obj, des, "#1");
  828. }
  829. }
  830. [Test]
  831. public void Write_Guid ()
  832. {
  833. var obj = Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09");
  834. using (var xr = GetReader ("Guid.xml")) {
  835. var des = XamlServices.Load (xr);
  836. Assert.AreEqual (obj, des, "#1");
  837. }
  838. }
  839. [Test]
  840. public void Write_GuidFactoryMethod ()
  841. {
  842. var obj = Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09");
  843. using (var xr = GetReader ("GuidFactoryMethod.xml")) {
  844. var des = XamlServices.Load (xr);
  845. Assert.AreEqual (obj, des, "#1");
  846. }
  847. }
  848. [Test]
  849. [ExpectedException (typeof (XamlObjectWriterException))] // cannot resolve the StaticExtension value.
  850. public void Write_StaticExtension ()
  851. {
  852. var obj = new StaticExtension ("FooBar");
  853. using (var xr = GetReader ("StaticExtension.xml")) {
  854. var des = XamlServices.Load (xr);
  855. Assert.AreEqual (obj, des, "#1");
  856. }
  857. }
  858. [Test]
  859. [Ignore ("Not sure why MemberType is NOT serialized. Needs investigation")]
  860. public void Write_StaticExtension2 ()
  861. {
  862. var obj = new StaticExtension ("FooBar"); //incorrect
  863. using (var xr = GetReader ("StaticExtension2.xml")) {
  864. var des = XamlServices.Load (xr);
  865. Assert.AreEqual (obj, des, "#1");
  866. }
  867. }
  868. [Test]
  869. public void Write_Reference ()
  870. {
  871. using (var xr = GetReader ("Reference.xml")) {
  872. var des = XamlServices.Load (xr);
  873. // .NET does not return Reference.
  874. // Its ProvideValue() returns MS.Internal.Xaml.Context.NameFixupToken,
  875. // which is assumed (by name) to resolve to the referenced object.
  876. Assert.IsNotNull (des, "#1");
  877. //Assert.AreEqual (new Reference ("FooBar"), des, "#1");
  878. }
  879. }
  880. [Test]
  881. public void Write_ArrayInt32 ()
  882. {
  883. var obj = new int [] {4, -5, 0, 255, int.MaxValue};
  884. using (var xr = GetReader ("Array_Int32.xml")) {
  885. var des = XamlServices.Load (xr);
  886. Assert.AreEqual (obj, des, "#1");
  887. }
  888. }
  889. [Test]
  890. public void Write_ListInt32 ()
  891. {
  892. var obj = new int [] {5, -3, int.MaxValue, 0}.ToList ();
  893. using (var xr = GetReader ("List_Int32.xml")) {
  894. var des = (List<int>) XamlServices.Load (xr);
  895. Assert.AreEqual (obj.ToArray (), des.ToArray (), "#1");
  896. }
  897. }
  898. [Test]
  899. public void Write_ListInt32_2 ()
  900. {
  901. var obj = new List<int> (new int [0]) { Capacity = 0 }; // set explicit capacity for trivial implementation difference
  902. using (var xr = GetReader ("List_Int32_2.xml")) {
  903. var des = (List<int>) XamlServices.Load (xr);
  904. Assert.AreEqual (obj.ToArray (), des.ToArray (), "#1");
  905. }
  906. }
  907. [Test]
  908. public void Write_ListType ()
  909. {
  910. var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
  911. using (var xr = GetReader ("List_Type.xml")) {
  912. var des = XamlServices.Load (xr);
  913. Assert.AreEqual (obj, des, "#1");
  914. }
  915. }
  916. [Test]
  917. public void Write_ListArray ()
  918. {
  919. var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
  920. using (var xr = GetReader ("List_Array.xml")) {
  921. var des = (List<Array>) XamlServices.Load (xr);
  922. Assert.AreEqual (obj, des, "#1");
  923. }
  924. }
  925. [Test]
  926. public void Write_DictionaryInt32String ()
  927. {
  928. var dic = new Dictionary<int,string> ();
  929. dic.Add (0, "foo");
  930. dic.Add (5, "bar");
  931. dic.Add (-2, "baz");
  932. using (var xr = GetReader ("Dictionary_Int32_String.xml")) {
  933. var des = XamlServices.Load (xr);
  934. Assert.AreEqual (dic, des, "#1");
  935. }
  936. }
  937. [Test]
  938. public void Write_DictionaryStringType ()
  939. {
  940. var dic = new Dictionary<string,Type> ();
  941. dic.Add ("t1", typeof (int));
  942. dic.Add ("t2", typeof (int []));
  943. dic.Add ("t3", typeof (int?));
  944. dic.Add ("t4", typeof (List<int>));
  945. dic.Add ("t5", typeof (Dictionary<int,DateTime>));
  946. dic.Add ("t6", typeof (List<KeyValuePair<int,DateTime>>));
  947. using (var xr = GetReader ("Dictionary_String_Type.xml")) {
  948. var des = XamlServices.Load (xr);
  949. Assert.AreEqual (dic, des, "#1");
  950. }
  951. }
  952. [Test]
  953. [Ignore ("Needs to get successfully deserialized. Currently we can't")]
  954. public void Write_PositionalParameters1Wrapper ()
  955. {
  956. // Unlike the above case, this has the wrapper object and hence PositionalParametersClass1 can be written as an attribute (markup extension)
  957. var obj = new PositionalParametersWrapper ("foo", 5);
  958. using (var xr = GetReader ("PositionalParametersWrapper.xml")) {
  959. var des = XamlServices.Load (xr);
  960. Assert.AreEqual (obj, des, "#1");
  961. }
  962. }
  963. [Test]
  964. public void Write_ArgumentAttributed ()
  965. {
  966. //var obj = new ArgumentAttributed ("foo", "bar");
  967. using (var xr = GetReader ("ArgumentAttributed.xml")) {
  968. var des = (ArgumentAttributed) XamlServices.Load (xr);
  969. Assert.AreEqual ("foo", des.Arg1, "#1");
  970. Assert.AreEqual ("bar", des.Arg2, "#2");
  971. }
  972. }
  973. [Test]
  974. public void Write_ArrayExtension2 ()
  975. {
  976. //var obj = new ArrayExtension (typeof (int));
  977. using (var xr = GetReader ("ArrayExtension2.xml")) {
  978. var des = XamlServices.Load (xr);
  979. // The resulting object is not ArrayExtension.
  980. Assert.AreEqual (new int [0], des, "#1");
  981. }
  982. }
  983. [Test]
  984. public void Write_ArrayList ()
  985. {
  986. var obj = new ArrayList (new int [] {5, -3, 0});
  987. using (var xr = GetReader ("ArrayList.xml")) {
  988. var des = XamlServices.Load (xr);
  989. Assert.AreEqual (obj, des, "#1");
  990. }
  991. }
  992. [Test]
  993. [Ignore ("Needs to get successfully deserialized. Currently we can't")]
  994. public void ComplexPositionalParameterWrapper ()
  995. {
  996. //var obj = new ComplexPositionalParameterWrapper () { Param = new ComplexPositionalParameterClass (new ComplexPositionalParameterValue () { Foo = "foo" })};
  997. using (var xr = GetReader ("ComplexPositionalParameterWrapper.xml")) {
  998. var des = (ComplexPositionalParameterWrapper) XamlServices.Load (xr);
  999. Assert.IsNotNull (des.Param, "#1");
  1000. Assert.AreEqual ("foo", des.Param.Value, "#2");
  1001. }
  1002. }
  1003. [Test]
  1004. public void Write_ListWrapper ()
  1005. {
  1006. var obj = new ListWrapper (new List<int> (new int [] {5, -3, 0}) { Capacity = 3}); // set explicit capacity for trivial implementation difference
  1007. using (var xr = GetReader ("ListWrapper.xml")) {
  1008. var des = (ListWrapper) XamlServices.Load (xr);
  1009. Assert.IsNotNull (des, "#1");
  1010. Assert.IsNotNull (des.Items, "#2");
  1011. Assert.AreEqual (obj.Items.ToArray (), des.Items.ToArray (), "#3");
  1012. }
  1013. }
  1014. [Test]
  1015. public void Write_ListWrapper2 ()
  1016. {
  1017. var obj = new ListWrapper2 (new List<int> (new int [] {5, -3, 0}) { Capacity = 3}); // set explicit capacity for trivial implementation difference
  1018. using (var xr = GetReader ("ListWrapper2.xml")) {
  1019. var des = (ListWrapper2) XamlServices.Load (xr);
  1020. Assert.IsNotNull (des, "#1");
  1021. Assert.IsNotNull (des.Items, "#2");
  1022. Assert.AreEqual (obj.Items.ToArray (), des.Items.ToArray (), "#3");
  1023. }
  1024. }
  1025. [Test]
  1026. public void Write_MyArrayExtension ()
  1027. {
  1028. //var obj = new MyArrayExtension (new int [] {5, -3, 0});
  1029. using (var xr = GetReader ("MyArrayExtension.xml")) {
  1030. var des = XamlServices.Load (xr);
  1031. // ProvideValue() returns an array
  1032. Assert.AreEqual (new int [] {5, -3, 0}, des, "#1");
  1033. }
  1034. }
  1035. [Test]
  1036. public void Write_MyArrayExtensionA ()
  1037. {
  1038. //var obj = new MyArrayExtensionA (new int [] {5, -3, 0});
  1039. using (var xr = GetReader ("MyArrayExtensionA.xml")) {
  1040. var des = XamlServices.Load (xr);
  1041. // ProvideValue() returns an array
  1042. Assert.AreEqual (new int [] {5, -3, 0}, des, "#1");
  1043. }
  1044. }
  1045. [Test]
  1046. public void Write_MyExtension ()
  1047. {
  1048. //var obj = new MyExtension () { Foo = typeof (int), Bar = "v2", Baz = "v7"};
  1049. using (var xr = GetReader ("MyExtension.xml")) {
  1050. var des = XamlServices.Load (xr);
  1051. // ProvideValue() returns this.
  1052. Assert.AreEqual ("provided_value", des, "#1");
  1053. }
  1054. }
  1055. [Test]
  1056. [ExpectedException (typeof (InvalidCastException))] // unable to cast string to MarkupExtension
  1057. [Category ("NotWorking")]
  1058. public void Write_MyExtension2 ()
  1059. {
  1060. //var obj = new MyExtension2 () { Foo = typeof (int), Bar = "v2"};
  1061. using (var xr = GetReader ("MyExtension2.xml")) {
  1062. XamlServices.Load (xr);
  1063. }
  1064. }
  1065. [Test]
  1066. public void Write_MyExtension3 ()
  1067. {
  1068. //var obj = new MyExtension3 () { Foo = typeof (int), Bar = "v2"};
  1069. using (var xr = GetReader ("MyExtension3.xml")) {
  1070. var des = XamlServices.Load (xr);
  1071. // StringConverter is used and the resulting value comes from ToString().
  1072. Assert.AreEqual ("MonoTests.System.Xaml.MyExtension3", des, "#1");
  1073. }
  1074. }
  1075. [Test]
  1076. [ExpectedException (typeof (XamlObjectWriterException))] // wrong TypeConverter input (input string for DateTimeConverter invalid)
  1077. public void Write_MyExtension4 ()
  1078. {
  1079. var obj = new MyExtension4 () { Foo = typeof (int), Bar = "v2"};
  1080. using (var xr = GetReader ("MyExtension4.xml")) {
  1081. var des = XamlServices.Load (xr);
  1082. Assert.AreEqual (obj, des, "#1");
  1083. }
  1084. }
  1085. [Test]
  1086. public void Write_MyExtension6 ()
  1087. {
  1088. //var obj = new MyExtension6 ("foo");
  1089. using (var xr = GetReader ("MyExtension6.xml")) {
  1090. var des = XamlServices.Load (xr);
  1091. // ProvideValue() returns this.
  1092. Assert.AreEqual ("foo", des, "#1");
  1093. }
  1094. }
  1095. [Test]
  1096. public void Write_PropertyDefinition ()
  1097. {
  1098. //var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
  1099. using (var xr = GetReader ("PropertyDefinition.xml")) {
  1100. var des = (PropertyDefinition) XamlServices.Load (xr);
  1101. Assert.AreEqual ("protected", des.Modifier, "#1");
  1102. Assert.AreEqual ("foo", des.Name, "#2");
  1103. Assert.AreEqual (XamlLanguage.String, des.Type, "#3");
  1104. }
  1105. }
  1106. [Test]
  1107. [Ignore ("this still does not give successful deserialization result - should there be any way?")]
  1108. public void Write_StaticExtensionWrapper ()
  1109. {
  1110. //var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("Foo") };
  1111. using (var xr = GetReader ("StaticExtensionWrapper.xml")) {
  1112. var des = (StaticExtensionWrapper) XamlServices.Load (xr);
  1113. Assert.IsNotNull (des.Param, "#1");
  1114. Assert.AreEqual ("Foo", des.Param.Member, "#2");
  1115. }
  1116. }
  1117. [Test]
  1118. [Ignore ("this still does not give successful deserialization result - should there be any way?")]
  1119. public void Write_TypeExtensionWrapper ()
  1120. {
  1121. //var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
  1122. using (var xr = GetReader ("TypeExtensionWrapper.xml")) {
  1123. var des = (TypeExtensionWrapper) XamlServices.Load (xr);
  1124. Assert.IsNotNull (des.Param, "#1");
  1125. // TypeName was not serialized into xml, hence deserialized as empty.
  1126. Assert.AreEqual (String.Empty, des.Param.TypeName, "#2");
  1127. }
  1128. }
  1129. [Test]
  1130. public void Write_NamedItems ()
  1131. {
  1132. // foo
  1133. // - bar
  1134. // -- foo
  1135. // - baz
  1136. var obj = new NamedItem ("foo");
  1137. var obj2 = new NamedItem ("bar");
  1138. obj.References.Add (obj2);
  1139. obj.References.Add (new NamedItem ("baz"));
  1140. obj2.References.Add (obj);
  1141. using (var xr = GetReader ("NamedItems.xml")) {
  1142. var des = (NamedItem) XamlServices.Load (xr);
  1143. Assert.IsNotNull (des, "#1");
  1144. Assert.AreEqual (2, des.References.Count, "#2");
  1145. Assert.AreEqual (typeof (NamedItem), des.References [0].GetType (), "#3");
  1146. Assert.AreEqual (typeof (NamedItem), des.References [1].GetType (), "#4");
  1147. Assert.AreEqual (des, des.References [0].References [0], "#5");
  1148. }
  1149. }
  1150. [Test]
  1151. public void Write_NamedItems2 ()
  1152. {
  1153. // i1
  1154. // - i2
  1155. // -- i3
  1156. // - i4
  1157. // -- i3
  1158. var obj = new NamedItem2 ("i1");
  1159. var obj2 = new NamedItem2 ("i2");
  1160. var obj3 = new NamedItem2 ("i3");
  1161. var obj4 = new NamedItem2 ("i4");
  1162. obj.References.Add (obj2);
  1163. obj.References.Add (obj4);
  1164. obj2.References.Add (obj3);
  1165. obj4.References.Add (obj3);
  1166. using (var xr = GetReader ("NamedItems2.xml")) {
  1167. var des = (NamedItem2) XamlServices.Load (xr);
  1168. Assert.IsNotNull (des, "#1");
  1169. Assert.AreEqual (2, des.References.Count, "#2");
  1170. Assert.AreEqual (typeof (NamedItem2), des.References [0].GetType (), "#3");
  1171. Assert.AreEqual (typeof (NamedItem2), des.References [1].GetType (), "#4");
  1172. Assert.AreEqual (1, des.References [0].References.Count, "#5");
  1173. Assert.AreEqual (1, des.References [1].References.Count, "#6");
  1174. Assert.AreEqual (des.References [0].References [0], des.References [1].References [0], "#7");
  1175. }
  1176. }
  1177. [Test]
  1178. public void Write_XmlSerializableWrapper ()
  1179. {
  1180. var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
  1181. using (var xr = GetReader ("XmlSerializableWrapper.xml")) {
  1182. var des = (XmlSerializableWrapper) XamlServices.Load (xr);
  1183. Assert.IsNotNull (des, "#1");
  1184. Assert.IsNotNull (des.Value, "#2");
  1185. Assert.AreEqual ("<root xmlns=\"" + assns + "\" />", des.Value.GetRaw (), "#3");
  1186. }
  1187. }
  1188. [Test]
  1189. public void Write_XmlSerializable ()
  1190. {
  1191. using (var xr = GetReader ("XmlSerializable.xml")) {
  1192. var des = (XmlSerializable) XamlServices.Load (xr);
  1193. Assert.IsNotNull (des, "#1");
  1194. }
  1195. }
  1196. [Test]
  1197. public void Write_ListXmlSerializable ()
  1198. {
  1199. using (var xr = GetReader ("List_XmlSerializable.xml")) {
  1200. var des = (List<XmlSerializable>) XamlServices.Load (xr);
  1201. Assert.AreEqual (1, des.Count, "#1");
  1202. }
  1203. }
  1204. [Test]
  1205. public void Write_AttachedProperty ()
  1206. {
  1207. using (var xr = GetReader ("AttachedProperty.xml")) {
  1208. AttachedWrapper des = null;
  1209. try {
  1210. des = (AttachedWrapper) XamlServices.Load (xr);
  1211. Assert.IsNotNull (des.Value, "#1");
  1212. Assert.AreEqual ("x", Attachable.GetFoo (des), "#2");
  1213. Assert.AreEqual ("y", Attachable.GetFoo (des.Value), "#3");
  1214. } finally {
  1215. if (des != null) {
  1216. Attachable.SetFoo (des, null);
  1217. Attachable.SetFoo (des.Value, null);
  1218. }
  1219. }
  1220. }
  1221. }
  1222. [Test]
  1223. public void Write_EventStore ()
  1224. {
  1225. using (var xr = GetReader ("EventStore.xml")) {
  1226. var res = (EventStore) XamlServices.Load (xr);
  1227. Assert.AreEqual ("foo", res.Examine (), "#1");
  1228. Assert.IsTrue (res.Method1Invoked, "#2");
  1229. }
  1230. }
  1231. [Test]
  1232. [ExpectedException (typeof (XamlDuplicateMemberException))] // for two occurence of Event1 ...
  1233. public void Write_EventStore2 ()
  1234. {
  1235. using (var xr = GetReader ("EventStore2.xml")) {
  1236. XamlServices.Load (xr);
  1237. }
  1238. }
  1239. [Test]
  1240. [ExpectedException (typeof (XamlObjectWriterException))] // attaching nonexistent method
  1241. public void Write_EventStore3 ()
  1242. {
  1243. using (var xr = GetReader ("EventStore3.xml")) {
  1244. XamlServices.Load (xr);
  1245. }
  1246. }
  1247. [Test]
  1248. [Category ("NotWorking")] // type resolution failure.
  1249. public void Write_EventStore4 ()
  1250. {
  1251. using (var xr = GetReader ("EventStore4.xml")) {
  1252. var res = (EventStore2<EventArgs>) XamlServices.Load (xr);
  1253. Assert.AreEqual ("foo", res.Examine (), "#1");
  1254. Assert.IsTrue (res.Method1Invoked, "#2");
  1255. }
  1256. }
  1257. [Test]
  1258. public void Write_AbstractWrapper ()
  1259. {
  1260. using (var xr = GetReader ("AbstractContainer.xml")) {
  1261. var res = (AbstractContainer) XamlServices.Load (xr);
  1262. Assert.IsNull (res.Value1, "#1");
  1263. Assert.IsNotNull (res.Value2, "#2");
  1264. Assert.AreEqual ("x", res.Value2.Foo, "#3");
  1265. }
  1266. }
  1267. [Test]
  1268. public void Write_ReadOnlyPropertyContainer ()
  1269. {
  1270. using (var xr = GetReader ("ReadOnlyPropertyContainer.xml")) {
  1271. var res = (ReadOnlyPropertyContainer) XamlServices.Load (xr);
  1272. Assert.AreEqual ("x", res.Foo, "#1");
  1273. Assert.AreEqual ("x", res.Bar, "#2");
  1274. }
  1275. }
  1276. [Test]
  1277. public void Write_TypeConverterOnListMember ()
  1278. {
  1279. using (var xr = GetReader ("TypeConverterOnListMember.xml")) {
  1280. var res = (SecondTest.TypeOtherAssembly) XamlServices.Load (xr);
  1281. Assert.AreEqual (3, res.Values.Count, "#1");
  1282. Assert.AreEqual (3, res.Values [2], "#2");
  1283. }
  1284. }
  1285. [Test]
  1286. public void Write_EnumContainer ()
  1287. {
  1288. using (var xr = GetReader ("EnumContainer.xml")) {
  1289. var res = (EnumContainer) XamlServices.Load (xr);
  1290. Assert.AreEqual (EnumValueType.Two, res.EnumProperty, "#1");
  1291. }
  1292. }
  1293. [Test]
  1294. public void Write_CollectionContentProperty ()
  1295. {
  1296. using (var xr = GetReader ("CollectionContentProperty.xml")) {
  1297. var res = (CollectionContentProperty) XamlServices.Load (xr);
  1298. Assert.AreEqual (4, res.ListOfItems.Count, "#1");
  1299. }
  1300. }
  1301. [Test]
  1302. public void Write_CollectionContentProperty2 ()
  1303. {
  1304. using (var xr = GetReader ("CollectionContentProperty2.xml")) {
  1305. var res = (CollectionContentProperty) XamlServices.Load (xr);
  1306. Assert.AreEqual (4, res.ListOfItems.Count, "#1");
  1307. }
  1308. }
  1309. [Test]
  1310. public void Write_AmbientPropertyContainer ()
  1311. {
  1312. using (var xr = GetReader ("AmbientPropertyContainer.xml")) {
  1313. var res = (SecondTest.ResourcesDict) XamlServices.Load (xr);
  1314. Assert.AreEqual (2, res.Count, "#1");
  1315. Assert.IsTrue (res.ContainsKey ("TestDictItem"), "#2");
  1316. Assert.IsTrue (res.ContainsKey ("okay"), "#3");
  1317. var i1 = res ["TestDictItem"] as SecondTest.TestObject;
  1318. Assert.IsNull (i1.TestProperty, "#4");
  1319. var i2 = res ["okay"] as SecondTest.TestObject;
  1320. Assert.AreEqual (i1, i2.TestProperty, "#5");
  1321. }
  1322. }
  1323. [Test] // bug #682102
  1324. public void Write_AmbientPropertyContainer2 ()
  1325. {
  1326. using (var xr = GetReader ("AmbientPropertyContainer2.xml")) {
  1327. var res = (SecondTest.ResourcesDict) XamlServices.Load (xr);
  1328. Assert.AreEqual (2, res.Count, "#1");
  1329. Assert.IsTrue (res.ContainsKey ("TestDictItem"), "#2");
  1330. Assert.IsTrue (res.ContainsKey ("okay"), "#3");
  1331. var i1 = res ["TestDictItem"] as SecondTest.TestObject;
  1332. Assert.IsNull (i1.TestProperty, "#4");
  1333. var i2 = res ["okay"] as SecondTest.TestObject;
  1334. Assert.AreEqual (i1, i2.TestProperty, "#5");
  1335. }
  1336. }
  1337. [Test]
  1338. public void Write_NullableContainer ()
  1339. {
  1340. using (var xr = GetReader ("NullableContainer.xml")) {
  1341. var res = (NullableContainer) XamlServices.Load (xr);
  1342. Assert.AreEqual (5, res.TestProp, "#1");
  1343. }
  1344. }
  1345. [Test]
  1346. public void Write_DirectListContainer ()
  1347. {
  1348. using (var xr = GetReader ("DirectListContainer.xml")) {
  1349. var res = (DirectListContainer) XamlServices.Load (xr);
  1350. Assert.AreEqual (3, res.Items.Count, "#1");
  1351. Assert.AreEqual ("Hello3", res.Items [2].Value, "#2");
  1352. }
  1353. }
  1354. [Test]
  1355. public void Write_DirectDictionaryContainer ()
  1356. {
  1357. using (var xr = GetReader ("DirectDictionaryContainer.xml")) {
  1358. var res = (DirectDictionaryContainer) XamlServices.Load (xr);
  1359. Assert.AreEqual (3, res.Items.Count, "#1");
  1360. Assert.AreEqual (40, res.Items [EnumValueType.Three], "#2");
  1361. }
  1362. }
  1363. [Test]
  1364. public void Write_DirectDictionaryContainer2 ()
  1365. {
  1366. using (var xr = GetReader ("DirectDictionaryContainer2.xml")) {
  1367. var res = (SecondTest.ResourcesDict2) XamlServices.Load (xr);
  1368. Assert.AreEqual (2, res.Count, "#1");
  1369. Assert.AreEqual ("1", ((SecondTest.TestObject2) res ["1"]).TestProperty, "#2");
  1370. Assert.AreEqual ("two", ((SecondTest.TestObject2) res ["two"]).TestProperty, "#3");
  1371. }
  1372. }
  1373. }
  1374. }