2 // System.Xml.XmlSerializerTests
\r
5 // Erik LeBel <eriklebel@yahoo.ca>
\r
7 // (C) 2003 Erik LeBel
\r
11 // Where possible, these tests avoid testing the order of
\r
12 // an object's members serialization. Mono and .NET do not
\r
13 // reflect members in the same order.
\r
15 // Only serializations tests so far, no deserialization.
\r
18 // test XmlArrayAttribute
\r
19 // test XmlArrayItemAttribute
\r
20 // test serialization of decimal type
\r
21 // test serialization of Guid type
\r
22 // test XmlNode serialization with and without modifying attributes.
\r
23 // test deserialization
\r
24 // FIXMEs found in this file
\r
27 using System.Collections;
\r
31 using System.Xml.Schema;
\r
32 using System.Xml.Serialization;
\r
34 using NUnit.Framework;
\r
36 using MonoTests.System.Xml.TestClasses;
\r
38 namespace MonoTests.System.XmlSerialization
\r
41 public class XmlSerializerTests : Assertion
\r
47 private void SetUpWriter()
\r
49 sw = new StringWriter ();
\r
50 xtw = new XmlTextWriter (sw);
\r
51 xtw.QuoteChar = '\'';
\r
52 xtw.Formatting = Formatting.None;
\r
55 private string WriterText
\r
59 string val = sw.GetStringBuilder().ToString();
\r
60 int offset = val.IndexOf('>') + 1;
\r
61 val = val.Substring(offset);
\r
62 return Infoset(val);
\r
66 private void Serialize(object o)
\r
69 xs = new XmlSerializer(o.GetType());
\r
70 xs.Serialize(xtw, o);
\r
73 private void Serialize(object o, Type type)
\r
76 xs = new XmlSerializer(type);
\r
77 xs.Serialize(xtw, o);
\r
80 private void Serialize(object o, XmlSerializerNamespaces ns)
\r
83 xs = new XmlSerializer(o.GetType());
\r
84 xs.Serialize(xtw, o, ns);
\r
87 private void Serialize(object o, XmlAttributeOverrides ao)
\r
90 xs = new XmlSerializer(o.GetType(), ao);
\r
91 xs.Serialize(xtw, o);
\r
94 private void Serialize(object o, XmlRootAttribute root)
\r
97 xs = new XmlSerializer(o.GetType(), root);
\r
98 xs.Serialize(xtw, o);
\r
101 // test constructors
\r
102 #if USE_VERSION_1_1 // It doesn't pass on MS.NET 1.1.
\r
104 public void TestConstructor()
\r
106 XmlSerializer ser = new XmlSerializer (null, "");
\r
111 // test basic types ////////////////////////////////////////////////////////
\r
113 public void TestSerializeInt()
\r
116 AssertEquals(Infoset("<int>10</int>"), WriterText);
\r
120 public void TestSerializeBool()
\r
123 AssertEquals(Infoset("<boolean>true</boolean>"), WriterText);
\r
126 AssertEquals(Infoset("<boolean>false</boolean>"), WriterText);
\r
130 public void TestSerializeString()
\r
132 Serialize("hello");
\r
133 AssertEquals(Infoset("<string>hello</string>"), WriterText);
\r
137 public void TestSerializeEmptyString()
\r
139 Serialize(String.Empty);
\r
140 AssertEquals(Infoset("<string />"), WriterText);
\r
144 public void TestSerializeNullObject()
\r
146 Serialize(null, typeof(object));
\r
147 AssertEquals(Infoset("<anyType xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />"), WriterText);
\r
151 [Ignore ("The generated XML is not exact but it is equivalent")]
\r
152 public void TestSerializeNullString()
\r
154 Serialize(null, typeof(string));
\r
155 Console.WriteLine (WriterText);
\r
156 AssertEquals (Infoset("<string xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />"), WriterText);
\r
160 public void TestSerializeIntArray()
\r
162 Serialize(new int[] {1, 2, 3, 4});
\r
163 AssertEquals (Infoset("<ArrayOfInt xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><int>1</int><int>2</int><int>3</int><int>4</int></ArrayOfInt>"), WriterText);
\r
167 public void TestSerializeEmptyArray()
\r
169 Serialize(new int[] {});
\r
170 AssertEquals(Infoset("<ArrayOfInt xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
174 public void TestSerializeChar()
\r
177 AssertEquals(Infoset("<char>65</char>"), WriterText);
\r
180 AssertEquals(Infoset("<char>0</char>"), WriterText);
\r
183 AssertEquals(Infoset("<char>10</char>"), WriterText);
\r
185 Serialize('\uFF01');
\r
186 AssertEquals(Infoset("<char>65281</char>"), WriterText);
\r
190 public void TestSerializeFloat()
\r
193 AssertEquals(Infoset("<double>10.78</double>"), WriterText);
\r
196 AssertEquals(Infoset("<double>-100000000</double>"), WriterText);
\r
198 // FIXME test INF and other boundary conditions that may exist with floats
\r
203 public void TestSerializeEnumeration()
\r
205 Serialize(SimpleEnumeration.FIRST);
\r
206 AssertEquals(Infoset("<SimpleEnumeration>FIRST</SimpleEnumeration>"), WriterText);
\r
208 Serialize(SimpleEnumeration.SECOND);
\r
209 AssertEquals(Infoset("<SimpleEnumeration>SECOND</SimpleEnumeration>"), WriterText);
\r
213 public void TestSerializeQualifiedName()
\r
215 Serialize(new XmlQualifiedName("me", "home.urn"));
\r
216 AssertEquals(Infoset("<QName xmlns:q1='home.urn'>q1:me</QName>"), WriterText);
\r
220 public void TestSerializeBytes()
\r
222 Serialize((byte)0xAB);
\r
223 AssertEquals(Infoset("<unsignedByte>171</unsignedByte>"), WriterText);
\r
225 Serialize((byte)15);
\r
226 AssertEquals(Infoset("<unsignedByte>15</unsignedByte>"), WriterText);
\r
230 public void TestSerializeByteArrays()
\r
232 Serialize(new byte[] {});
\r
233 AssertEquals(Infoset("<base64Binary />"), WriterText);
\r
235 Serialize(new byte[] {0xAB, 0xCD});
\r
236 AssertEquals(Infoset("<base64Binary>q80=</base64Binary>"), WriterText);
\r
240 public void TestSerializeDateTime()
\r
242 DateTime d = new DateTime();
\r
245 TimeZone tz = TimeZone.CurrentTimeZone;
\r
246 TimeSpan off = tz.GetUtcOffset (d);
\r
247 string sp = string.Format ("{0:00}:{1:00}", off.TotalHours, off.TotalMinutes%60);
\r
248 if (off.Ticks > 0) sp = "+" + sp;
\r
249 else sp = "-" + sp;
\r
251 AssertEquals (Infoset("<dateTime>0001-01-01T00:00:00.0000000" + sp + "</dateTime>"), WriterText);
\r
261 public void TestSerialize()
\r
264 AssertEquals(WriterText, "");
\r
268 // test basic class serialization /////////////////////////////////////
\r
270 public void TestSerializeSimpleClass()
\r
272 SimpleClass simple = new SimpleClass();
\r
274 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
276 simple.something = "hello";
\r
279 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText);
\r
283 public void TestSerializeStringCollection()
\r
285 StringCollection strings = new StringCollection();
\r
286 Serialize(strings);
\r
287 AssertEquals(Infoset("<ArrayOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
289 strings.Add("hello");
\r
290 strings.Add("goodbye");
\r
291 Serialize(strings);
\r
292 AssertEquals(Infoset("<ArrayOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><string>hello</string><string>goodbye</string></ArrayOfString>"), WriterText);
\r
297 public void TestSerializePlainContainer()
\r
299 StringCollectionContainer container = new StringCollectionContainer();
\r
300 Serialize(container);
\r
301 AssertEquals(Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages /></StringCollectionContainer>"), WriterText);
\r
303 container.Messages.Add("hello");
\r
304 container.Messages.Add("goodbye");
\r
305 Serialize(container);
\r
306 AssertEquals(Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages><string>hello</string><string>goodbye</string></Messages></StringCollectionContainer>"), WriterText);
\r
310 public void TestSerializeArrayContainer()
\r
312 ArrayContainer container = new ArrayContainer();
\r
313 Serialize(container);
\r
314 AssertEquals(Infoset("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"),WriterText);
\r
316 container.items = new object[] {10, 20};
\r
317 Serialize(container);
\r
318 AssertEquals(Infoset("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><anyType xsi:type='xsd:int'>10</anyType><anyType xsi:type='xsd:int'>20</anyType></items></ArrayContainer>"),WriterText);
\r
320 container.items = new object[] {10, "hello"};
\r
321 Serialize(container);
\r
322 AssertEquals(Infoset("<ArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><anyType xsi:type='xsd:int'>10</anyType><anyType xsi:type='xsd:string'>hello</anyType></items></ArrayContainer>"),WriterText);
\r
326 public void TestSerializeClassArrayContainer()
\r
328 ClassArrayContainer container = new ClassArrayContainer();
\r
329 Serialize(container);
\r
330 AssertEquals(Infoset("<ClassArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"),WriterText);
\r
332 SimpleClass simple1 = new SimpleClass();
\r
333 simple1.something = "hello";
\r
334 SimpleClass simple2 = new SimpleClass();
\r
335 simple2.something = "hello";
\r
336 container.items = new SimpleClass[2];
\r
337 container.items[0] = simple1;
\r
338 container.items[1] = simple2;
\r
339 Serialize(container);
\r
340 AssertEquals(Infoset("<ClassArrayContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><SimpleClass><something>hello</something></SimpleClass><SimpleClass><something>hello</something></SimpleClass></items></ClassArrayContainer>"),WriterText);
\r
343 // test basic attributes ///////////////////////////////////////////////
\r
345 public void TestSerializeSimpleClassWithXmlAttributes()
\r
347 SimpleClassWithXmlAttributes simple = new SimpleClassWithXmlAttributes();
\r
349 AssertEquals(Infoset("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
351 simple.something = "hello";
\r
353 AssertEquals (Infoset("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' member='hello' />"), WriterText);
\r
356 // test overrides ///////////////////////////////////////////////////////
\r
358 public void TestSerializeSimpleClassWithOverrides()
\r
360 // Also tests XmlIgnore
\r
361 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
363 XmlAttributes attr = new XmlAttributes();
\r
364 attr.XmlIgnore = true;
\r
365 overrides.Add(typeof(SimpleClassWithXmlAttributes), "something", attr);
\r
367 SimpleClassWithXmlAttributes simple = new SimpleClassWithXmlAttributes();
\r
368 simple.something = "hello";
\r
369 Serialize(simple, overrides);
\r
370 AssertEquals(Infoset("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
373 // test xmlText //////////////////////////////////////////////////////////
\r
375 public void TestSerializeXmlTextAttribute()
\r
377 SimpleClass simple = new SimpleClass();
\r
378 simple.something = "hello";
\r
380 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
381 XmlAttributes attr = new XmlAttributes();
\r
382 overrides.Add(typeof(SimpleClass), "something", attr);
\r
384 attr.XmlText = new XmlTextAttribute();
\r
385 Serialize(simple, overrides);
\r
386 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>hello</SimpleClass>"), WriterText);
\r
388 attr.XmlText = new XmlTextAttribute(typeof(string));
\r
389 Serialize(simple, overrides);
\r
390 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>hello</SimpleClass>"), WriterText);
\r
394 attr.XmlText = new XmlTextAttribute(typeof(byte[]));
\r
395 Serialize(simple, overrides);
\r
396 Fail("XmlText.Type does not match the type it serializes: this should have failed");
\r
404 attr.XmlText = new XmlTextAttribute();
\r
405 attr.XmlText.DataType = "sometype";
\r
406 Serialize(simple, overrides);
\r
407 Fail("XmlText.DataType does not match the type it serializes: this should have failed");
\r
414 // test xmlRoot //////////////////////////////////////////////////////////
\r
416 public void TestSerializeXmlRootAttribute()
\r
418 // constructor override & element name
\r
419 XmlRootAttribute root = new XmlRootAttribute();
\r
420 root.ElementName = "renamed";
\r
422 SimpleClassWithXmlAttributes simpleWithAttributes = new SimpleClassWithXmlAttributes();
\r
423 Serialize(simpleWithAttributes, root);
\r
424 AssertEquals(Infoset("<renamed xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
426 SimpleClass simple = null;
\r
427 root.IsNullable = false;
\r
430 Serialize(simple, root);
\r
431 Fail("Cannot serialize null object if XmlRoot's IsNullable == false");
\r
437 root.IsNullable = true;
\r
440 Serialize(simple, root);
\r
441 Fail("Cannot serialize null object if XmlRoot's IsNullable == true");
\r
447 simple = new SimpleClass();
\r
448 root.ElementName = null;
\r
449 root.Namespace = "some.urn";
\r
450 Serialize(simple, root);
\r
451 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns='some.urn' />"), WriterText);
\r
455 public void TestSerializeXmlRootAttributeOnMember()
\r
458 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
459 XmlAttributes childAttr = new XmlAttributes();
\r
460 childAttr.XmlRoot = new XmlRootAttribute("simple");
\r
461 overrides.Add(typeof(SimpleClass), childAttr);
\r
463 XmlAttributes attr = new XmlAttributes();
\r
464 attr.XmlRoot = new XmlRootAttribute("simple");
\r
465 overrides.Add(typeof(ClassArrayContainer), attr);
\r
467 ClassArrayContainer container = new ClassArrayContainer();
\r
468 container.items = new SimpleClass[1];
\r
469 container.items[0] = new SimpleClass();
\r
470 Serialize(container, overrides);
\r
471 AssertEquals(Infoset("<simple xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' ><items><SimpleClass /></items></simple>"),WriterText);
\r
473 // FIXME test data type
\r
476 // test XmlAttribute /////////////////////////////////////////////////////
\r
478 public void TestSerializeXmlAttributeAttribute()
\r
481 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
482 XmlAttributes attr = new XmlAttributes();
\r
483 attr.XmlAttribute = new XmlAttributeAttribute();
\r
484 overrides.Add(typeof(SimpleClass), "something", attr);
\r
486 SimpleClass simple = new SimpleClass();;
\r
487 Serialize(simple, overrides);
\r
488 AssertEquals("#1", Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
491 simple.something = "hello";
\r
492 Serialize(simple, overrides);
\r
493 AssertEquals ("#2", Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' something='hello' />"), WriterText);
\r
496 attr.XmlAttribute.AttributeName = "somethingelse";
\r
497 Serialize(simple, overrides);
\r
498 AssertEquals ("#3", Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' somethingelse='hello' />"), WriterText);
\r
501 // FIXME this should work, shouldnt it?
\r
502 // attr.XmlAttribute.Type = typeof(string);
\r
503 // Serialize(simple, overrides);
\r
504 // Assert(WriterText.EndsWith(" something='hello' />"));
\r
507 attr.XmlAttribute.Namespace = "some:urn";
\r
508 Serialize(simple, overrides);
\r
509 AssertEquals ("#4", Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' d1p1:somethingelse='hello' xmlns:d1p1='some:urn' />"), WriterText);
\r
512 // FIXME XmlSchemaForm Form
\r
514 // FIXME write XmlQualifiedName as attribute
\r
517 // test XmlElement ///////////////////////////////////////////////////////
\r
519 public void TestSerializeXmlElementAttribute()
\r
523 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
524 XmlAttributes attr = new XmlAttributes();
\r
525 XmlElementAttribute element = new XmlElementAttribute();
\r
526 attr.XmlElements.Add(element);
\r
527 overrides.Add(typeof(SimpleClass), "something", attr);
\r
530 SimpleClass simple = new SimpleClass();;
\r
531 Serialize(simple, overrides);
\r
532 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
535 simple.something = "hello";
\r
536 Serialize(simple, overrides);
\r
537 AssertEquals (Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText);
\r
540 element.ElementName = "saying";
\r
541 Serialize(simple, overrides);
\r
542 AssertEquals (Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><saying>hello</saying></SimpleClass>"), WriterText);
\r
545 element.IsNullable = false;
\r
546 simple.something = null;
\r
547 Serialize(simple, overrides);
\r
548 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"),WriterText);
\r
550 element.IsNullable = true;
\r
551 simple.something = null;
\r
552 Serialize(simple, overrides);
\r
553 AssertEquals (Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><saying xsi:nil='true' /></SimpleClass>"), WriterText);
\r
556 element.ElementName = null;
\r
557 element.IsNullable = false;
\r
558 element.Namespace = "some:urn";
\r
559 simple.something = "hello";
\r
560 Serialize(simple, overrides);
\r
561 AssertEquals (Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something xmlns='some:urn'>hello</something></SimpleClass>"), WriterText);
\r
568 // test XmlElementAttribute with arrays and collections //////////////////
\r
570 public void TestSerializeCollectionWithXmlElementAttribute()
\r
573 // if no type is specified or the specified type
\r
574 // matches the contents of the collection,
\r
575 // serialize each element in an element named after the member.
\r
576 // if the type does not match, or matches the collection itself,
\r
577 // create a base wrapping element for the member, and then
\r
578 // wrap each collection item in its own wrapping element based on type.
\r
580 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
581 XmlAttributes attr = new XmlAttributes();
\r
582 XmlElementAttribute element = new XmlElementAttribute();
\r
583 attr.XmlElements.Add(element);
\r
584 overrides.Add(typeof(StringCollectionContainer), "Messages", attr);
\r
586 // empty collection & no type info in XmlElementAttribute
\r
587 StringCollectionContainer container = new StringCollectionContainer();
\r
588 Serialize(container, overrides);
\r
589 AssertEquals(Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
591 // non-empty collection & no type info in XmlElementAttribute
\r
592 container.Messages.Add("hello");
\r
593 Serialize(container, overrides);
\r
594 AssertEquals (Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages></StringCollectionContainer>"), WriterText);
\r
596 // non-empty collection & only type info in XmlElementAttribute
\r
597 element.Type = typeof(StringCollection);
\r
598 Serialize(container, overrides);
\r
599 AssertEquals (Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages><string>hello</string></Messages></StringCollectionContainer>"), WriterText);
\r
601 // non-empty collection & only type info in XmlElementAttribute
\r
602 element.Type = typeof(string);
\r
603 Serialize(container, overrides);
\r
604 AssertEquals(Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages></StringCollectionContainer>"), WriterText);
\r
607 container.Messages.Add("goodbye");
\r
608 element.Type = null;
\r
609 Serialize(container, overrides);
\r
610 AssertEquals(Infoset("<StringCollectionContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><Messages>hello</Messages><Messages>goodbye</Messages></StringCollectionContainer>"), WriterText);
\r
613 // test DefaultValue /////////////////////////////////////////////////////
\r
615 public void TestSerializeDefaultValueAttribute()
\r
617 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
\r
619 XmlAttributes attr = new XmlAttributes();
\r
620 string defaultValueInstance = "nothing";
\r
621 attr.XmlDefaultValue = defaultValueInstance;
\r
622 overrides.Add(typeof(SimpleClass), "something", attr);
\r
625 SimpleClass simple = new SimpleClass();
\r
626 Serialize(simple, overrides);
\r
627 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
629 // same value as default
\r
630 simple.something = defaultValueInstance;
\r
631 Serialize(simple, overrides);
\r
632 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />"), WriterText);
\r
634 // some other value
\r
635 simple.something = "hello";
\r
636 Serialize(simple, overrides);
\r
637 AssertEquals(Infoset("<SimpleClass xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></SimpleClass>"), WriterText);
\r
640 // test XmlEnum //////////////////////////////////////////////////////////
\r
642 public void TestSerializeXmlEnumAttribute()
\r
644 // technically this has an XmlIgnore attribute,
\r
645 // but it is not being serialized as a member.
\r
646 Serialize(XmlSchemaForm.None);
\r
647 AssertEquals(Infoset("<XmlSchemaForm>0</XmlSchemaForm>"), WriterText);
\r
649 Serialize(XmlSchemaForm.Qualified);
\r
650 AssertEquals(Infoset("<XmlSchemaForm>qualified</XmlSchemaForm>"), WriterText);
\r
652 Serialize(XmlSchemaForm.Unqualified);
\r
653 AssertEquals(Infoset("<XmlSchemaForm>unqualified</XmlSchemaForm>"), WriterText);
\r
657 public void TestSerializeXmlNodeArray ()
659 XmlDocument doc = new XmlDocument ();
660 Serialize (new XmlNode [] { doc.CreateAttribute("at"), doc.CreateElement("elem1"), doc.CreateElement("elem2") }, typeof(object));
661 AssertEquals(Infoset("<anyType at=\"\"><elem1/><elem2/></anyType>"), WriterText);
\r
665 public void TestSerializeXmlElement ()
667 XmlDocument doc = new XmlDocument ();
668 Serialize (doc.CreateElement("elem"), typeof(XmlElement));
669 AssertEquals(Infoset("<elem/>"), WriterText);
\r
673 public void TestSerializeXmlElementSubclass ()
675 XmlDocument doc = new XmlDocument ();
676 Serialize (new MyElem (doc), typeof(XmlElement));
677 AssertEquals(Infoset("<myelem aa=\"1\"/>"), WriterText);
\r
679 Serialize (new MyElem (doc), typeof(MyElem));
680 AssertEquals(Infoset("<myelem aa=\"1\"/>"), WriterText);
\r
684 public void TestSerializeXmlCDataSection ()
686 XmlDocument doc = new XmlDocument ();
687 CDataContainer c = new CDataContainer ();
688 c.cdata = doc.CreateCDataSection("data section contents");
690 AssertEquals(Infoset("<CDataContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><cdata><![CDATA[data section contents]]></cdata></CDataContainer>"), WriterText);
\r
694 public void TestSerializeXmlNode ()
696 XmlDocument doc = new XmlDocument ();
697 NodeContainer c = new NodeContainer ();
698 c.node = doc.CreateTextNode("text");
700 AssertEquals(Infoset("<NodeContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><node>text</node></NodeContainer>"), WriterText);
\r
704 public void TestSerializeChoice ()
\r
706 Choices ch = new Choices ();
\r
707 ch.MyChoice = "choice text";
\r
708 ch.ItemType = ItemChoiceType.ChoiceZero;
\r
710 AssertEquals(Infoset("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceZero>choice text</ChoiceZero></Choices>"), WriterText);
\r
711 ch.ItemType = ItemChoiceType.StrangeOne;
\r
713 AssertEquals(Infoset("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceOne>choice text</ChoiceOne></Choices>"), WriterText);
\r
714 ch.ItemType = ItemChoiceType.ChoiceTwo;
\r
716 AssertEquals(Infoset("<Choices xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><ChoiceTwo>choice text</ChoiceTwo></Choices>"), WriterText);
\r
719 public static string Infoset (string sx)
\r
721 XmlDocument doc = new XmlDocument ();
\r
723 StringBuilder sb = new StringBuilder ();
\r
724 GetInfoset (doc.DocumentElement, sb);
\r
725 return sb.ToString ();
\r
728 public static string Infoset (XmlNode nod)
\r
730 StringBuilder sb = new StringBuilder ();
\r
731 GetInfoset (nod, sb);
\r
732 return sb.ToString ();
\r
735 static void GetInfoset (XmlNode nod, StringBuilder sb)
\r
737 switch (nod.NodeType)
\r
739 case XmlNodeType.Attribute:
\r
740 if (nod.LocalName == "xmlns" && nod.NamespaceURI == "http://www.w3.org/2000/xmlns/") return;
\r
741 sb.Append (" " + nod.NamespaceURI + ":" + nod.LocalName + "='" + nod.Value + "'");
\r
744 case XmlNodeType.Element:
\r
745 XmlElement elem = (XmlElement) nod;
\r
746 sb.Append ("<" + elem.NamespaceURI + ":" + elem.LocalName);
\r
748 ArrayList ats = new ArrayList ();
\r
749 foreach (XmlAttribute at in elem.Attributes)
\r
750 ats.Add (at.LocalName + " " + at.NamespaceURI);
\r
754 foreach (string name in ats)
\r
756 string[] nn = name.Split (' ');
\r
757 GetInfoset (elem.Attributes[nn[0],nn[1]], sb);
\r
761 foreach (XmlNode cn in elem.ChildNodes)
\r
762 GetInfoset (cn, sb);
\r
767 sb.Append (nod.OuterXml);
\r