?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[bcl] Remove ONLY_1_1 defines from class libs
[mono-project.git] / mcs / class / System.XML / Test / System.Xml.Serialization / XmlReflectionImporterTests.cs
blobf4103f14d7d31269148b0a142f05f97e0b136b5d
1 //
2 // System.Xml.Serialization.XmlReflectionImporterTests
3 //
4 // Author:
5 // Erik LeBel (eriklebel@yahoo.ca)
6 //
7 // (C) 2003 Erik LeBel
8 //
9 // FIXME test some of these with Xml Attributes attached to some members:
10 // do the names get carried over to Element for XmlAttributeAttribute and XmlElementAttribute?
11 //
12
13 using System;
14 using System.Collections;
15 using System.IO;
16 using System.Xml;
17 using System.Xml.Schema;
18 using System.Xml.Serialization;
19
20 using NUnit.Framework;
21 using System.Collections.Generic;
22
23 using MonoTests.System.Xml.TestClasses;
24
25 namespace MonoTests.System.XmlSerialization
26 {
27 // debugging class
28 internal class Debug
29 {
30 public static void Print(XmlTypeMapping tm)
31 {
32 Console.WriteLine("/XmlTypeMapping:");
33 Console.WriteLine("ElementName: {0} ", tm.ElementName);
34 Console.WriteLine("Namespace: {0} ", tm.Namespace);
35 Console.WriteLine("TypeName: {0} ", tm.TypeName);
36 Console.WriteLine("FullTypeName: {0} ", tm.TypeFullName);
37 }
38
39 public static void Print(XmlMemberMapping mm)
40 {
41 Console.WriteLine("/XmlMemberMapping:");
42 Console.WriteLine("Any: {0} ", mm.Any);
43 Console.WriteLine("ElementName: {0} ", mm.ElementName);
44 Console.WriteLine("MemberName: {0} ", mm.MemberName);
45 Console.WriteLine("Namespace: {0} ", mm.Namespace);
46 Console.WriteLine("TypeFullName: {0} ", mm.TypeFullName);
47 Console.WriteLine("TypeName: {0} ", mm.TypeName);
48 Console.WriteLine("TypeNamespace: {0} ", mm.TypeNamespace);
49 }
50 }
51
52 [TestFixture]
53 public class XmlReflectionImporterTests
54 {
55 private const string SomeNamespace = "some:urn";
56 private const string AnotherNamespace = "another:urn";
57 private const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";
58
59 // these Map methods re-create the XmlReflectionImporter at every call.
60
61 private XmlTypeMapping Map(Type t)
62 {
63 XmlReflectionImporter ri = new XmlReflectionImporter();
64 XmlTypeMapping tm = ri.ImportTypeMapping(t);
65 //Debug.Print(tm);
66
67 return tm;
68 }
69
70 private XmlTypeMapping Map(Type t, XmlRootAttribute root)
71 {
72 XmlReflectionImporter ri = new XmlReflectionImporter();
73 XmlTypeMapping tm = ri.ImportTypeMapping(t, root);
74
75 return tm;
76 }
77
78 private XmlTypeMapping Map(Type t, string ns)
79 {
80 XmlReflectionImporter ri = new XmlReflectionImporter(ns);
81 XmlTypeMapping tm = ri.ImportTypeMapping(t);
82 //Debug.Print(tm);
83
84 return tm;
85 }
86
87 private XmlTypeMapping Map (Type t, string ns, XmlRootAttribute root)
88 {
89 XmlReflectionImporter ri = new XmlReflectionImporter (ns);
90 XmlTypeMapping tm = ri.ImportTypeMapping (t, root);
91
92 return tm;
93 }
94
95 private XmlTypeMapping Map(Type t, XmlAttributeOverrides overrides)
96 {
97 XmlReflectionImporter ri = new XmlReflectionImporter(overrides);
98 XmlTypeMapping tm = ri.ImportTypeMapping(t);
99 //Debug.Print(tm);
100
101 return tm;
102 }
103
104 private XmlMembersMapping MembersMap(Type t, XmlAttributeOverrides overrides,
105 XmlReflectionMember [] members, bool inContainer)
106 {
107 XmlReflectionImporter ri = new XmlReflectionImporter(overrides);
108 XmlMembersMapping mm = ri.ImportMembersMapping(null, null, members, inContainer);
109
110 return mm;
111 }
112
113 [Test]
114 public void TestIntTypeMapping()
115 {
116 XmlTypeMapping tm = Map(typeof(int));
117 Assert.AreEqual ("int", tm.ElementName, "#1");
118 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
119 Assert.AreEqual ("Int32", tm.TypeName, "#3");
120 Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
121 }
122
123 [Test]
124 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
125 public void TestIntTypeMapping_Array ()
126 {
127 XmlTypeMapping tm = Map(typeof(int[]));
128 Assert.AreEqual ("ArrayOfInt", tm.ElementName, "#A1");
129 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
130 Assert.AreEqual ("ArrayOfInt32", tm.TypeName, "#A3");
131 Assert.AreEqual ("System.Int32[]", tm.TypeFullName, "#A4");
132
133 tm = Map (typeof (int[][]));
134 Assert.AreEqual ("ArrayOfArrayOfInt", tm.ElementName, "#B1");
135 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
136 Assert.AreEqual ("ArrayOfArrayOfInt32", tm.TypeName, "#B3");
137 Assert.AreEqual ("System.Int32[][]", tm.TypeFullName, "#B4");
138
139 tm = Map (typeof (int[][][]));
140 Assert.AreEqual ("ArrayOfArrayOfArrayOfInt", tm.ElementName, "#C1");
141 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
142 Assert.AreEqual ("ArrayOfArrayOfArrayOfInt32", tm.TypeName, "#C3");
143 Assert.AreEqual ("System.Int32[][][]", tm.TypeFullName, "#C4");
144 }
145
146 [Test]
147 public void TestStringTypeMapping()
148 {
149 XmlTypeMapping tm = Map(typeof(string));
150 Assert.AreEqual ("string", tm.ElementName, "#1");
151 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
152 Assert.AreEqual ("String", tm.TypeName, "#3");
153 Assert.AreEqual ("System.String", tm.TypeFullName, "#4");
154 }
155
156 [Test]
157 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
158 public void TestStringTypeMapping_Array ()
159 {
160 XmlTypeMapping tm = Map (typeof (string[]));
161 Assert.AreEqual ("ArrayOfString", tm.ElementName, "#A1");
162 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
163 Assert.AreEqual ("ArrayOfString", tm.TypeName, "#A3");
164 Assert.AreEqual ("System.String[]", tm.TypeFullName, "#A4");
165
166 tm = Map (typeof (string[][]));
167 Assert.AreEqual ("ArrayOfArrayOfString", tm.ElementName, "#B1");
168 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
169 Assert.AreEqual ("ArrayOfArrayOfString", tm.TypeName, "#B3");
170 Assert.AreEqual ("System.String[][]", tm.TypeFullName, "#B4");
171
172 tm = Map (typeof (string[][][]));
173 Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.ElementName, "#C1");
174 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
175 Assert.AreEqual ("ArrayOfArrayOfArrayOfString", tm.TypeName, "#C3");
176 Assert.AreEqual ("System.String[][][]", tm.TypeFullName, "#C4");
177 }
178
179 [Test]
180 public void TestObjectTypeMapping()
181 {
182 XmlTypeMapping tm = Map(typeof(object));
183 Assert.AreEqual ("anyType", tm.ElementName, "#1");
184 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
185 Assert.AreEqual ("Object", tm.TypeName, "#3");
186 Assert.AreEqual ("System.Object", tm.TypeFullName, "#4");
187 }
188
189 [Test]
190 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
191 public void TestObjectTypeMapping_Array ()
192 {
193 XmlTypeMapping tm = Map (typeof (object[]));
194 Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#A1");
195 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
196 Assert.AreEqual ("ArrayOfObject", tm.TypeName, "#A3");
197 Assert.AreEqual ("System.Object[]", tm.TypeFullName, "#A4");
198
199 tm = Map (typeof (object[][]));
200 Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#B1");
201 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
202 Assert.AreEqual ("ArrayOfArrayOfObject", tm.TypeName, "#B3");
203 Assert.AreEqual ("System.Object[][]", tm.TypeFullName, "#B4");
204
205 tm = Map (typeof (object[][][]));
206 Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
207 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
208 Assert.AreEqual ("ArrayOfArrayOfArrayOfObject", tm.TypeName, "#C3");
209 Assert.AreEqual ("System.Object[][][]", tm.TypeFullName, "#C4");
210 }
211
212 [Test]
213 public void TestByteTypeMapping()
214 {
215 XmlTypeMapping tm = Map(typeof(byte));
216 Assert.AreEqual ("unsignedByte", tm.ElementName, "#1");
217 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
218 Assert.AreEqual ("Byte", tm.TypeName, "#3");
219 Assert.AreEqual ("System.Byte", tm.TypeFullName, "#4");
220 }
221
222 [Test]
223 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
224 public void TestByteTypeMapping_Array ()
225 {
226 XmlTypeMapping tm = Map(typeof(byte[]));
227 Assert.AreEqual ("base64Binary", tm.ElementName, "#A1");
228 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
229 Assert.AreEqual ("Byte[]", tm.TypeName, "#A3");
230 Assert.AreEqual ("System.Byte[]", tm.TypeFullName, "#A4");
231
232 tm = Map (typeof (byte[][]));
233 Assert.AreEqual ("ArrayOfBase64Binary", tm.ElementName, "#B1");
234 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
235 Assert.AreEqual ("ArrayOfArrayOfByte", tm.TypeName, "#B3");
236 Assert.AreEqual ("System.Byte[][]", tm.TypeFullName, "#B4");
237
238 tm = Map (typeof (byte[][][]));
239 Assert.AreEqual ("ArrayOfArrayOfBase64Binary", tm.ElementName, "#C1");
240 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
241 Assert.AreEqual ("ArrayOfArrayOfArrayOfByte", tm.TypeName, "#C3");
242 Assert.AreEqual ("System.Byte[][][]", tm.TypeFullName, "#C4");
243 }
244
245 [Test]
246 public void TestBoolTypeMapping()
247 {
248 XmlTypeMapping tm = Map(typeof(bool));
249 Assert.AreEqual ("boolean", tm.ElementName, "#1");
250 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
251 Assert.AreEqual ("Boolean", tm.TypeName, "#3");
252 Assert.AreEqual ("System.Boolean", tm.TypeFullName, "#4");
253 }
254
255 [Test]
256 public void TestShortTypeMapping()
257 {
258 XmlTypeMapping tm = Map(typeof(short));
259 Assert.AreEqual ("short", tm.ElementName, "#1");
260 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
261 Assert.AreEqual ("Int16", tm.TypeName, "#3");
262 Assert.AreEqual ("System.Int16", tm.TypeFullName, "#4");
263 }
264
265 [Test]
266 public void TestUnsignedShortTypeMapping()
267 {
268 XmlTypeMapping tm = Map(typeof(ushort));
269 Assert.AreEqual ("unsignedShort", tm.ElementName, "#1");
270 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
271 Assert.AreEqual ("UInt16", tm.TypeName, "#3");
272 Assert.AreEqual ("System.UInt16", tm.TypeFullName, "#4");
273 }
274
275 [Test]
276 public void TestUIntTypeMapping()
277 {
278 XmlTypeMapping tm = Map(typeof(uint));
279 Assert.AreEqual ("unsignedInt", tm.ElementName, "#1");
280 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
281 Assert.AreEqual ("UInt32", tm.TypeName, "#3");
282 Assert.AreEqual ("System.UInt32", tm.TypeFullName, "#4");
283 }
284
285 [Test]
286 public void TestLongTypeMapping()
287 {
288 XmlTypeMapping tm = Map(typeof(long));
289 Assert.AreEqual ("long", tm.ElementName, "#1");
290 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
291 Assert.AreEqual ("Int64", tm.TypeName, "#3");
292 Assert.AreEqual ("System.Int64", tm.TypeFullName, "#4");
293 }
294
295 [Test]
296 public void TestULongTypeMapping()
297 {
298 XmlTypeMapping tm = Map(typeof(ulong));
299 Assert.AreEqual ("unsignedLong", tm.ElementName, "#1");
300 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
301 Assert.AreEqual ("UInt64", tm.TypeName, "#3");
302 Assert.AreEqual ("System.UInt64", tm.TypeFullName, "#4");
303 }
304
305 [Test]
306 public void TestFloatTypeMapping()
307 {
308 XmlTypeMapping tm = Map(typeof(float));
309 Assert.AreEqual ("float", tm.ElementName, "#1");
310 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
311 Assert.AreEqual ("Single", tm.TypeName, "#3");
312 Assert.AreEqual ("System.Single", tm.TypeFullName, "#4");
313 }
314
315 [Test]
316 public void TestDoubleTypeMapping()
317 {
318 XmlTypeMapping tm = Map(typeof(double));
319 Assert.AreEqual ("double", tm.ElementName, "#1");
320 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
321 Assert.AreEqual ("Double", tm.TypeName, "#3");
322 Assert.AreEqual ("System.Double", tm.TypeFullName, "#4");
323 }
324
325 [Test]
326 public void TestDateTimeTypeMapping()
327 {
328 XmlTypeMapping tm = Map(typeof(DateTime));
329 Assert.AreEqual ("dateTime", tm.ElementName, "#1");
330 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
331 Assert.AreEqual ("DateTime", tm.TypeName, "#3");
332 Assert.AreEqual ("System.DateTime", tm.TypeFullName, "#4");
333 }
334
335 [Test]
336 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
337 public void TestDateTimeTypeMapping_Array ()
338 {
339 XmlTypeMapping tm = Map (typeof (DateTime[]));
340 Assert.AreEqual ("ArrayOfDateTime", tm.ElementName, "#A1");
341 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
342 Assert.AreEqual ("ArrayOfDateTime", tm.TypeName, "#A3");
343 Assert.AreEqual ("System.DateTime[]", tm.TypeFullName, "#A4");
344
345 tm = Map (typeof (DateTime[][]));
346 Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.ElementName, "#B1");
347 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
348 Assert.AreEqual ("ArrayOfArrayOfDateTime", tm.TypeName, "#B3");
349 Assert.AreEqual ("System.DateTime[][]", tm.TypeFullName, "#B4");
350
351 tm = Map (typeof (DateTime[][][]));
352 Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.ElementName, "#C1");
353 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
354 Assert.AreEqual ("ArrayOfArrayOfArrayOfDateTime", tm.TypeName, "#C3");
355 Assert.AreEqual ("System.DateTime[][][]", tm.TypeFullName, "#C4");
356 }
357
358 [Test]
359 public void TestGuidTypeMapping()
360 {
361 XmlTypeMapping tm = Map(typeof(Guid));
362 Assert.AreEqual ("guid", tm.ElementName, "#1");
363 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
364 Assert.AreEqual ("Guid", tm.TypeName, "#3");
365 Assert.AreEqual ("System.Guid", tm.TypeFullName, "#4");
366 }
367
368 [Test]
369 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
370 public void TestGuidTypeMapping_Array ()
371 {
372 XmlTypeMapping tm = Map (typeof (Guid[]));
373 Assert.AreEqual ("ArrayOfGuid", tm.ElementName, "#A1");
374 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
375 Assert.AreEqual ("ArrayOfGuid", tm.TypeName, "#A3");
376 Assert.AreEqual ("System.Guid[]", tm.TypeFullName, "#A4");
377
378 tm = Map (typeof (Guid[][]));
379 Assert.AreEqual ("ArrayOfArrayOfGuid", tm.ElementName, "#B1");
380 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
381 Assert.AreEqual ("ArrayOfArrayOfGuid", tm.TypeName, "#B3");
382 Assert.AreEqual ("System.Guid[][]", tm.TypeFullName, "#B4");
383
384 tm = Map (typeof (Guid[][][]));
385 Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.ElementName, "#C1");
386 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
387 Assert.AreEqual ("ArrayOfArrayOfArrayOfGuid", tm.TypeName, "#C3");
388 Assert.AreEqual ("System.Guid[][][]", tm.TypeFullName, "#C4");
389 }
390
391 [Test]
392 public void TestDecimalTypeMapping()
393 {
394 XmlTypeMapping tm = Map(typeof(decimal));
395 Assert.AreEqual ("decimal", tm.ElementName, "#1");
396 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
397 Assert.AreEqual ("Decimal", tm.TypeName, "#3");
398 Assert.AreEqual ("System.Decimal", tm.TypeFullName, "#4");
399 }
400
401 [Test]
402 public void TestXmlQualifiedNameTypeMapping()
403 {
404 XmlTypeMapping tm = Map(typeof(XmlQualifiedName));
405 Assert.AreEqual ("QName", tm.ElementName, "#1");
406 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
407 Assert.AreEqual ("XmlQualifiedName", tm.TypeName, "#3");
408 Assert.AreEqual ("System.Xml.XmlQualifiedName", tm.TypeFullName, "#4");
409 }
410
411 [Test]
412 public void TestSByteTypeMapping()
413 {
414 XmlTypeMapping tm = Map(typeof(sbyte));
415 Assert.AreEqual ("byte", tm.ElementName, "#1");
416 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
417 Assert.AreEqual ("SByte", tm.TypeName, "#3");
418 Assert.AreEqual ("System.SByte", tm.TypeFullName, "#4");
419 }
420
421
422 [Test]
423 public void TestCharTypeMapping()
424 {
425 XmlTypeMapping tm = Map(typeof(char));
426 Assert.AreEqual ("char", tm.ElementName, "#1");
427 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
428 Assert.AreEqual ("Char", tm.TypeName, "#3");
429 Assert.AreEqual ("System.Char", tm.TypeFullName, "#4");
430 }
431
432 [Test]
433 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
434 public void TestCharTypeMapping_Array ()
435 {
436 XmlTypeMapping tm = Map (typeof (char[]));
437 Assert.AreEqual ("ArrayOfChar", tm.ElementName, "#A1");
438 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
439 Assert.AreEqual ("ArrayOfChar", tm.TypeName, "#A3");
440 Assert.AreEqual ("System.Char[]", tm.TypeFullName, "#A4");
441
442 tm = Map (typeof (char[][]));
443 Assert.AreEqual ("ArrayOfArrayOfChar", tm.ElementName, "#B1");
444 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
445 Assert.AreEqual ("ArrayOfArrayOfChar", tm.TypeName, "#B3");
446 Assert.AreEqual ("System.Char[][]", tm.TypeFullName, "#B4");
447
448 tm = Map (typeof (char[][][]));
449 Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.ElementName, "#C1");
450 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
451 Assert.AreEqual ("ArrayOfArrayOfArrayOfChar", tm.TypeName, "#C3");
452 Assert.AreEqual ("System.Char[][][]", tm.TypeFullName, "#C4");
453 }
454
455 [Test]
456 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
457 public void TestXmlNodeTypeMapping ()
458 {
459 Type type = typeof (XmlNode);
460
461 XmlTypeMapping tm = Map (type);
462 Assert.AreEqual (string.Empty, tm.ElementName, "#A1");
463 Assert.IsNull (tm.Namespace, "#A2");
464 Assert.AreEqual ("XmlNode", tm.TypeName, "#A3");
465 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#A4");
466
467 tm = Map (type, AnotherNamespace);
468 Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
469 Assert.IsNull (tm.Namespace, "#B2");
470 Assert.AreEqual ("XmlNode", tm.TypeName, "#B3");
471 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#B4");
472
473 XmlRootAttribute root = new XmlRootAttribute ("somename");
474 root.Namespace = SomeNamespace;
475 tm = Map (type, root);
476 Assert.AreEqual ("somename", tm.ElementName, "#C1");
477 Assert.IsNull (tm.Namespace, "#C2");
478 Assert.AreEqual ("XmlNode", tm.TypeName, "#C3");
479 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#C4");
480
481 tm = Map (type, AnotherNamespace, root);
482 Assert.AreEqual ("somename", tm.ElementName, "#D1");
483 Assert.IsNull (tm.Namespace, "#D2");
484 Assert.AreEqual ("XmlNode", tm.TypeName, "#D3");
485 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#D4");
486
487 root.Namespace = null;
488 tm = Map (type, root);
489 Assert.AreEqual ("somename", tm.ElementName, "#E1");
490 Assert.IsNull (tm.Namespace, "#E2");
491 Assert.AreEqual ("XmlNode", tm.TypeName, "#E3");
492 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#E4");
493
494 tm = Map (type, AnotherNamespace, root);
495 Assert.AreEqual ("somename", tm.ElementName, "#F1");
496 Assert.IsNull (tm.Namespace, "#F2");
497 Assert.AreEqual ("XmlNode", tm.TypeName, "#F3");
498 Assert.AreEqual ("System.Xml.XmlNode", tm.TypeFullName, "#F4");
499 }
500
501 [Test]
502 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
503 public void TestXmlElementTypeMapping ()
504 {
505 Type type = typeof (XmlElement);
506
507 XmlTypeMapping tm = Map (type);
508 Assert.AreEqual (string.Empty, tm.ElementName, "#1");
509 Assert.IsNull (tm.Namespace, "#2");
510 Assert.AreEqual ("XmlElement", tm.TypeName, "#3");
511 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#4");
512
513 tm = Map (type, AnotherNamespace);
514 Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
515 Assert.IsNull (tm.Namespace, "#B2");
516 Assert.AreEqual ("XmlElement", tm.TypeName, "#B3");
517 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#B4");
518
519 XmlRootAttribute root = new XmlRootAttribute ("somename");
520 root.Namespace = SomeNamespace;
521 tm = Map (type, root);
522 Assert.AreEqual ("somename", tm.ElementName, "#C1");
523 Assert.IsNull (tm.Namespace, "#C2");
524 Assert.AreEqual ("XmlElement", tm.TypeName, "#C3");
525 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#C4");
526
527 tm = Map (type, AnotherNamespace, root);
528 Assert.AreEqual ("somename", tm.ElementName, "#D1");
529 Assert.IsNull (tm.Namespace, "#D2");
530 Assert.AreEqual ("XmlElement", tm.TypeName, "#D3");
531 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#D4");
532
533 root.Namespace = null;
534 tm = Map (type, root);
535 Assert.AreEqual ("somename", tm.ElementName, "#E1");
536 Assert.IsNull (tm.Namespace, "#E2");
537 Assert.AreEqual ("XmlElement", tm.TypeName, "#E3");
538 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#E4");
539
540 tm = Map (type, AnotherNamespace, root);
541 Assert.AreEqual ("somename", tm.ElementName, "#F1");
542 Assert.IsNull (tm.Namespace, "#F2");
543 Assert.AreEqual ("XmlElement", tm.TypeName, "#F3");
544 Assert.AreEqual ("System.Xml.XmlElement", tm.TypeFullName, "#F4");
545 }
546
547 [Test]
548 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
549 public void TestXmlNotationTypeMapping ()
550 {
551 Type type = typeof (XmlNotation);
552
553 XmlTypeMapping tm = Map (type);
554 Assert.AreEqual (string.Empty, tm.ElementName, "#1");
555 Assert.IsNull (tm.Namespace, "#2");
556 Assert.AreEqual ("XmlNotation", tm.TypeName, "#3");
557 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#4");
558
559 tm = Map (type, AnotherNamespace);
560 Assert.AreEqual (string.Empty, tm.ElementName, "#B1");
561 Assert.IsNull (tm.Namespace, "#B2");
562 Assert.AreEqual ("XmlNotation", tm.TypeName, "#B3");
563 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#B4");
564
565 XmlRootAttribute root = new XmlRootAttribute ("somename");
566 root.Namespace = SomeNamespace;
567 tm = Map (type, root);
568 Assert.AreEqual ("somename", tm.ElementName, "#C1");
569 Assert.IsNull (tm.Namespace, "#C2");
570 Assert.AreEqual ("XmlNotation", tm.TypeName, "#C3");
571 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#C4");
572
573 tm = Map (type, AnotherNamespace, root);
574 Assert.AreEqual ("somename", tm.ElementName, "#D1");
575 Assert.IsNull (tm.Namespace, "#D2");
576 Assert.AreEqual ("XmlNotation", tm.TypeName, "#D3");
577 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#D4");
578
579 root.Namespace = null;
580 tm = Map (type, root);
581 Assert.AreEqual ("somename", tm.ElementName, "#E1");
582 Assert.IsNull (tm.Namespace, "#E2");
583 Assert.AreEqual ("XmlNotation", tm.TypeName, "#E3");
584 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#E4");
585
586 tm = Map (type, AnotherNamespace, root);
587 Assert.AreEqual ("somename", tm.ElementName, "#F1");
588 Assert.IsNull (tm.Namespace, "#F2");
589 Assert.AreEqual ("XmlNotation", tm.TypeName, "#F3");
590 Assert.AreEqual ("System.Xml.XmlNotation", tm.TypeFullName, "#F4");
591 }
592
593 [Test]
594 public void TestXmlSerializableTypeMapping ()
595 {
596 XmlTypeMapping tm = Map (typeof (Employee));
597 Assert.AreEqual ("Employee", tm.ElementName, "#1");
598 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
599 Assert.AreEqual ("Employee", tm.TypeName, "#3");
600 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee", tm.TypeFullName, "#4");
601 }
602
603 [Test]
604 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
605 public void TestXmlSerializableTypeMapping_Array ()
606 {
607 XmlTypeMapping tm = Map (typeof (Employee[]));
608 Assert.AreEqual ("ArrayOfEmployee", tm.ElementName, "#A1");
609 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
610 Assert.AreEqual ("ArrayOfEmployee", tm.TypeName, "#A3");
611 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[]", tm.TypeFullName, "#A4");
612
613 tm = Map (typeof (Employee[][]));
614 Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.ElementName, "#B1");
615 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
616 Assert.AreEqual ("ArrayOfArrayOfEmployee", tm.TypeName, "#B3");
617 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][]", tm.TypeFullName, "#B4");
618
619 tm = Map (typeof (Employee[][][]));
620 Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.ElementName, "#C1");
621 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
622 Assert.AreEqual ("ArrayOfArrayOfArrayOfEmployee", tm.TypeName, "#C3");
623 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.Employee[][][]", tm.TypeFullName, "#C4");
624 }
625
626 [Test]
627 public void TestClassTypeMapping_NestedStruct ()
628 {
629 XmlTypeMapping tm = Map (typeof (NestedStruct));
630 Assert.AreEqual ("NestedStruct", tm.ElementName, "#1");
631 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
632 Assert.AreEqual ("NestedStruct", tm.TypeName, "#3");
633 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.NestedStruct", tm.TypeFullName, "#4");
634 }
635
636 [Test]
637 [ExpectedException (typeof (ArgumentNullException))]
638 public void TestNullTypeMapping()
639 {
640 Map(null);
641 }
642
643 [Test]
644 public void TestIntTypeMappingWithDefaultNamespaces()
645 {
646 XmlTypeMapping tm = Map(typeof(int), SomeNamespace);
647 Assert.AreEqual ("int", tm.ElementName, "#1");
648 Assert.AreEqual (SomeNamespace, tm.Namespace, "#2");
649 Assert.AreEqual ("Int32", tm.TypeName, "#3");
650 Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
651 }
652
653 [Test]
654 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
655 public void TestStructTypeMapping ()
656 {
657 XmlTypeMapping tm = Map (typeof (TimeSpan));
658 Assert.AreEqual ("TimeSpan", tm.ElementName, "#1");
659 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
660 Assert.AreEqual ("TimeSpan", tm.TypeName, "#3");
661 Assert.AreEqual ("System.TimeSpan", tm.TypeFullName, "#4");
662 }
663
664 [Test]
665 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
666 public void TestStructTypeMapping_Array ()
667 {
668 XmlTypeMapping tm = Map (typeof (TimeSpan[]));
669 Assert.AreEqual ("ArrayOfTimeSpan", tm.ElementName, "#A1");
670 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
671 Assert.AreEqual ("ArrayOfTimeSpan", tm.TypeName, "#A3");
672 Assert.AreEqual ("System.TimeSpan[]", tm.TypeFullName, "#A4");
673
674 tm = Map (typeof (TimeSpan[][]));
675 Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.ElementName, "#B1");
676 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
677 Assert.AreEqual ("ArrayOfArrayOfTimeSpan", tm.TypeName, "#B3");
678 Assert.AreEqual ("System.TimeSpan[][]", tm.TypeFullName, "#B4");
679
680 tm = Map (typeof (TimeSpan[][][]));
681 Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.ElementName, "#C1");
682 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
683 Assert.AreEqual ("ArrayOfArrayOfArrayOfTimeSpan", tm.TypeName, "#C3");
684 Assert.AreEqual ("System.TimeSpan[][][]", tm.TypeFullName, "#C4");
685 }
686
687 [Test]
688 public void TestEnumTypeMapping ()
689 {
690 XmlTypeMapping tm = Map (typeof (AttributeTargets));
691 Assert.AreEqual ("AttributeTargets", tm.ElementName, "#1");
692 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
693 Assert.AreEqual ("AttributeTargets", tm.TypeName, "#3");
694 Assert.AreEqual ("System.AttributeTargets", tm.TypeFullName, "#4");
695 }
696
697 [Test]
698 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
699 public void TestEnumTypeMapping_Array ()
700 {
701 XmlTypeMapping tm = Map (typeof (AttributeTargets[]));
702 Assert.AreEqual ("ArrayOfAttributeTargets", tm.ElementName, "#A1");
703 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
704 Assert.AreEqual ("ArrayOfAttributeTargets", tm.TypeName, "#A3");
705 Assert.AreEqual ("System.AttributeTargets[]", tm.TypeFullName, "#A4");
706
707 tm = Map (typeof (AttributeTargets[][]));
708 Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.ElementName, "#B1");
709 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
710 Assert.AreEqual ("ArrayOfArrayOfAttributeTargets", tm.TypeName, "#B3");
711 Assert.AreEqual ("System.AttributeTargets[][]", tm.TypeFullName, "#B4");
712
713 tm = Map (typeof (AttributeTargets[][][]));
714 Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.ElementName, "#C1");
715 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
716 Assert.AreEqual ("ArrayOfArrayOfArrayOfAttributeTargets", tm.TypeName, "#C3");
717 Assert.AreEqual ("System.AttributeTargets[][][]", tm.TypeFullName, "#C4");
718 }
719
720 [Test]
721 public void TestClassTypeMapping()
722 {
723 XmlTypeMapping tm = Map (typeof (SimpleClass));
724 Assert.AreEqual ("SimpleClass", tm.ElementName, "#1");
725 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
726 Assert.AreEqual ("SimpleClass", tm.TypeName, "#3");
727 Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass", tm.TypeFullName, "#4");
728 }
729
730 [Test]
731 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
732 public void TestClassTypeMapping_Array ()
733 {
734 XmlTypeMapping tm = Map (typeof (SimpleClass[]));
735 Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#A1");
736 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
737 Assert.AreEqual ("ArrayOfSimpleClass", tm.TypeName, "#A3");
738 Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[]", tm.TypeFullName, "#A4");
739
740 tm = Map (typeof (SimpleClass[][]));
741 Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
742 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
743 Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.TypeName, "#B3");
744 Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][]", tm.TypeFullName, "#B4");
745
746 tm = Map (typeof (SimpleClass[][][]));
747 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
748 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
749 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.TypeName, "#C3");
750 Assert.AreEqual ("MonoTests.System.Xml.TestClasses.SimpleClass[][][]", tm.TypeFullName, "#C4");
751 }
752
753 [Test]
754 [ExpectedException (typeof (NotSupportedException))]
755 public void TypeMapping_IDictionary ()
756 {
757 // The type MonoTests.System.Xml.TestClasses.DictionaryWithIndexer
758 // is not supported because it implements IDictionary.
759 Map (typeof (DictionaryWithIndexer));
760 }
761
762 [Test]
763 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
764 public void TypeMapping_IEnumerable_SimpleClass ()
765 {
766 XmlTypeMapping tm = Map (typeof (SimpleClassEnumerable));
767 Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");
768 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
769 Assert.AreEqual ("SimpleClassEnumerable", tm.TypeName, "#3");
770 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable", tm.TypeFullName, "#4");
771
772 tm = Map (typeof (SimpleClassEnumerable[]));
773 Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");
774 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
775 Assert.AreEqual ("ArrayOfSimpleClassEnumerable", tm.TypeName, "#A3");
776 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[]", tm.TypeFullName, "#A4");
777
778 tm = Map (typeof (SimpleClassEnumerable[][]));
779 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
780 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
781 Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#B3");
782 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][]", tm.TypeFullName, "#B4");
783
784 tm = Map (typeof (SimpleClassEnumerable[][][]));
785 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
786 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
787 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerable", tm.TypeName, "#C3");
788 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerable[][][]", tm.TypeFullName, "#C4");
789 }
790
791 [Test]
792 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
793 public void TypeMapping_IEnumerable_Object ()
794 {
795 XmlTypeMapping tm = Map (typeof (ObjectEnumerable));
796 Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
797 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
798 Assert.AreEqual ("ObjectEnumerable", tm.TypeName, "#3");
799 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable", tm.TypeFullName, "#4");
800
801 tm = Map (typeof (ObjectEnumerable[]));
802 Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
803 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
804 Assert.AreEqual ("ArrayOfObjectEnumerable", tm.TypeName, "#A3");
805 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[]", tm.TypeFullName, "#A4");
806
807 tm = Map (typeof (ObjectEnumerable[][]));
808 Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
809 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
810 Assert.AreEqual ("ArrayOfArrayOfObjectEnumerable", tm.TypeName, "#B3");
811 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][]", tm.TypeFullName, "#B4");
812
813 tm = Map (typeof (ObjectEnumerable[][][]));
814 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
815 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
816 Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectEnumerable", tm.TypeName, "#C3");
817 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectEnumerable[][][]", tm.TypeFullName, "#C4");
818 }
819
820 [Test]
821 [ExpectedException (typeof (InvalidOperationException))]
822 public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod ()
823 {
824 Map (typeof (ObjectEnumerableNoMatchingAddMethod));
825 }
826
827 [Test]
828 [ExpectedException (typeof (InvalidOperationException))]
829 public void TypeMapping_IEnumerable_Object_NoMatchingAddMethod_Array ()
830 {
831 Map (typeof (ObjectEnumerableNoMatchingAddMethod[]));
832 }
833
834 [Test]
835 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
836 public void TypeMapping_IEnumerable_SimpleClass_PrivateCurrent ()
837 {
838 XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateCurrent));
839 Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
840 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
841 Assert.AreEqual ("SimpleClassEnumerablePrivateCurrent", tm.TypeName, "#3");
842 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent", tm.TypeFullName, "#4");
843
844 tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[]));
845 Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
846 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
847 Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#A3");
848 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[]", tm.TypeFullName, "#A4");
849
850 tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][]));
851 Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
852 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
853 Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#B3");
854 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][]", tm.TypeFullName, "#B4");
855
856 tm = Map (typeof (SimpleClassEnumerablePrivateCurrent[][][]));
857 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
858 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
859 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateCurrent", tm.TypeName, "#C3");
860 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateCurrent[][][]", tm.TypeFullName, "#C4");
861 }
862
863 [Test]
864 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
865 public void TypeMapping_IEnumerable_SimpleClass_PrivateGetEnumerator ()
866 {
867 XmlTypeMapping tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator));
868 Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
869 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
870 Assert.AreEqual ("SimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#3");
871 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator", tm.TypeFullName, "#4");
872
873 tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[]));
874 Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
875 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
876 Assert.AreEqual ("ArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#A3");
877 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[]", tm.TypeFullName, "#A4");
878
879 tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][]));
880 Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
881 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
882 Assert.AreEqual ("ArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#B3");
883 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][]", tm.TypeFullName, "#B4");
884
885 tm = Map (typeof (SimpleClassEnumerablePrivateGetEnumerator[][][]));
886 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
887 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
888 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassEnumerablePrivateGetEnumerator", tm.TypeName, "#C3");
889 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassEnumerablePrivateGetEnumerator[][][]", tm.TypeFullName, "#C4");
890 }
891
892 [Test]
893 [ExpectedException (typeof (InvalidOperationException))]
894 public void TypeMapping_ICollection_Object_NoMatchingAddMethod ()
895 {
896 Map (typeof (ObjectCollectionNoMatchingAddMethod));
897 }
898
899 [Test]
900 [ExpectedException (typeof (InvalidOperationException))]
901 public void TypeMapping_ICollection_Object_NoMatchingAddMethod_Array ()
902 {
903 Map (typeof (ObjectCollectionNoMatchingAddMethod[]));
904 }
905
906 [Test]
907 [ExpectedException (typeof (InvalidOperationException))]
908 public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod ()
909 {
910 Map (typeof (SimpleClassCollectionNoMatchingAddMethod));
911 }
912
913 [Test]
914 [ExpectedException (typeof (InvalidOperationException))]
915 public void TypeMapping_ICollection_SimpleClass_NoMatchingAddMethod_Array ()
916 {
917 Map (typeof (SimpleClassCollectionNoMatchingAddMethod[]));
918 }
919
920 [Test]
921 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
922 public void TypeMapping_ICollection_SimpleClass ()
923 {
924 XmlTypeMapping tm = Map (typeof (SimpleClassCollection));
925 Assert.AreEqual ("ArrayOfSimpleClass", tm.ElementName, "#1");
926 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
927 Assert.AreEqual ("SimpleClassCollection", tm.TypeName, "#3");
928 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection", tm.TypeFullName, "#4");
929
930 tm = Map (typeof (SimpleClassCollection[]));
931 Assert.AreEqual ("ArrayOfArrayOfSimpleClass", tm.ElementName, "#A1");
932 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
933 Assert.AreEqual ("ArrayOfSimpleClassCollection", tm.TypeName, "#A3");
934 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[]", tm.TypeFullName, "#A4");
935
936 tm = Map (typeof (SimpleClassCollection[][]));
937 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#B1");
938 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
939 Assert.AreEqual ("ArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#B3");
940 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][]", tm.TypeFullName, "#B4");
941
942 tm = Map (typeof (SimpleClassCollection[][][]));
943 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfSimpleClass", tm.ElementName, "#C1");
944 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
945 Assert.AreEqual ("ArrayOfArrayOfArrayOfSimpleClassCollection", tm.TypeName, "#C3");
946 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.SimpleClassCollection[][][]", tm.TypeFullName, "#C4");
947 }
948
949 [Test]
950 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
951 public void TypeMapping_ICollection_Object ()
952 {
953 XmlTypeMapping tm = Map (typeof (ObjectCollection));
954 Assert.AreEqual ("ArrayOfAnyType", tm.ElementName, "#1");
955 Assert.AreEqual (string.Empty, tm.Namespace, "#2");
956 Assert.AreEqual ("ObjectCollection", tm.TypeName, "#3");
957 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection", tm.TypeFullName, "#4");
958
959 tm = Map (typeof (ObjectCollection[]));
960 Assert.AreEqual ("ArrayOfArrayOfAnyType", tm.ElementName, "#A1");
961 Assert.AreEqual (string.Empty, tm.Namespace, "#A2");
962 Assert.AreEqual ("ArrayOfObjectCollection", tm.TypeName, "#A3");
963 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[]", tm.TypeFullName, "#A4");
964
965 tm = Map (typeof (ObjectCollection[][]));
966 Assert.AreEqual ("ArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#B1");
967 Assert.AreEqual (string.Empty, tm.Namespace, "#B2");
968 Assert.AreEqual ("ArrayOfArrayOfObjectCollection", tm.TypeName, "#B3");
969 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][]", tm.TypeFullName, "#B4");
970
971 tm = Map (typeof (ObjectCollection[][][]));
972 Assert.AreEqual ("ArrayOfArrayOfArrayOfArrayOfAnyType", tm.ElementName, "#C1");
973 Assert.AreEqual (string.Empty, tm.Namespace, "#C2");
974 Assert.AreEqual ("ArrayOfArrayOfArrayOfObjectCollection", tm.TypeName, "#C3");
975 Assert.AreEqual ("MonoTests.System.XmlSerialization.XmlReflectionImporterTests.ObjectCollection[][][]", tm.TypeFullName, "#C4");
976 }
977
978 [Test]
979 [ExpectedException (typeof (InvalidOperationException))]
980 public void TypeMapping_ICollection_Object_NoIntIndexer ()
981 {
982 Map (typeof (ObjectCollectionNoIntIndexer));
983 }
984
985 [Test]
986 [ExpectedException (typeof (InvalidOperationException))]
987 public void TypeMapping_ICollection_Object_NoIntIndexer_Array ()
988 {
989 Map (typeof (ObjectCollectionNoIntIndexer[]));
990 }
991
992 [Test]
993 [ExpectedException (typeof (InvalidOperationException))]
994 public void TypeMapping_ICollection_SimpleClass_NoIntIndexer ()
995 {
996 Map (typeof (SimpleClassCollectionNoIntIndexer));
997 }
998
999 [Test]
1000 [ExpectedException (typeof (InvalidOperationException))]
1001 public void TypeMapping_ICollection_SimpleClass_NoIntIndexer_Array ()
1002 {
1003 Map (typeof (SimpleClassCollectionNoIntIndexer[]));
1004 }
1005
1006 [Test]
1007 public void TypeMapping_InvalidDefault ()
1008 {
1009 XmlAttributes attrs = new XmlAttributes (typeof (Field).GetMember ("Modifiers") [0]);
1010 attrs.XmlDefaultValue = 2; // not a defined enum value
1011 XmlAttributeOverrides overrides = new XmlAttributeOverrides ();
1012 overrides.Add (typeof (Field), "Modifiers", attrs);
1013
1014 try {
1015 Map (typeof (Field), overrides);
1016 Assert.Fail ("#A1");
1017 } catch (InvalidOperationException ex) {
1018 // There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
1019 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
1020 Assert.IsNotNull (ex.Message, "#A3");
1021 Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#A4");
1022 Assert.IsNotNull (ex.InnerException, "#A5");
1023
1024 // There was an error reflecting field 'Modifiers'
1025 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#A6");
1026 Assert.IsNotNull (ex.InnerException.Message, "#A7");
1027 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#A8");
1028 Assert.IsNotNull (ex.InnerException.InnerException, "#A9");
1029
1030 // Value '2' cannot be converted to System.Int32
1031 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#A10");
1032 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#A11");
1033 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'2'") != -1, "#A12");
1034 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (int).FullName) != -1, "#A13");
1035 Assert.IsNull (ex.InnerException.InnerException.InnerException, "#A14");
1036 }
1037
1038 attrs.XmlDefaultValue = "2"; // not of the same type as the underlying enum type (System.Int32)
1039
1040 try {
1041 Map (typeof (Field), overrides);
1042 Assert.Fail ("#B1");
1043 } catch (InvalidOperationException ex) {
1044 // There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
1045 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1046 Assert.IsNotNull (ex.Message, "#B3");
1047 Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#B4");
1048 Assert.IsNotNull (ex.InnerException, "#B5");
1049
1050 // There was an error reflecting field 'Modifiers'
1051 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B6");
1052 Assert.IsNotNull (ex.InnerException.Message, "#B7");
1053 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#B8");
1054 Assert.IsNotNull (ex.InnerException.InnerException, "#B9");
1055
1056 // Enum underlying type and the object must be same type or object.
1057 // Type passed in was 'System.String'; the enum underlying type was
1058 // 'System.Int32'.
1059 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.InnerException.GetType (), "#B10");
1060 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#B11");
1061 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (string).FullName) != -1, "#B12");
1062 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (int).FullName) != -1, "#B13");
1063 Assert.IsNull (ex.InnerException.InnerException.InnerException, "#B14");
1064 }
1065
1066 attrs.XmlDefaultValue = EnumDefaultValueNF.e2; // other enum type
1067
1068 try {
1069 Map (typeof (Field), overrides);
1070 Assert.Fail ("#C1");
1071 } catch (InvalidOperationException ex) {
1072 // There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
1073 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1074 Assert.IsNotNull (ex.Message, "#C3");
1075 Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#C4");
1076 Assert.IsNotNull (ex.InnerException, "#C5");
1077
1078 // There was an error reflecting field 'Modifiers'
1079 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C6");
1080 Assert.IsNotNull (ex.InnerException.Message, "#C7");
1081 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#C8");
1082 Assert.IsNotNull (ex.InnerException.InnerException, "#C9");
1083
1084 // Object must be the same type as the enum. The type passed in
1085 // was MonoTests.System.Xml.TestClasses.EnumDefaultValueNF; the
1086 // enum type was MonoTests.System.Xml.TestClasses.MapModifiers
1087 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.InnerException.GetType (), "#C10");
1088 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#C11");
1089 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).FullName) != -1, "#C12");
1090 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (MapModifiers).FullName) != -1, "#C13");
1091 Assert.IsNull (ex.InnerException.InnerException.InnerException, "#C14");
1092 }
1093
1094 attrs.XmlDefaultValue = (MapModifiers) 20; // non-existing enum value
1095
1096 try {
1097 Map (typeof (Field), overrides);
1098 Assert.Fail ("#D1");
1099 } catch (InvalidOperationException ex) {
1100 // There was an error reflecting type MonoTests.System.Xml.TestClasses.Field
1101 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1102 Assert.IsNotNull (ex.Message, "#D3");
1103 Assert.IsTrue (ex.Message.IndexOf (typeof (Field).FullName) != -1, "#D4");
1104 Assert.IsNotNull (ex.InnerException, "#D5");
1105
1106 // There was an error reflecting field 'Modifiers'
1107 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D6");
1108 Assert.IsNotNull (ex.InnerException.Message, "#D7");
1109 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#D8");
1110 Assert.IsNotNull (ex.InnerException.InnerException, "#D9");
1111
1112 // Value '20' cannot be converted to MonoTests.System.Xml.TestClasses.MapModifiers
1113 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.InnerException.GetType (), "#D10");
1114 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#D11");
1115 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'20'") != -1, "#D12");
1116 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (MapModifiers).FullName) != -1, "#D13");
1117 Assert.IsNull (ex.InnerException.InnerException.InnerException, "#D14");
1118 }
1119 }
1120
1121 [Test]
1122 [ExpectedException (typeof (ArgumentNullException))]
1123 public void TypeMapping_Null ()
1124 {
1125 Map ((Type) null);
1126 }
1127
1128 [Test]
1129 [ExpectedException (typeof (NotSupportedException))]
1130 public void TypeMapping_Void ()
1131 {
1132 Map (typeof (void));
1133 }
1134
1135 [Test]
1136 public void TypeMapping_WrongChoices ()
1137 {
1138 try {
1139 Map (typeof (WrongChoices));
1140 Assert.Fail ("#1");
1141 } catch (InvalidOperationException ex) {
1142 // There was an error reflecting type 'MonoTests.System.Xml.TestClasses.WrongChoices'
1143 Assert.IsNotNull (ex.Message, "#2");
1144 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (WrongChoices).FullName + "'") != -1, "#3");
1145 Assert.IsNotNull (ex.InnerException, "#4");
1146
1147 // There was an error reflecting field 'MyChoice'
1148 Assert.IsNotNull (ex.InnerException.Message, "#5");
1149 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'MyChoice'") != -1, "#6");
1150 Assert.IsNotNull (ex.InnerException.InnerException, "#7");
1151
1152 // Type MonoTests.System.Xml.TestClasses.ItemChoiceType is missing
1153 // enumeration value 'StrangeOne' for element 'StrangeOne' from
1154 // namespace ''.
1155 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#8");
1156 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf (typeof (ItemChoiceType).FullName) != -1, "#9");
1157 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("'StrangeOne'") != -1, "#10");
1158 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("''") != -1, "#11");
1159 }
1160 }
1161
1162 [Test] // bug #77591
1163 public void TypeMapping_XmlText_PrimitiveTypes ()
1164 {
1165 XmlAttributeOverrides overrides = null;
1166 XmlAttributes attrs = null;
1167
1168 overrides = new XmlAttributeOverrides ();
1169 attrs = new XmlAttributes ();
1170 attrs.XmlText = new XmlTextAttribute (typeof (int));
1171 overrides.Add (typeof (Field), "Modifiers", attrs);
1172
1173 try {
1174 Map (typeof (Field), overrides);
1175 Assert.Fail ("#A1");
1176 } catch (InvalidOperationException ex) {
1177 // There was an error reflecting type 'MonoTests.System.Xml.TestClasses.Field'
1178 Assert.IsNotNull (ex.Message, "#A2");
1179 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Field).FullName + "'") != -1, "#A3");
1180 Assert.IsNotNull (ex.InnerException, "#A4");
1181
1182 // There was an error reflecting field 'Modifiers'
1183 Assert.IsNotNull (ex.InnerException.Message, "#A5");
1184 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Modifiers'") != -1, "#A6");
1185 Assert.IsNotNull (ex.InnerException.InnerException, "#A7");
1186
1187 // The type for XmlText may not be specified for primitive types
1188 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#A8");
1189 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("XmlText") != -1, "#A9");
1190 }
1191
1192 overrides = new XmlAttributeOverrides ();
1193 attrs = new XmlAttributes ();
1194 attrs.XmlText = new XmlTextAttribute (typeof (int));
1195 overrides.Add (typeof (Field), "Street", attrs);
1196
1197 try {
1198 Map (typeof (Field), overrides);
1199 Assert.Fail ("#B1");
1200 } catch (InvalidOperationException ex) {
1201 // There was an error reflecting type 'MonoTests.System.Xml.TestClasses.Field'
1202 Assert.IsNotNull (ex.Message, "#B2");
1203 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Field).FullName + "'") != -1, "#B3");
1204 Assert.IsNotNull (ex.InnerException, "#B4");
1205
1206 // There was an error reflecting field 'Street'
1207 Assert.IsNotNull (ex.InnerException.Message, "#B5");
1208 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Street'") != -1, "#B6");
1209 Assert.IsNotNull (ex.InnerException.InnerException, "#B7");
1210
1211 // The type for XmlText may not be specified for primitive types
1212 Assert.IsNotNull (ex.InnerException.InnerException.Message, "#B8");
1213 Assert.IsTrue (ex.InnerException.InnerException.Message.IndexOf ("XmlText") != -1, "#B9");
1214 }
1215
1216 overrides = new XmlAttributeOverrides ();
1217 attrs = new XmlAttributes ();
1218 attrs.XmlText = new XmlTextAttribute (typeof (MapModifiers));
1219 overrides.Add (typeof (Field), "Modifiers", attrs);
1220 Map (typeof (Field), overrides);
1221
1222 overrides = new XmlAttributeOverrides ();
1223 attrs = new XmlAttributes ();
1224 attrs.XmlText = new XmlTextAttribute (typeof (string));
1225 overrides.Add (typeof (Field), "Street", attrs);
1226 Map (typeof (Field), overrides);
1227 }
1228
1229 [Test]
1230 [Category ("NotWorking")] // mark it NotWorking until fixes have landed in svn
1231 public void TestImportMembersMapping()
1232 {
1233 Type type = typeof(SimpleClass);
1234 XmlAttributes attrs = new XmlAttributes();
1235 XmlAttributeOverrides overrides = new XmlAttributeOverrides();
1236 overrides.Add(typeof(SimpleClass), attrs);
1237
1238 XmlReflectionMember[] members = new XmlReflectionMember[0];
1239 XmlMembersMapping mm;
1240 try
1241 {
1242 mm = MembersMap(type, overrides, members, true);
1243 Assert.Fail("Should not be able to fetch an empty XmlMembersMapping");
1244 }
1245 catch (Exception)
1246 {
1247 }
1248
1249 XmlReflectionMember rm = new XmlReflectionMember();
1250 rm.IsReturnValue = false;
1251 rm.MemberName = "something";
1252 rm.MemberType = typeof(string);
1253 members = new XmlReflectionMember[1];
1254 members[0] = rm;
1255
1256 mm = MembersMap(type, overrides, members, false);
1257
1258 Equals(mm.Count, 1);
1259
1260 XmlMemberMapping smm = mm[0];
1261 Assert.IsFalse (smm.Any, "#1");
1262 Assert.AreEqual ("something", smm.ElementName, "#2");
1263 Assert.AreEqual ("something", smm.MemberName, "#3");
1264 Assert.IsNull (smm.Namespace, "#4");
1265 Assert.AreEqual ("System.String", smm.TypeFullName, "#5");
1266 Assert.AreEqual ("string", smm.TypeName, "#6");
1267 Assert.AreEqual (XmlSchemaNamespace, smm.TypeNamespace, "#7");
1268
1269 rm = new XmlReflectionMember();
1270 rm.IsReturnValue = false;
1271 rm.MemberName = "nothing";
1272 rm.MemberType = typeof(string);
1273 members = new XmlReflectionMember[1];
1274 members[0] = rm;
1275
1276 mm = MembersMap(type, overrides, members, false);
1277 Assert.AreEqual (1, mm.Count, "#8");
1278 }
1279
1280 [Test]
1281 public void TestIntTypeMappingWithXmlRootAttribute()
1282 {
1283 const string TheNamespace = "another:urn";
1284 XmlRootAttribute root = new XmlRootAttribute("price");
1285 root.Namespace = TheNamespace;
1286
1287 XmlTypeMapping tm = Map(typeof(int), root);
1288 Assert.AreEqual ("price", tm.ElementName, "#1");
1289 Assert.AreEqual (TheNamespace, tm.Namespace, "#2");
1290 Assert.AreEqual ("Int32", tm.TypeName, "#3");
1291 Assert.AreEqual ("System.Int32", tm.TypeFullName, "#4");
1292 }
1293
1294 [Test]
1295 [ExpectedException (typeof (InvalidOperationException))]
1296 public void TestSerializeWrongChoice ()
1297 {
1298 new XmlSerializer (typeof(WrongChoices));
1299 }
1300
1301 [Test]
1302 public void XmlArrayOnByteArray ()
1303 {
1304 new XmlSerializer (typeof (XmlArrayOnByteArrayType));
1305 }
1306
1307
1308 [Test]
1309 public void ImportNullableInt ()
1310 {
1311 XmlReflectionImporter imp = new XmlReflectionImporter ();
1312 XmlTypeMapping map = imp.ImportTypeMapping (typeof (int?));
1313 XmlSchemas schemas = new XmlSchemas ();
1314 XmlSchemaExporter exp = new XmlSchemaExporter (schemas);
1315 exp.ExportTypeMapping (map);
1316 XmlSchema schema = schemas [0];
1317 XmlSchemaElement el = schema.Items [0] as XmlSchemaElement;
1318 Assert.AreEqual ("int", el.Name, "#1");
1319 Assert.AreEqual (new XmlQualifiedName ("int", XmlSchema.Namespace), el.SchemaTypeName, "#2");
1320 Assert.AreEqual (true, el.IsNillable, "#3");
1321 }
1322
1323 [Test]
1324 public void ImportNullableContainer ()
1325 {
1326 new XmlSerializer (typeof (NullableContainer));
1327 }
1328
1329 [Test]
1330 public void ImportNullableContainer2 ()
1331 {
1332 XmlReflectionImporter imp = new XmlReflectionImporter ();
1333 XmlTypeMapping map = imp.ImportTypeMapping (typeof (NullableContainer2));
1334 XmlSchemas schemas = new XmlSchemas ();
1335 XmlSchemaExporter exp = new XmlSchemaExporter (schemas);
1336 exp.ExportTypeMapping (map);
1337
1338 XmlSchema schema = schemas [0];
1339 XmlSchemaComplexType el = schema.Items [1] as XmlSchemaComplexType;
1340
1341 XmlSchemaSequence s = el.Particle as XmlSchemaSequence;
1342 XmlSchemaElement el2 = s.Items [0] as XmlSchemaElement;
1343 Assert.IsTrue (el2.IsNillable);
1344 }
1345
1346 [Test]
1347 [ExpectedException (typeof (InvalidOperationException))]
1348 public void ImportGenericTypeDefinition ()
1349 {
1350 new XmlSerializer (typeof (List<int>).GetGenericTypeDefinition ());
1351 }
1352
1353 [Test]
1354 [ExpectedException (typeof (InvalidOperationException))]
1355 public void XmlSchemaProviderMissingMethod ()
1356 {
1357 new XmlSerializer (typeof (XmlSchemaProviderMissingMethodType));
1358 }
1359
1360 [Test]
1361 [ExpectedException (typeof (InvalidOperationException))]
1362 public void XmlSchemaProviderMethodNonStatic ()
1363 {
1364 new XmlSerializer (typeof (XmlSchemaProviderNonStaticType));
1365 }
1366
1367 [Test]
1368 [ExpectedException (typeof (InvalidOperationException))]
1369 public void XmlSchemaProviderMethodIncorrectReturn ()
1370 {
1371 new XmlSerializer (typeof (XmlSchemaProviderIncorrectReturnType));
1372 }
1373
1374 [Test]
1375 public void XmlSchemaProviderAndDefaultNamespace ()
1376 {
1377 XmlTypeMapping tm = new XmlReflectionImporter ("urn:bar").ImportTypeMapping (typeof (XmlSchemaProviderAndDefaultNamespaceType));
1378 Assert.AreEqual ("foo", tm.ElementName, "#1");
1379 Assert.AreEqual ("foo", tm.XsdTypeName, "#2");
1380 Assert.AreEqual ("urn:bar", tm.Namespace, "#3");
1381 Assert.AreEqual ("urn:foo", tm.XsdTypeNamespace);
1382 }
1383
1384 [Test]
1385 public void ImportGenericICollectionWrapped ()
1386 {
1387 new XmlSerializer (typeof (MyCollection));
1388 }
1389
1390 [Test]
1391 public void Bug704813Type ()
1392 {
1393 var xs = new XmlSerializer (typeof (Bug704813Type));
1394 xs.Serialize (TextWriter.Null, new Bug704813Type ());
1395 }
1396
1397 [Test]
1398 public void Bug708178Type()
1399 {
1400 string file = Path.Combine (Path.GetTempPath (), "Bug708178Type.xml");
1401 XmlSerializer xmlSerializer = new XmlSerializer (typeof(Bug708178Type));
1402 Bug708178Type bugType = new Bug708178Type ();
1403 bugType.Foo.Add ("test");
1404 Assert.AreEqual (1, bugType.Foo.Count);
1405
1406 //xml Serialize
1407 TextWriter WriteFileStream = new StreamWriter (file, false);
1408 xmlSerializer.Serialize (WriteFileStream, bugType);
1409 WriteFileStream.Close ();
1410
1411 //xml Deserialize
1412 FileStream ReadFileStream = new FileStream (file, FileMode.Open, FileAccess.Read, FileShare.Read);
1413 Bug708178Type bugTypeReload = (Bug708178Type)xmlSerializer.Deserialize (ReadFileStream);
1414
1415 //should have deserialized the relationship
1416 Assert.AreEqual(1, bugTypeReload.Foo.Count);
1417 }
1418
1419 public class Employee : IXmlSerializable
1420 {
1421 private string _firstName;
1422 private string _lastName;
1423 private string _address;
1424
1425 public XmlSchema GetSchema ()
1426 {
1427 return null;
1428 }
1429
1430 public void WriteXml (XmlWriter writer)
1431 {
1432 writer.WriteStartElement ("employee", "urn:devx-com");
1433 writer.WriteAttributeString ("firstName", _firstName);
1434 writer.WriteAttributeString ("lastName", _lastName);
1435 writer.WriteAttributeString ("address", _address);
1436 writer.WriteEndElement ();
1437 }
1438
1439 public void ReadXml (XmlReader reader)
1440 {
1441 XmlNodeType type = reader.MoveToContent ();
1442 if (type == XmlNodeType.Element && reader.LocalName == "employee") {
1443 _firstName = reader["firstName"];
1444 _lastName = reader["lastName"];
1445 _address = reader["address"];
1446 }
1447 }
1448 }
1449
1450 public class NestedStruct
1451 {
1452 public TimeSpan Period = TimeSpan.MaxValue;
1453 }
1454
1455 public class ObjectEnumerable : IEnumerable
1456 {
1457 public void Add (int value)
1458 {
1459 }
1460
1461 public void Add (object value)
1462 {
1463 }
1464
1465 public IEnumerator GetEnumerator ()
1466 {
1467 return new ArrayList ().GetEnumerator ();
1468 }
1469 }
1470
1471 public class SimpleClassEnumerable : IEnumerable
1472 {
1473 public void Add (int value)
1474 {
1475 }
1476
1477 public void Add (object value)
1478 {
1479 }
1480
1481 IEnumerator IEnumerable.GetEnumerator ()
1482 {
1483 return GetEnumerator ();
1484 }
1485
1486 public SimpleClassEnumerator GetEnumerator ()
1487 {
1488 return new SimpleClassEnumerator (new ArrayList ());
1489 }
1490 }
1491
1492 public class SimpleClassEnumerablePrivateGetEnumerator : IEnumerable
1493 {
1494 public void Add (object value)
1495 {
1496 }
1497
1498 IEnumerator IEnumerable.GetEnumerator ()
1499 {
1500 return new ArrayList ().GetEnumerator ();
1501 }
1502 }
1503
1504 public class SimpleClassEnumerablePrivateCurrent : IEnumerable
1505 {
1506 public void Add (object value)
1507 {
1508 }
1509
1510 IEnumerator IEnumerable.GetEnumerator ()
1511 {
1512 return GetEnumerator ();
1513 }
1514
1515 public NoCurrentEnumerator GetEnumerator ()
1516 {
1517 return new NoCurrentEnumerator (new ArrayList ());
1518 }
1519 }
1520
1521 // GetEnumerator().Current returns object, but there's no corresponding
1522 // Add (System.Object) method
1523 public class ObjectEnumerableNoMatchingAddMethod : IEnumerable
1524 {
1525 public void Add (int value)
1526 {
1527 }
1528
1529 public IEnumerator GetEnumerator ()
1530 {
1531 return new ArrayList ().GetEnumerator ();
1532 }
1533 }
1534
1535 // GetEnumerator().Current returns SimpleClass, but there's no
1536 // corresponding Add (SimpleClass) method
1537 public class SimpleClassCollectionNoMatchingAddMethod : ICollection
1538 {
1539 public SimpleClass this[int index]
1540 {
1541 get
1542 {
1543 return (SimpleClass) _list[index];
1544 }
1545 }
1546
1547 public int Count
1548 {
1549 get { return _list.Count; }
1550 }
1551
1552 public bool IsSynchronized
1553 {
1554 get { return _list.IsSynchronized; }
1555 }
1556
1557 public object SyncRoot
1558 {
1559 get { return _list.SyncRoot; }
1560 }
1561
1562 public void CopyTo (Array array, int index)
1563 {
1564 _list.CopyTo (array, index);
1565 }
1566
1567 IEnumerator IEnumerable.GetEnumerator ()
1568 {
1569 return GetEnumerator ();
1570 }
1571
1572 public SimpleClassEnumerator GetEnumerator ()
1573 {
1574 return new SimpleClassEnumerator (_list);
1575 }
1576
1577 private ArrayList _list = new ArrayList ();
1578 }
1579
1580 // GetEnumerator().Current returns object, but there's no corresponding
1581 // Add (System.Object) method
1582 public class ObjectCollectionNoMatchingAddMethod : ICollection
1583 {
1584 public object this[int index]
1585 {
1586 get
1587 {
1588 return _list[index];
1589 }
1590 }
1591
1592 public int Count
1593 {
1594 get { return _list.Count; }
1595 }
1596
1597 public bool IsSynchronized
1598 {
1599 get { return _list.IsSynchronized; }
1600 }
1601
1602 public object SyncRoot
1603 {
1604 get { return _list.SyncRoot; }
1605 }
1606
1607 public void CopyTo (Array array, int index)
1608 {
1609 _list.CopyTo (array, index);
1610 }
1611
1612 IEnumerator IEnumerable.GetEnumerator ()
1613 {
1614 return GetEnumerator ();
1615 }
1616
1617 public IEnumerator GetEnumerator ()
1618 {
1619 return _list.GetEnumerator ();
1620 }
1621
1622 private ArrayList _list = new ArrayList ();
1623 }
1624
1625 // Does not have int indexer.
1626 public class SimpleClassCollectionNoIntIndexer : ICollection
1627 {
1628 public SimpleClass this[string name]
1629 {
1630 get
1631 {
1632 return new SimpleClass ();
1633 }
1634 }
1635
1636 public int Count
1637 {
1638 get { return _list.Count; }
1639 }
1640
1641 public bool IsSynchronized
1642 {
1643 get { return _list.IsSynchronized; }
1644 }
1645
1646 public object SyncRoot
1647 {
1648 get { return _list.SyncRoot; }
1649 }
1650
1651 public void CopyTo (Array array, int index)
1652 {
1653 _list.CopyTo (array, index);
1654 }
1655
1656 IEnumerator IEnumerable.GetEnumerator ()
1657 {
1658 return GetEnumerator ();
1659 }
1660
1661 public SimpleClassEnumerator GetEnumerator ()
1662 {
1663 return new SimpleClassEnumerator (_list);
1664 }
1665
1666 public void Add (SimpleClass value)
1667 {
1668 _list.Add (value);
1669 }
1670
1671 private ArrayList _list = new ArrayList ();
1672 }
1673
1674 // Does not have int indexer.
1675 public class ObjectCollectionNoIntIndexer : ICollection
1676 {
1677 public object this[string name]
1678 {
1679 get
1680 {
1681 return new SimpleClass ();
1682 }
1683 }
1684
1685 public int Count
1686 {
1687 get { return _list.Count; }
1688 }
1689
1690 public bool IsSynchronized
1691 {
1692 get { return _list.IsSynchronized; }
1693 }
1694
1695 public object SyncRoot
1696 {
1697 get { return _list.SyncRoot; }
1698 }
1699
1700 public void CopyTo (Array array, int index)
1701 {
1702 _list.CopyTo (array, index);
1703 }
1704
1705 public IEnumerator GetEnumerator ()
1706 {
1707 return _list.GetEnumerator ();
1708 }
1709
1710 public void Add (object value)
1711 {
1712 _list.Add (value);
1713 }
1714
1715 private ArrayList _list = new ArrayList ();
1716 }
1717
1718 public class SimpleClassCollection : ICollection
1719 {
1720 public SimpleClass this[int index]
1721 {
1722 get
1723 {
1724 return (SimpleClass) _list[index];
1725 }
1726 }
1727
1728 public int Count
1729 {
1730 get { return _list.Count; }
1731 }
1732
1733 public bool IsSynchronized
1734 {
1735 get { return _list.IsSynchronized; }
1736 }
1737
1738 public object SyncRoot
1739 {
1740 get { return _list.SyncRoot; }
1741 }
1742
1743 public void CopyTo (Array array, int index)
1744 {
1745 _list.CopyTo (array, index);
1746 }
1747
1748 IEnumerator IEnumerable.GetEnumerator ()
1749 {
1750 return GetEnumerator ();
1751 }
1752
1753 public SimpleClassEnumerator GetEnumerator ()
1754 {
1755 return new SimpleClassEnumerator (_list);
1756 }
1757
1758 public void Add (SimpleClass value)
1759 {
1760 _list.Add (value);
1761 }
1762
1763 private ArrayList _list = new ArrayList ();
1764 }
1765
1766 public class ObjectCollection : ICollection
1767 {
1768 public object this[int name]
1769 {
1770 get
1771 {
1772 return new SimpleClass ();
1773 }
1774 }
1775
1776 public int Count
1777 {
1778 get { return _list.Count; }
1779 }
1780
1781 public bool IsSynchronized
1782 {
1783 get { return _list.IsSynchronized; }
1784 }
1785
1786 public object SyncRoot
1787 {
1788 get { return _list.SyncRoot; }
1789 }
1790
1791 public void CopyTo (Array array, int index)
1792 {
1793 _list.CopyTo (array, index);
1794 }
1795
1796 public IEnumerator GetEnumerator ()
1797 {
1798 return _list.GetEnumerator ();
1799 }
1800
1801 public void Add (object value)
1802 {
1803 _list.Add (value);
1804 }
1805
1806 private ArrayList _list = new ArrayList ();
1807 }
1808
1809 public class SimpleClassEnumerator : IEnumerator
1810 {
1811 internal SimpleClassEnumerator (ArrayList arguments)
1812 {
1813 IEnumerable temp = (IEnumerable) (arguments);
1814 _baseEnumerator = temp.GetEnumerator ();
1815 }
1816 public SimpleClass Current
1817 {
1818 get { return (SimpleClass) _baseEnumerator.Current; }
1819 }
1820
1821 object IEnumerator.Current
1822 {
1823 get { return _baseEnumerator.Current; }
1824 }
1825
1826 public bool MoveNext ()
1827 {
1828 return _baseEnumerator.MoveNext ();
1829 }
1830
1831 bool IEnumerator.MoveNext ()
1832 {
1833 return _baseEnumerator.MoveNext ();
1834 }
1835
1836 public void Reset ()
1837 {
1838 _baseEnumerator.Reset ();
1839 }
1840
1841 void IEnumerator.Reset ()
1842 {
1843 _baseEnumerator.Reset ();
1844 }
1845
1846 private IEnumerator _baseEnumerator;
1847 }
1848
1849 public class NoCurrentEnumerator : IEnumerator
1850 {
1851 internal NoCurrentEnumerator (ArrayList arguments)
1852 {
1853 IEnumerable temp = (IEnumerable) (arguments);
1854 _baseEnumerator = temp.GetEnumerator ();
1855 }
1856
1857 object IEnumerator.Current
1858 {
1859 get { return _baseEnumerator.Current; }
1860 }
1861
1862 public bool MoveNext ()
1863 {
1864 return _baseEnumerator.MoveNext ();
1865 }
1866
1867 bool IEnumerator.MoveNext ()
1868 {
1869 return _baseEnumerator.MoveNext ();
1870 }
1871
1872 public void Reset ()
1873 {
1874 _baseEnumerator.Reset ();
1875 }
1876
1877 void IEnumerator.Reset ()
1878 {
1879 _baseEnumerator.Reset ();
1880 }
1881
1882 private IEnumerator _baseEnumerator;
1883 }
1884
1885 public class XmlArrayOnByteArrayType
1886 {
1887 [XmlArray]
1888 [XmlArrayItem ("Byte", IsNullable =false)]
1889 public byte [] Args;
1890 }
1891
1892 public class NullableContainer
1893 {
1894 [XmlElement (IsNullable = true)]
1895 public int? NilInt;
1896 }
1897
1898 public class NullableContainer2
1899 {
1900 int? value;
1901
1902 public int? NullableInt {
1903 get { return value; }
1904 set { this.value = value; }
1905 }
1906 }
1907
1908 [XmlSchemaProvider ("GetXsdType")]
1909 public class XmlSchemaProviderMissingMethodType : IXmlSerializable
1910 {
1911 public void ReadXml (XmlReader reader)
1912 {
1913 }
1914
1915 public void WriteXml (XmlWriter writer)
1916 {
1917 }
1918
1919 public XmlSchema GetSchema ()
1920 {
1921 return null;
1922 }
1923 }
1924
1925 [XmlSchemaProvider ("GetXsdType")]
1926 public class XmlSchemaProviderNonStaticType : IXmlSerializable
1927 {
1928 public void ReadXml (XmlReader reader)
1929 {
1930 }
1931
1932 public void WriteXml (XmlWriter writer)
1933 {
1934 }
1935
1936 public XmlSchema GetSchema ()
1937 {
1938 return null;
1939 }
1940
1941 public object GetXsdType ()
1942 {
1943 return null;
1944 }
1945 }
1946
1947 [XmlSchemaProvider ("GetXsdType")]
1948 public class XmlSchemaProviderIncorrectReturnType : IXmlSerializable
1949 {
1950 public void ReadXml (XmlReader reader)
1951 {
1952 }
1953
1954 public void WriteXml (XmlWriter writer)
1955 {
1956 }
1957
1958 public XmlSchema GetSchema ()
1959 {
1960 return null;
1961 }
1962
1963 public static object GetXsdType ()
1964 {
1965 return null;
1966 }
1967 }
1968
1969 [XmlSchemaProvider ("GetXsd")]
1970 public class XmlSchemaProviderAndDefaultNamespaceType : IXmlSerializable
1971 {
1972 public static XmlQualifiedName GetXsd (XmlSchemaSet xss)
1973 {
1974 XmlSchema xs = new XmlSchema ();
1975 xs.TargetNamespace = "urn:foo";
1976 XmlSchemaComplexType ct = new XmlSchemaComplexType ();
1977 ct.Name = "foo";
1978 xs.Items.Add (ct);
1979 xss.Add (xs);
1980 return new XmlQualifiedName ("foo", "urn:foo");
1981 }
1982
1983 public void WriteXml (XmlWriter write)
1984 {
1985 }
1986
1987 public void ReadXml (XmlReader reader)
1988 {
1989 }
1990
1991 public XmlSchema GetSchema ()
1992 {
1993 return null;
1994 }
1995 }
1996
1997 public class MyCollection : ICollection<string>
1998 {
1999 public int Count { get { return 0; } }
2000
2001 public bool IsReadOnly { get { return false; } }
2002
2003 public void Add (string s)
2004 {
2005 }
2006
2007 public void Clear ()
2008 {
2009 }
2010
2011 public bool Contains (string item)
2012 {
2013 return false;
2014 }
2015
2016 public void CopyTo (string [] array, int arrayIndex)
2017 {
2018 }
2019
2020 public IEnumerator<string> GetEnumerator ()
2021 {
2022 throw new Exception ();
2023 }
2024
2025 IEnumerator IEnumerable.GetEnumerator ()
2026 {
2027 return GetEnumerator ();
2028 }
2029
2030 public bool Remove (string item)
2031 {
2032 return false;
2033 }
2034 }
2035
2036 public class Bug594490Class
2037 {
2038 [XmlAttribute ("xml:lang")]
2039 public string GroupName;
2040 }
2041
2042 [Test]
2043 public void Bug594490_SerializationOfXmlLangAttribute ()
2044 {
2045 var serializer = new XmlSerializer (typeof(Bug594490Class));
2046
2047 using (var writer = new StringWriter ()) {
2048 var obj = new Bug594490Class ();
2049
2050 obj.GroupName = "hello world";
2051
2052 serializer.Serialize (writer, obj);
2053 writer.Close ();
2054
2055 Assert.AreEqual (@"<?xml version=""1.0"" encoding=""utf-16""?>
2056 <Bug594490Class xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xml:lang=""hello world"" />",
2057 writer.ToString (),
2058 "Novell bug #594490 (https://bugzilla.novell.com/show_bug.cgi?id=594490) not fixed.");
2059 }
2060 }
2061
2062 /*
2063 * The following code was generated from Microsoft's xsd.exe with the /classes switch.
2064 * It only includes the relevent details but was based on the following namespaces:
2065 * urn:oasis:names:tc:SAML:2.0:protocol
2066 * urn:oasis:names:tc:SAML:2.0:assertion
2067 * http://www.w3.org/2000/09/xmldsig#
2068 * http://www.w3.org/2001/04/xmlenc
2069 */
2070
2071 [XmlTypeAttribute (Namespace = "urn:oasis:names:tc:SAML:2.0:protocol")]
2072 [XmlRootAttribute ("RequestedAuthnContext", Namespace = "urn:oasis:names:tc:SAML:2.0:protocol", IsNullable = false)]
2073 public class RequestedAuthnContext
2074 {
2075 string[] items;
2076 ItemsChoice7[] itemsElementName;
2077
2078 [XmlElementAttribute ("AuthnContextClassRef", typeof (string), Namespace = "urn:oasis:names:tc:SAML:2.0:assertion", DataType = "anyURI")]
2079 [XmlElementAttribute ("AuthnContextDeclRef", typeof (string), Namespace = "urn:oasis:names:tc:SAML:2.0:assertion", DataType = "anyURI")]
2080 [XmlChoiceIdentifierAttribute ("ItemsElementName")]
2081 public string[] Items {
2082 get { return this.items; }
2083 set { this.items = value; }
2084 }
2085
2086 [XmlElementAttribute ("ItemsElementName")]
2087 [XmlIgnoreAttribute ()]
2088 public ItemsChoice7[] ItemsElementName {
2089 get { return this.itemsElementName; }
2090 set { this.itemsElementName = value; }
2091 }
2092 }
2093
2094 [XmlTypeAttribute (Namespace = "urn:oasis:names:tc:SAML:2.0:protocol", IncludeInSchema = false)]
2095 public enum ItemsChoice7 {
2096 [XmlEnumAttribute ("urn:oasis:names:tc:SAML:2.0:assertion:AuthnContextClassRef")]
2097 AuthnContextClassRef,
2098 [XmlEnumAttribute ("urn:oasis:names:tc:SAML:2.0:assertion:AuthnContextDeclRef")]
2099 AuthnContextDeclRef,
2100 }
2101 // End snippet from xsd.exe
2102
2103 [Test]
2104 public void FullyQualifiedName_XmlEnumAttribute ()
2105 {
2106 var serializer = new XmlSerializer (typeof (RequestedAuthnContext));
2107 }
2108 }
2109 }
2110
Mirror of the official Mono project git repository