2 // Microsoft.CSharp.* Test Cases
5 // Erik LeBel (eriklebel@yahoo.ca)
11 using System.CodeDom.Compiler;
12 using System.Globalization;
16 using NUnit.Framework;
18 namespace MonoTests.Microsoft.CSharp
21 /// Test ICodeGenerator's GenerateCodeFromNamespace, along with a
22 /// minimal set CodeDom components.
25 public class CodeGeneratorFromNamespaceTest : CodeGeneratorTestBase
27 CodeNamespace codeNamespace;
33 codeNamespace = new CodeNamespace ();
36 protected override string Generate (CodeGeneratorOptions options)
38 StringWriter writer = new StringWriter ();
39 writer.NewLine = NewLine;
41 generator.GenerateCodeFromNamespace (codeNamespace, writer, options);
43 return writer.ToString ();
47 [ExpectedException (typeof (NullReferenceException))]
48 public void NullNamespaceTest ()
55 public void NullNamespaceNameTest ()
57 codeNamespace.Name = null;
58 Assert.AreEqual ("\n", Generate ());
63 public void DefaultNamespaceTest ()
65 Assert.AreEqual ("\n", Generate ());
69 public void SimpleNamespaceTest ()
73 codeNamespace.Name = "A";
75 Assert.AreEqual ("namespace A {\n \n}\n", code, "#1");
77 CodeGeneratorOptions options = new CodeGeneratorOptions ();
78 options.BracingStyle = "C";
79 code = Generate (options);
80 Assert.AreEqual ("namespace A\n{\n \n}\n", code, "#2");
84 public void InvalidNamespaceTest ()
86 codeNamespace.Name = "A,B";
87 Assert.AreEqual ("namespace A,B {\n \n}\n", Generate ());
91 public void CommentOnlyNamespaceTest ()
93 CodeCommentStatement comment = new CodeCommentStatement ("a");
94 codeNamespace.Comments.Add (comment);
95 Assert.AreEqual ("// a\n\n", Generate ());
99 public void ImportsTest ()
101 codeNamespace.Imports.Add (new CodeNamespaceImport ("System"));
102 codeNamespace.Imports.Add (new CodeNamespaceImport ("System.Collections"));
104 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
106 "using System.Collections;{0}" +
107 "{0}", NewLine), Generate (), "#1");
109 codeNamespace.Name = "A";
111 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
112 "namespace A {{{0}" +
113 " using System;{0}" +
114 " using System.Collections;{0}" +
116 "}}{0}", NewLine), Generate (), "#2");
118 codeNamespace.Name = null;
119 codeNamespace.Comments.Add (new CodeCommentStatement ("a"));
121 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
124 "using System.Collections;{0}" +
125 "{0}", NewLine), Generate (), "#3");
127 codeNamespace.Name = "A";
129 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
131 "namespace A {{{0}" +
132 " using System;{0}" +
133 " using System.Collections;{0}" +
135 "}}{0}", NewLine), Generate (), "#4");
139 public void TypeTest ()
141 codeNamespace.Types.Add (new CodeTypeDeclaration ("Person"));
142 Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
145 "public class Person {{{0}" +
146 "}}{0}", NewLine), Generate (), "#A1");
148 CodeGeneratorOptions options = new CodeGeneratorOptions ();
149 options.BlankLinesBetweenMembers = false;
150 Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
152 "public class Person {{{0}" +
153 "}}{0}", NewLine), Generate (options), "#A2");
155 codeNamespace.Name = "A";
156 Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
157 "namespace A {{{0}" +
160 " public class Person {{{0}" +
162 "}}{0}", NewLine), Generate (), "#B1");
164 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
165 "namespace A {{{0}" +
167 " public class Person {{{0}" +
169 "}}{0}", NewLine), Generate (options), "#B2");
173 public void Type_TypeParameters ()
175 codeNamespace.Name = "SomeNS";
177 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
178 codeNamespace.Types.Add (type);
179 type.TypeParameters.Add (new CodeTypeParameter ("T"));
181 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
182 "namespace SomeNS {{{0}" +
185 " public class SomeClass<T>{0}" +
188 "}}{0}", NewLine), Generate (), "#1");
190 type.TypeParameters.Add (new CodeTypeParameter ("as"));
191 type.TypeParameters.Add (new CodeTypeParameter ("is"));
193 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
194 "namespace SomeNS {{{0}" +
197 " public class SomeClass<T, as, is>{0}" +
202 "}}{0}", NewLine), Generate (), "#2");
204 CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
205 typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
206 type.TypeParameters.Add (typeParamR);
208 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
209 "namespace SomeNS {{{0}" +
212 " public class SomeClass<T, as, is, R>{0}" +
216 " where R : System.IComparable {{{0}" +
218 "}}{0}", NewLine), Generate (), "#3");
220 type.TypeParameters.Add (new CodeTypeParameter ("S"));
222 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
223 "namespace SomeNS {{{0}" +
226 " public class SomeClass<T, as, is, R, S>{0}" +
230 " where R : System.IComparable{0}" +
233 "}}{0}", NewLine), Generate (), "#4");
238 public void Type_TypeParameters_Constraints ()
240 codeNamespace.Name = "SomeNS";
242 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
243 codeNamespace.Types.Add (type);
245 CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
246 typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
247 type.TypeParameters.Add (typeParamT);
249 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
250 "namespace SomeNS {{{0}" +
253 " public class SomeClass<T>{0}" +
254 " where T : System.IComparable {{{0}" +
256 "}}{0}", NewLine), Generate (), "#1");
258 typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
260 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
261 "namespace SomeNS {{{0}" +
264 " public class SomeClass<T>{0}" +
265 " where T : System.IComparable, System.ICloneable {{{0}" +
267 "}}{0}", NewLine), Generate (), "#2");
269 typeParamT.HasConstructorConstraint = true;
271 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
272 "namespace SomeNS {{{0}" +
275 " public class SomeClass<T>{0}" +
276 " where T : System.IComparable, System.ICloneable, new () {{{0}" +
278 "}}{0}", NewLine), Generate (), "#3");
280 CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
281 typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
282 type.TypeParameters.Add (typeParamS);
284 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
285 "namespace SomeNS {{{0}" +
288 " public class SomeClass<T, S>{0}" +
289 " where T : System.IComparable, System.ICloneable, new (){0}" +
290 " where S : System.IDisposable {{{0}" +
292 "}}{0}", NewLine), Generate (), "#4");
294 CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
295 typeParamR.HasConstructorConstraint = true;
296 type.TypeParameters.Add (typeParamR);
298 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
299 "namespace SomeNS {{{0}" +
302 " public class SomeClass<T, S, R>{0}" +
303 " where T : System.IComparable, System.ICloneable, new (){0}" +
304 " where S : System.IDisposable{0}" +
305 " where R : new() {{{0}" +
307 "}}{0}", NewLine), Generate (), "#5");
311 public void Type_TypeParameters_ConstructorConstraint ()
313 codeNamespace.Name = "SomeNS";
315 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
316 codeNamespace.Types.Add (type);
318 CodeTypeParameter typeParam = new CodeTypeParameter ("T");
319 typeParam.HasConstructorConstraint = true;
320 type.TypeParameters.Add (typeParam);
322 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
323 "namespace SomeNS {{{0}" +
326 " public class SomeClass<T>{0}" +
327 " where T : new() {{{0}" +
329 "}}{0}", NewLine), Generate ());
333 public void Method_TypeParameters ()
335 codeNamespace.Name = "SomeNS";
337 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
338 codeNamespace.Types.Add (type);
340 CodeMemberMethod method = new CodeMemberMethod ();
341 method.Name = "SomeMethod";
342 type.Members.Add (method);
344 method.TypeParameters.Add (new CodeTypeParameter ("T"));
346 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
347 "namespace SomeNS {{{0}" +
350 " public class SomeClass {{{0}" +
352 " private void SomeMethod<T>(){0}" +
356 "}}{0}", NewLine), Generate (), "#1");
358 method.TypeParameters.Add (new CodeTypeParameter ("as"));
359 method.TypeParameters.Add (new CodeTypeParameter ("is"));
361 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
362 "namespace SomeNS {{{0}" +
365 " public class SomeClass {{{0}" +
367 " private void SomeMethod<T, as, is>(){0}" +
373 "}}{0}", NewLine), Generate (), "#2");
375 CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
376 typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
377 method.TypeParameters.Add (typeParamR);
379 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
380 "namespace SomeNS {{{0}" +
383 " public class SomeClass {{{0}" +
385 " private void SomeMethod<T, as, is, R>(){0}" +
389 " where R : System.IComparable {{{0}" +
392 "}}{0}", NewLine), Generate (), "#3");
394 method.TypeParameters.Add (new CodeTypeParameter ("S"));
396 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
397 "namespace SomeNS {{{0}" +
400 " public class SomeClass {{{0}" +
402 " private void SomeMethod<T, as, is, R, S>(){0}" +
406 " where R : System.IComparable{0}" +
410 "}}{0}", NewLine), Generate (), "#4");
414 public void Method_TypeParameters_Constraints ()
416 codeNamespace.Name = "SomeNS";
418 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
419 codeNamespace.Types.Add (type);
421 CodeMemberMethod method = new CodeMemberMethod ();
422 method.Name = "SomeMethod";
423 type.Members.Add (method);
425 CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
426 typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
427 method.TypeParameters.Add (typeParamT);
429 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
430 "namespace SomeNS {{{0}" +
433 " public class SomeClass {{{0}" +
435 " private void SomeMethod<T>(){0}" +
436 " where T : System.IComparable {{{0}" +
439 "}}{0}", NewLine), Generate (), "#1");
441 typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
443 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
444 "namespace SomeNS {{{0}" +
447 " public class SomeClass {{{0}" +
449 " private void SomeMethod<T>(){0}" +
450 " where T : System.IComparable, System.ICloneable {{{0}" +
453 "}}{0}", NewLine), Generate (), "#2");
455 typeParamT.HasConstructorConstraint = true;
457 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
458 "namespace SomeNS {{{0}" +
461 " public class SomeClass {{{0}" +
463 " private void SomeMethod<T>(){0}" +
464 " where T : System.IComparable, System.ICloneable, new () {{{0}" +
467 "}}{0}", NewLine), Generate (), "#3");
469 CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
470 typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
471 method.TypeParameters.Add (typeParamS);
473 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
474 "namespace SomeNS {{{0}" +
477 " public class SomeClass {{{0}" +
479 " private void SomeMethod<T, S>(){0}" +
480 " where T : System.IComparable, System.ICloneable, new (){0}" +
481 " where S : System.IDisposable {{{0}" +
484 "}}{0}", NewLine), Generate (), "#4");
486 CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
487 typeParamR.HasConstructorConstraint = true;
488 method.TypeParameters.Add (typeParamR);
490 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
491 "namespace SomeNS {{{0}" +
494 " public class SomeClass {{{0}" +
496 " private void SomeMethod<T, S, R>(){0}" +
497 " where T : System.IComparable, System.ICloneable, new (){0}" +
498 " where S : System.IDisposable{0}" +
499 " where R : new() {{{0}" +
502 "}}{0}", NewLine), Generate (), "#5");
505 [Test] // bug #353921
506 public void Method_TypeParameters_ConstructorConstraint ()
508 codeNamespace.Name = "SomeNS";
510 CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
511 codeNamespace.Types.Add (type);
513 CodeMemberMethod method = new CodeMemberMethod ();
514 method.Name = "SomeMethod";
515 type.Members.Add (method);
517 CodeTypeParameter typeParam = new CodeTypeParameter ("T");
518 typeParam.HasConstructorConstraint = true;
519 method.TypeParameters.Add (typeParam);
521 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
522 "namespace SomeNS {{{0}" +
525 " public class SomeClass {{{0}" +
527 " private void SomeMethod<T>(){0}" +
528 " where T : new() {{{0}" +
531 "}}{0}", NewLine), Generate ());