mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromCompileUnitTest.cs

   1 //
   2 // Microsoft.VisualBasic.* Test Cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2005 Novell
   8 //
   9
  10 using System;
  11 using System.Globalization;
  12 using System.Text;
  13 using System.CodeDom;
  14 using System.CodeDom.Compiler;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.Microsoft.VisualBasic
  19 {
  20         [TestFixture]
  21         public class CodeGeneratorFromCompileUnitTest : CodeGeneratorTestBase
  22         {
  23                 string codeUnitHeader = "";
  24                 CodeCompileUnit codeUnit = null;
  25
  26                 public CodeGeneratorFromCompileUnitTest ()
  27                 {
  28                         Init();
  29                         Generate();
  30                         codeUnitHeader = Code;
  31                 }
  32
  33                 [SetUp]
  34                 public void Init ()
  35                 {
  36                         InitBase ();
  37                         codeUnit = new CodeCompileUnit ();
  38                 }
  39
  40                 protected override string Code {
  41                         get { return base.Code.Substring (codeUnitHeader.Length); }
  42                 }
  43
  44                 protected override void Generate ()
  45                 {
  46                         generator.GenerateCodeFromCompileUnit (codeUnit, writer, options);
  47                         writer.Close ();
  48                 }
  49
  50                 [Test]
  51                 public void DefaultCodeUnitTest ()
  52                 {
  53                         Generate ();
  54                         Assert.AreEqual ("", Code);
  55                 }
  56
  57                 [Test]
  58                 [ExpectedException (typeof (NullReferenceException))]
  59                 public void NullCodeUnitTest ()
  60                 {
  61                         codeUnit = null;
  62                         Generate();
  63                 }
  64
  65                 [Test]
  66                 public void ReferencedTest ()
  67                 {
  68                         codeUnit.ReferencedAssemblies.Add ("System.dll");
  69                         Generate();
  70                         Assert.AreEqual ("", Code);
  71                 }
  72
  73                 [Test]
  74                 public void SimpleNamespaceTest ()
  75                 {
  76                         CodeNamespace ns = new CodeNamespace ("A");
  77                         codeUnit.Namespaces.Add (ns);
  78                         Generate ();
  79                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  80                                 "{0}Namespace A{0}End Namespace{0}", writer.NewLine), Code);
  81                 }
  82
  83                 [Test]
  84                 public void ReferenceAndSimpleNamespaceTest()
  85                 {
  86                         CodeNamespace ns = new CodeNamespace ("A");
  87                         codeUnit.Namespaces.Add (ns);
  88                         codeUnit.ReferencedAssemblies.Add ("using System;");
  89                         Generate ();
  90                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  91                                 "{0}Namespace A{0}End Namespace{0}", writer.NewLine), Code);
  92                 }
  93
  94                 [Test]
  95                 public void SimpleAttributeTest ()
  96                 {
  97                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
  98                         attrDec.Name = "A";
  99
 100                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 101                         Generate ();
 102                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 103                                 "<Assembly: A()> {0}", writer.NewLine), Code);
 104                 }
 105
 106                 [Test]
 107                 public void AttributeWithValueTest ()
 108                 {
 109                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 110                         attrDec.Name = "A";
 111
 112                         attrDec.Arguments.Add (new CodeAttributeArgument("A1",
 113                                 new CodePrimitiveExpression(false)));
 114                         attrDec.Arguments.Add (new CodeAttributeArgument("A2",
 115                                 new CodePrimitiveExpression(true)));
 116
 117                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 118                         Generate ();
 119                         Assert.AreEqual ("<Assembly: A(A1:=false, A2:=true)> " +
 120                                 writer.NewLine, Code);
 121                 }
 122
 123                 [Test]
 124                 public void MultipleAttributeTest ()
 125                 {
 126                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 127                         attrDec.Name = "A";
 128                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 129
 130                         attrDec = new CodeAttributeDeclaration ();
 131                         attrDec.Name = "B";
 132                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 133                         Generate ();
 134                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 135                                 "<Assembly: A(),  _{0} Assembly: B()> {0}", writer.NewLine),
 136                                 Code);
 137                 }
 138
 139                 [Test]
 140                 public void AttributeAndSimpleNamespaceTest ()
 141                 {
 142                         CodeNamespace ns = new CodeNamespace ("A");
 143                         codeUnit.Namespaces.Add (ns);
 144
 145                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 146                         attrDec.Name = "A";
 147                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 148
 149                         attrDec = new CodeAttributeDeclaration ();
 150                         attrDec.Name = "B";
 151                         codeUnit.AssemblyCustomAttributes.Add (attrDec);
 152
 153                         Generate ();
 154
 155                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 156                                 "<Assembly: A(),  _{0} Assembly: B()> {0}{0}Namespace A{0}End "
 157                                 + "Namespace{0}",writer.NewLine), Code);
 158                 }
 159
 160                 [Test]
 161                 public void CodeSnippetTest ()
 162                 {
 163                         StringBuilder sb = new StringBuilder();
 164                         sb.Append ("Public Class Test1");
 165                         sb.Append (Environment.NewLine);
 166                         sb.Append ("End Class");
 167
 168                         codeUnit = new CodeSnippetCompileUnit (sb.ToString ());
 169                         generator.GenerateCodeFromCompileUnit (codeUnit, writer, options);
 170                         writer.Close ();
 171                         Assert.AreEqual (sb.ToString () + writer.NewLine,
 172                                                 writer.ToString());
 173                 }
 174         }
 175 }