// passes here, but ...
xw.WriteValue ("foo");
// rejected here, unlike XamlXmlWriter.
- //
- // Basically, assume that no content could be written
- // for an object member within XamlObjectWriter.
xw.WriteEndMember ();
}
[Test]
[ExpectedException (typeof (XamlDuplicateMemberException))]
- [Category ("NotWorking")]
public void DuplicateAssignment2 ()
{
var xw = new XamlObjectWriter (sctx, null);
[Test]
// This behavior is different from XamlXmlWriter. Compare to XamlXmlWriterTest.WriteValueList().
+ [Category ("NotWorking")] // not worthy of passing
public void WriteValueList ()
{
var xw = new XamlObjectWriter (sctx, null);
Assert.AreEqual ("bar", l [1], "#3");
}
+ // I believe .NET XamlObjectWriter.Dispose() is hack and should
+ // be fixed to exactly determine which of End (member or object)
+ // to call that results in this ExpectedException.
+ // Surprisingly, PositionalParameters is allowed to be closed
+ // without EndMember. So it smells that .NET is hacky.
+ // We should disable this test and introduce better code (which
+ // is already in XamlWriterInternalBase).
[Test]
[ExpectedException (typeof (XamlObjectWriterException))]
+ [Ignore ("See the comment in XamlObjectWriterTest.cs")]
public void CloseWithoutEndMember ()
{
var xw = new XamlObjectWriter (sctx, null);
}
[Test]
- [Category ("NotWorking")]
+ [Category ("NotWorking")] // not worthy of passing
public void StartMemberBeforeNamespace ()
{
var xw = new XamlObjectWriter (sctx, null);
}
[Test]
- [Category ("NotWorking")]
public void GetObjectOnIntValue ()
{
var xw = new XamlObjectWriter (sctx, null);
xw.WriteEndObject ();
}
- // use case based tests.
+ // extra use case based tests.
+
+ [Test]
+ public void WriteEx_Type_WriteString ()
+ {
+ var ow = new XamlObjectWriter (sctx);
+ ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
+ ));
+ ow.WriteStartObject (XamlLanguage.Type);
+ ow.WriteStartMember (XamlLanguage.PositionalParameters);
+ ow.WriteValue ("x:Int32");
+ ow.Close ();
+ Assert.AreEqual (typeof (int), ow.Result, "#1");
+ }
+
+ [Test]
+ public void WriteEx_Type_WriteType ()
+ {
+ var ow = new XamlObjectWriter (sctx);
+ ow.WriteNamespace (new NamespaceDeclaration (XamlLanguage.Xaml2006Namespace, "x"
+ ));
+ ow.WriteStartObject (XamlLanguage.Type);
+ ow.WriteStartMember (XamlLanguage.PositionalParameters);
+ ow.WriteValue (typeof (int));
+ ow.Close ();
+ Assert.AreEqual (typeof (int), ow.Result, "#1");
+ }
+
+ // common use case based tests (to other readers/writers).
XamlReader GetReader (string filename)
{
}
[Test]
- [Category ("NotWorking")]
public void Write_Type ()
{
using (var xr = GetReader ("Type.xml")) {
}
[Test]
- [Category ("NotWorking")]
public void Write_Type2 ()
{
var obj = typeof (MonoTests.System.Xaml.TestClass1);
}
}
+ [Test]
+ public void Write_GuidFactoryMethod ()
+ {
+ var obj = Guid.Parse ("9c3345ec-8922-4662-8e8d-a4e41f47cf09");
+ using (var xr = GetReader ("GuidFactoryMethod.xml")) {
+ var des = XamlServices.Load (xr);
+ Assert.AreEqual (obj, des, "#1");
+ }
+ }
+
[Test]
[ExpectedException (typeof (XamlObjectWriterException))] // cannot resolve the StaticExtension value.
- [Category ("NotWorking")]
public void Write_StaticExtension ()
{
var obj = new StaticExtension ("FooBar");
}
[Test]
- [Category ("NotWorking")]
public void Write_ListType ()
{
var obj = new List<Type> (new Type [] {typeof (int), typeof (Dictionary<Type, XamlType>)}) { Capacity = 2 };
}
[Test]
- [Category ("NotWorking")]
+ public void Write_ListArray ()
+ {
+ var obj = new List<Array> (new Array [] { new int [] { 1,2,3}, new string [] { "foo", "bar", "baz" }}) { Capacity = 2 };
+ using (var xr = GetReader ("List_Array.xml")) {
+ var des = (List<Array>) XamlServices.Load (xr);
+ Assert.AreEqual (obj, des, "#1");
+ }
+ }
+
+ [Test]
public void Write_DictionaryInt32String ()
{
var dic = new Dictionary<int,string> ();
}
[Test]
- [Category ("NotWorking")]
public void Write_DictionaryStringType ()
{
var dic = new Dictionary<string,Type> ();
}
[Test]
- [Category ("NotWorking")]
public void Write_ArgumentAttributed ()
{
//var obj = new ArgumentAttributed ("foo", "bar");
}
[Test]
- [Category ("NotWorking")]
public void Write_MyExtension3 ()
{
//var obj = new MyExtension3 () { Foo = typeof (int), Bar = "v2"};
}
[Test]
- [Category ("NotWorking")]
public void Write_PropertyDefinition ()
{
//var obj = new PropertyDefinition () { Modifier = "protected", Name = "foo", Type = XamlLanguage.String };
Assert.AreEqual (XamlLanguage.String, des.Type, "#3");
}
}
+
+ [Test]
+ [Ignore ("this still does not give successful deserialization result - should there be any way?")]
+ public void Write_StaticExtensionWrapper ()
+ {
+ //var obj = new StaticExtensionWrapper () { Param = new StaticExtension ("Foo") };
+ using (var xr = GetReader ("StaticExtensionWrapper.xml")) {
+ var des = (StaticExtensionWrapper) XamlServices.Load (xr);
+ Assert.IsNotNull (des.Param, "#1");
+ Assert.AreEqual ("Foo", des.Param.Member, "#2");
+ }
+ }
+
+ [Test]
+ [Ignore ("this still does not give successful deserialization result - should there be any way?")]
+ public void Write_TypeExtensionWrapper ()
+ {
+ //var obj = new TypeExtensionWrapper () { Param = new TypeExtension ("Foo") };
+ using (var xr = GetReader ("TypeExtensionWrapper.xml")) {
+ var des = (TypeExtensionWrapper) XamlServices.Load (xr);
+ Assert.IsNotNull (des.Param, "#1");
+ // TypeName was not serialized into xml, hence deserialized as empty.
+ Assert.AreEqual (String.Empty, des.Param.TypeName, "#2");
+ }
+ }
+
+ [Test]
+ public void Write_NamedItems ()
+ {
+ // foo
+ // - bar
+ // -- foo
+ // - baz
+ var obj = new NamedItem ("foo");
+ var obj2 = new NamedItem ("bar");
+ obj.References.Add (obj2);
+ obj.References.Add (new NamedItem ("baz"));
+ obj2.References.Add (obj);
+
+ using (var xr = GetReader ("NamedItems.xml")) {
+ var des = (NamedItem) XamlServices.Load (xr);
+ Assert.IsNotNull (des, "#1");
+ Assert.AreEqual (2, des.References.Count, "#2");
+ Assert.AreEqual (typeof (NamedItem), des.References [0].GetType (), "#3");
+ Assert.AreEqual (typeof (NamedItem), des.References [1].GetType (), "#4");
+ Assert.AreEqual (des, des.References [0].References [0], "#5");
+ }
+ }
+
+ [Test]
+ public void Write_NamedItems2 ()
+ {
+ // i1
+ // - i2
+ // -- i3
+ // - i4
+ // -- i3
+ var obj = new NamedItem2 ("i1");
+ var obj2 = new NamedItem2 ("i2");
+ var obj3 = new NamedItem2 ("i3");
+ var obj4 = new NamedItem2 ("i4");
+ obj.References.Add (obj2);
+ obj.References.Add (obj4);
+ obj2.References.Add (obj3);
+ obj4.References.Add (obj3);
+
+ using (var xr = GetReader ("NamedItems2.xml")) {
+ var des = (NamedItem2) XamlServices.Load (xr);
+ Assert.IsNotNull (des, "#1");
+ Assert.AreEqual (2, des.References.Count, "#2");
+ Assert.AreEqual (typeof (NamedItem2), des.References [0].GetType (), "#3");
+ Assert.AreEqual (typeof (NamedItem2), des.References [1].GetType (), "#4");
+ Assert.AreEqual (1, des.References [0].References.Count, "#5");
+ Assert.AreEqual (1, des.References [1].References.Count, "#6");
+ Assert.AreEqual (des.References [0].References [0], des.References [1].References [0], "#7");
+ }
+ }
+
+ [Test]
+ public void Write_XmlSerializableWrapper ()
+ {
+ var assns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name;
+ using (var xr = GetReader ("XmlSerializableWrapper.xml")) {
+ var des = (XmlSerializableWrapper) XamlServices.Load (xr);
+ Assert.IsNotNull (des, "#1");
+ Assert.IsNotNull (des.Value, "#2");
+ Assert.AreEqual ("<root xmlns=\"" + assns + "\" />", des.Value.GetRaw (), "#3");
+ }
+ }
+
+ [Test]
+ public void Write_XmlSerializable ()
+ {
+ using (var xr = GetReader ("XmlSerializable.xml")) {
+ var des = (XmlSerializable) XamlServices.Load (xr);
+ Assert.IsNotNull (des, "#1");
+ }
+ }
+
+ [Test]
+ public void Write_ListXmlSerializable ()
+ {
+ using (var xr = GetReader ("List_XmlSerializable.xml")) {
+ var des = (List<XmlSerializable>) XamlServices.Load (xr);
+ Assert.AreEqual (1, des.Count, "#1");
+ }
+ }
+
+ [Test]
+ public void Write_AttachedProperty ()
+ {
+ using (var xr = GetReader ("AttachedProperty.xml")) {
+ AttachedWrapper des = null;
+ try {
+ des = (AttachedWrapper) XamlServices.Load (xr);
+ Assert.IsNotNull (des.Value, "#1");
+ Assert.AreEqual ("x", Attachable.GetFoo (des), "#2");
+ Assert.AreEqual ("y", Attachable.GetFoo (des.Value), "#3");
+ } finally {
+ if (des != null) {
+ Attachable.SetFoo (des, null);
+ Attachable.SetFoo (des.Value, null);
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void Write_EventStore ()
+ {
+ using (var xr = GetReader ("EventStore.xml")) {
+ var res = (EventStore) XamlServices.Load (xr);
+ Assert.AreEqual ("foo", res.Examine (), "#1");
+ Assert.IsTrue (res.Method1Invoked, "#2");
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (XamlDuplicateMemberException))] // for two occurence of Event1 ...
+ public void Write_EventStore2 ()
+ {
+ using (var xr = GetReader ("EventStore2.xml")) {
+ XamlServices.Load (xr);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (XamlObjectWriterException))] // attaching nonexistent method
+ public void Write_EventStore3 ()
+ {
+ using (var xr = GetReader ("EventStore3.xml")) {
+ XamlServices.Load (xr);
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")] // type resolution failure.
+ public void Write_EventStore4 ()
+ {
+ using (var xr = GetReader ("EventStore4.xml")) {
+ var res = (EventStore2<EventArgs>) XamlServices.Load (xr);
+ Assert.AreEqual ("foo", res.Examine (), "#1");
+ Assert.IsTrue (res.Method1Invoked, "#2");
+ }
+ }
+
+ [Test]
+ public void Write_AbstractWrapper ()
+ {
+ using (var xr = GetReader ("AbstractContainer.xml")) {
+ var res = (AbstractContainer) XamlServices.Load (xr);
+ Assert.IsNull (res.Value1, "#1");
+ Assert.IsNotNull (res.Value2, "#2");
+ Assert.AreEqual ("x", res.Value2.Foo, "#3");
+ }
+ }
+
+ [Test]
+ public void Write_ReadOnlyPropertyContainer ()
+ {
+ using (var xr = GetReader ("ReadOnlyPropertyContainer.xml")) {
+ var res = (ReadOnlyPropertyContainer) XamlServices.Load (xr);
+ Assert.AreEqual ("x", res.Foo, "#1");
+ Assert.AreEqual ("x", res.Bar, "#2");
+ }
+ }
}
}
projects / mono.git / blobdiff