mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs

   1 //
   2 // Microsoft.CSharp.* Test Cases
   3 //
   4 // Authors:
   5 //      Erik LeBel (eriklebel@yahoo.ca)
   6 //
   7 // (c) 2003 Erik LeBel
   8 //
   9 using System;
  10 using System.CodeDom;
  11 using System.CodeDom.Compiler;
  12 using System.Globalization;
  13 using System.IO;
  14 using System.Text;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.Microsoft.CSharp
  19 {
  20         /// <summary>
  21         /// Test ICodeGenerator's GenerateCodeFromNamespace, along with a
  22         /// minimal set CodeDom components.
  23         /// </summary>
  24         [TestFixture]
  25         public class CodeGeneratorFromNamespaceTest : CodeGeneratorTestBase
  26         {
  27                 CodeNamespace codeNamespace = null;
  28
  29                 [SetUp]
  30                 public void Init ()
  31                 {
  32                         InitBase ();
  33                         codeNamespace = new CodeNamespace ();
  34                 }
  35
  36                 protected override string Generate (CodeGeneratorOptions options)
  37                 {
  38                         StringWriter writer = new StringWriter ();
  39                         writer.NewLine = NewLine;
  40
  41                         generator.GenerateCodeFromNamespace (codeNamespace, writer, options);
  42                         writer.Close ();
  43                         return writer.ToString ();
  44                 }
  45
  46                 [Test]
  47                 [ExpectedException (typeof (NullReferenceException))]
  48                 public void NullNamespaceTest ()
  49                 {
  50                         codeNamespace = null;
  51                         Generate ();
  52                 }
  53
  54                 [Test]
  55                 public void NullNamespaceNameTest ()
  56                 {
  57                         codeNamespace.Name = null;
  58                         Assert.AreEqual ("\n", Generate ());
  59                 }
  60
  61
  62                 [Test]
  63                 public void DefaultNamespaceTest ()
  64                 {
  65                         Assert.AreEqual ("\n", Generate ());
  66                 }
  67
  68                 [Test]
  69                 public void SimpleNamespaceTest ()
  70                 {
  71                         string code = null;
  72
  73                         codeNamespace.Name = "A";
  74                         code = Generate ();
  75                         Assert.AreEqual ("namespace A {\n    \n}\n", code, "#1");
  76
  77                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
  78                         options.BracingStyle = "C";
  79                         code = Generate (options);
  80                         Assert.AreEqual ("namespace A\n{\n    \n}\n", code, "#2");
  81                 }
  82
  83                 [Test]
  84                 public void InvalidNamespaceTest ()
  85                 {
  86                         codeNamespace.Name = "A,B";
  87                         Assert.AreEqual ("namespace A,B {\n    \n}\n", Generate ());
  88                 }
  89
  90                 [Test]
  91                 public void CommentOnlyNamespaceTest ()
  92                 {
  93                         CodeCommentStatement comment = new CodeCommentStatement ("a");
  94                         codeNamespace.Comments.Add (comment);
  95                         Assert.AreEqual ("// a\n\n", Generate ());
  96                 }
  97
  98                 [Test]
  99                 public void ImportsTest ()
 100                 {
 101                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System"));
 102                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System.Collections"));
 103
 104                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 105                                 "using System;{0}" +
 106                                 "using System.Collections;{0}" +
 107                                 "{0}", NewLine), Generate (), "#1");
 108
 109                         codeNamespace.Name = "A";
 110
 111                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 112                                 "namespace A {{{0}" +
 113                                 "    using System;{0}" +
 114                                 "    using System.Collections;{0}" +
 115                                 "    {0}" +
 116                                 "}}{0}", NewLine), Generate (), "#2");
 117
 118                         codeNamespace.Name = null;
 119                         codeNamespace.Comments.Add (new CodeCommentStatement ("a"));
 120
 121                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 122                                 "// a{0}" +
 123                                 "using System;{0}" +
 124                                 "using System.Collections;{0}" +
 125                                 "{0}", NewLine), Generate (), "#3");
 126
 127                         codeNamespace.Name = "A";
 128
 129                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 130                                 "// a{0}" +
 131                                 "namespace A {{{0}" +
 132                                 "    using System;{0}" +
 133                                 "    using System.Collections;{0}" +
 134                                 "    {0}" +
 135                                 "}}{0}", NewLine), Generate (), "#4");
 136                 }
 137
 138                 [Test]
 139                 public void TypeTest ()
 140                 {
 141                         codeNamespace.Types.Add (new CodeTypeDeclaration ("Person"));
 142                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 143                                 "{0}" +
 144                                 "{0}" +
 145                                 "public class Person {{{0}" +
 146                                 "}}{0}", NewLine), Generate (), "#A1");
 147
 148                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
 149                         options.BlankLinesBetweenMembers = false;
 150                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 151                                 "{0}" +
 152                                 "public class Person {{{0}" +
 153                                 "}}{0}", NewLine), Generate (options), "#A2");
 154
 155                         codeNamespace.Name = "A";
 156                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 157                                 "namespace A {{{0}" +
 158                                 "    {0}" +
 159                                 "    {0}" +
 160                                 "    public class Person {{{0}" +
 161                                 "    }}{0}" +
 162                                 "}}{0}", NewLine), Generate (), "#B1");
 163
 164                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 165                                 "namespace A {{{0}" +
 166                                 "    {0}" +
 167                                 "    public class Person {{{0}" +
 168                                 "    }}{0}" +
 169                                 "}}{0}", NewLine), Generate (options), "#B2");
 170                 }
 171         }
 172 }