New test.

[mono.git] / mcs / class / System / Test / Microsoft.CSharp / CodeGeneratorFromNamespaceTest.cs

diff --git a/mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs b/mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs
index aa9511d0cebb3094ca781ca6e5b3cc67d2bce894..cba64f69e951f08506b7c367253e6e0dd5868701 100644 (file)
--- a/mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs
+++ b/mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs
@@ -7,21 +7,20 @@
 // (c) 2003 Erik LeBel
 //
 using System;
-using System.Text;
 using System.CodeDom;
 using System.CodeDom.Compiler;
+using System.Globalization;
+using System.IO;
+using System.Text;
 
 using NUnit.Framework;
 
 namespace MonoTests.Microsoft.CSharp
 {
-       
-       ///
        /// <summary>
-       ///     Test ICodeGenerator's GenerateCodeFromNamespace, along with a 
-       ///     minimal set CodeDom components.
+       /// Test ICodeGenerator's GenerateCodeFromNamespace, along with a 
+       /// minimal set CodeDom components.
        /// </summary>
-       ///
        [TestFixture]
        public class CodeGeneratorFromNamespaceTest : CodeGeneratorTestBase
        {
@@ -34,10 +33,14 @@ namespace MonoTests.Microsoft.CSharp
                        codeNamespace = new CodeNamespace ();
                }
                
-               protected override void Generate ()
+               protected override string Generate (CodeGeneratorOptions options)
                {
+                       StringWriter writer = new StringWriter ();
+                       writer.NewLine = NewLine;
+
                        generator.GenerateCodeFromNamespace (codeNamespace, writer, options);
                        writer.Close ();
+                       return writer.ToString ();
                }
                
                [Test]
@@ -52,49 +55,118 @@ namespace MonoTests.Microsoft.CSharp
                public void NullNamespaceNameTest ()
                {
                        codeNamespace.Name = null;
-                       Generate ();
-                       Assertion.AssertEquals ("\n", Code);
+                       Assert.AreEqual ("\n", Generate ());
                }
 
                
                [Test]
                public void DefaultNamespaceTest ()
                {
-                       Generate ();
-                       Assertion.AssertEquals ("\n", Code);
+                       Assert.AreEqual ("\n", Generate ());
                }
 
                [Test]
                public void SimpleNamespaceTest ()
                {
+                       string code = null;
+
                        codeNamespace.Name = "A";
-                       Generate();
-                       Assertion.AssertEquals ("namespace A {\n    \n}\n", Code);
+                       code = Generate ();
+                       Assert.AreEqual ("namespace A {\n    \n}\n", code, "#1");
+
+                       CodeGeneratorOptions options = new CodeGeneratorOptions ();
+                       options.BracingStyle = "C";
+                       code = Generate (options);
+                       Assert.AreEqual ("namespace A\n{\n    \n}\n", code, "#2");
                }
 
                [Test]
                public void InvalidNamespaceTest ()
                {
                        codeNamespace.Name = "A,B";
-                       Generate();
-                       Assertion.AssertEquals ("namespace A,B {\n    \n}\n", Code);
+                       Assert.AreEqual ("namespace A,B {\n    \n}\n", Generate ());
                }
 
-
                [Test]
                public void CommentOnlyNamespaceTest ()
                {
                        CodeCommentStatement comment = new CodeCommentStatement ("a");
                        codeNamespace.Comments.Add (comment);
-                       Generate ();
-                       Assertion.AssertEquals ("// a\n\n", Code);
+                       Assert.AreEqual ("// a\n\n", Generate ());
                }
-       }
 
-       // FIXME implement tests for these methods:
-       // GenerateCodeFromType
-       // GenerateCodeFromExpression
-       // GenerateCodeFromStatement
+               [Test]
+               public void ImportsTest ()
+               {
+                       codeNamespace.Imports.Add (new CodeNamespaceImport ("System"));
+                       codeNamespace.Imports.Add (new CodeNamespaceImport ("System.Collections"));
+
+                       Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+                               "using System;{0}" +
+                               "using System.Collections;{0}" +
+                               "{0}", NewLine), Generate (), "#1");
 
-}
+                       codeNamespace.Name = "A";
+
+                       Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+                               "namespace A {{{0}" +
+                               "    using System;{0}" +
+                               "    using System.Collections;{0}" +
+                               "    {0}" +
+                               "}}{0}", NewLine), Generate (), "#2");
 
+                       codeNamespace.Name = null;
+                       codeNamespace.Comments.Add (new CodeCommentStatement ("a"));
+
+                       Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+                               "// a{0}" +
+                               "using System;{0}" +
+                               "using System.Collections;{0}" +
+                               "{0}", NewLine), Generate (), "#3");
+
+                       codeNamespace.Name = "A";
+
+                       Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+                               "// a{0}" +
+                               "namespace A {{{0}" +
+                               "    using System;{0}" +
+                               "    using System.Collections;{0}" +
+                               "    {0}" +
+                               "}}{0}", NewLine), Generate (), "#4");
+               }
+
+               [Test]
+               public void TypeTest ()
+               {
+                       codeNamespace.Types.Add (new CodeTypeDeclaration ("Person"));
+                       Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
+                               "{0}" +
+                               "{0}" +
+                               "public class Person {{{0}" +
+                               "}}{0}", NewLine), Generate (), "#A1");
+
+                       CodeGeneratorOptions options = new CodeGeneratorOptions ();
+                       options.BlankLinesBetweenMembers = false;
+                       Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
+                               "{0}" +
+                               "public class Person {{{0}" +
+                               "}}{0}", NewLine), Generate (options), "#A2");
+
+                       codeNamespace.Name = "A";
+                       Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
+                               "namespace A {{{0}" +
+                               "    {0}" +
+                               "    {0}" +
+                               "    public class Person {{{0}" +
+                               "    }}{0}" +
+                               "}}{0}", NewLine), Generate (), "#B1");
+
+                       Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+                               "namespace A {{{0}" +
+                               "    {0}" +
+                               "    public class Person {{{0}" +
+                               "    }}{0}" +
+                               "}}{0}", NewLine), Generate (options), "#B2");
+               }
+       }
+}