/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/TypeDeclarationTests.cs

http://github.com/icsharpcode/ILSpy · C# · 203 lines · 10 code · 2 blank · 191 comment · 0 complexity · bf95bdd62effa02d7fce3bff5843c6c0 MD5 · raw file 

    

  1. // Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
    2. 

  2. // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
    3. 

  3. 

  4. using System;
    5. 

  5. using ICSharpCode.NRefactory.VB.Ast;
    6. 

  6. using NUnit.Framework;
    7. 

  7. 

  8. namespace ICSharpCode.NRefactory.VB.Tests.Ast
    9. 

  9. {
    10. 

  10. 	[TestFixture]
    11. 

  11. 	public class TypeDeclarationTests
    12. 

  12. 	{
    13. 

  13. //		#region VB.NET
    14. 

  14. //		[Test]
    15. 

  15. //		public void VBNetSimpleClassTypeDeclarationTest()
    16. 

  16. //		{
    17. 

  17. //			string program = "Class TestClass\n" +
    18. 

  18. //				"End Class\n";
    19. 

  19. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    20. 

  20. //			
    21. 

  21. //			Assert.AreEqual("TestClass", td.Name);
    22. 

  22. //			Assert.AreEqual(ClassType.Class, td.Type);
    23. 

  23. //			Assert.AreEqual(1, td.StartLocation.Line, "start line");
    24. 

  24. //			Assert.AreEqual(1, td.BodyStartLocation.Line, "bodystart line");
    25. 

  25. //			Assert.AreEqual(16, td.BodyStartLocation.Column, "bodystart col");
    26. 

  26. //			Assert.AreEqual(2, td.EndLocation.Line, "end line");
    27. 

  27. //			Assert.AreEqual(10, td.EndLocation.Column, "end col");
    28. 

  28. //		}
    29. 

  29. //		
    30. 

  30. //		[Test]
    31. 

  31. //		public void VBNetMissingBaseClassTest()
    32. 

  32. //		{
    33. 

  33. //			// SD2-1499: test that this invalid code doesn't crash
    34. 

  34. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>("public class test inherits", true);
    35. 

  35. //			Assert.AreEqual(0, td.BaseTypes.Count);
    36. 

  36. //		}
    37. 

  37. //		
    38. 

  38. //		[Test]
    39. 

  39. //		public void VBNetEnumWithBaseClassDeclarationTest()
    40. 

  40. //		{
    41. 

  41. //			string program = "Enum TestEnum As Byte\n" +
    42. 

  42. //				"End Enum\n";
    43. 

  43. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    44. 

  44. //			
    45. 

  45. //			Assert.AreEqual("TestEnum", td.Name);
    46. 

  46. //			Assert.AreEqual(ClassType.Enum, td.Type);
    47. 

  47. //			Assert.AreEqual("System.Byte", td.BaseTypes[0].Type);
    48. 

  48. //			Assert.AreEqual(0, td.Children.Count);
    49. 

  49. //		}
    50. 

  50. //		
    51. 

  51. //		[Test]
    52. 

  52. //		public void VBNetEnumOnSingleLine()
    53. 

  53. //		{
    54. 

  54. //			string program = "Enum TestEnum : A : B = 1 : C : End Enum";
    55. 

  55. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    56. 

  56. //			
    57. 

  57. //			Assert.AreEqual("TestEnum", td.Name);
    58. 

  58. //			Assert.AreEqual(ClassType.Enum, td.Type);
    59. 

  59. //			Assert.AreEqual(3, td.Children.Count);
    60. 

  60. //		}
    61. 

  61. //		
    62. 

  62. //		[Test]
    63. 

  63. //		public void VBNetEnumOnSingleLine2()
    64. 

  64. //		{
    65. 

  65. //			string program = "Enum TestEnum : A : : B = 1 :: C : End Enum";
    66. 

  66. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    67. 

  67. //			
    68. 

  68. //			Assert.AreEqual("TestEnum", td.Name);
    69. 

  69. //			Assert.AreEqual(ClassType.Enum, td.Type);
    70. 

  70. //			Assert.AreEqual(3, td.Children.Count);
    71. 

  71. //		}
    72. 

  72. //		
    73. 

  73. //		
    74. 

  74. //		[Test]
    75. 

  75. //		public void VBNetEnumWithSystemBaseClassDeclarationTest()
    76. 

  76. //		{
    77. 

  77. //			string program = "Enum TestEnum As System.UInt16\n" +
    78. 

  78. //				"End Enum\n";
    79. 

  79. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    80. 

  80. //			
    81. 

  81. //			Assert.AreEqual("TestEnum", td.Name);
    82. 

  82. //			Assert.AreEqual(ClassType.Enum, td.Type);
    83. 

  83. //			Assert.AreEqual("System.UInt16", td.BaseTypes[0].Type);
    84. 

  84. //			Assert.AreEqual(0, td.Children.Count);
    85. 

  85. //		}
    86. 

  86. //		
    87. 

  87. //		[Test]
    88. 

  88. //		public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
    89. 

  89. //		{
    90. 

  90. //			string program = "Class TestClass\n" +
    91. 

  91. //				"End Class";
    92. 

  92. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    93. 

  93. //			
    94. 

  94. //			Assert.AreEqual("TestClass", td.Name);
    95. 

  95. //			Assert.AreEqual(ClassType.Class, td.Type);
    96. 

  96. //			Assert.AreEqual(1, td.StartLocation.Line, "start line");
    97. 

  97. //			Assert.AreEqual(2, td.EndLocation.Line, "end line");
    98. 

  98. //		}
    99. 

  99. //		
    100. 

  100. //		[Test]
    101. 

  101. //		public void VBNetSimpleClassTypeDeclarationWithColon()
    102. 

  102. //		{
    103. 

  103. //			string program = "Class TestClass\n" +
    104. 

  104. //				" : \n" +
    105. 

  105. //				"End Class";
    106. 

  106. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    107. 

  107. //			
    108. 

  108. //			Assert.AreEqual("TestClass", td.Name);
    109. 

  109. //			Assert.AreEqual(ClassType.Class, td.Type);
    110. 

  110. //		}
    111. 

  111. //		
    112. 

  112. //		[Test]
    113. 

  113. //		public void VBNetSimplePartialClassTypeDeclarationTest()
    114. 

  114. //		{
    115. 

  115. //			string program = "Partial Class TestClass\n" +
    116. 

  116. //				"End Class\n";
    117. 

  117. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    118. 

  118. //			
    119. 

  119. //			Assert.AreEqual("TestClass", td.Name);
    120. 

  120. //			Assert.AreEqual(ClassType.Class, td.Type);
    121. 

  121. //			Assert.AreEqual(Modifiers.Partial, td.Modifier);
    122. 

  122. //		}
    123. 

  123. //		
    124. 

  124. //		[Test]
    125. 

  125. //		public void VBNetPartialPublicClass()
    126. 

  126. //		{
    127. 

  127. //			string program = "Partial Public Class TestClass\nEnd Class\n";
    128. 

  128. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
    129. 

  129. //			
    130. 

  130. //			Assert.AreEqual("TestClass", td.Name);
    131. 

  131. //			Assert.AreEqual(ClassType.Class, td.Type);
    132. 

  132. //			Assert.AreEqual(Modifiers.Partial | Modifiers.Public, td.Modifier);
    133. 

  133. //		}
    134. 

  134. //		
    135. 

  135. //		[Test]
    136. 

  136. //		public void VBNetGenericClassTypeDeclarationTest()
    137. 

  137. //		{
    138. 

  138. //			string declr = @"
    139. 

  139. //Public Class Test(Of T)
    140. 

  140. //
    141. 

  141. //End Class
    142. 

  142. //";
    143. 

  143. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
    144. 

  144. //			
    145. 

  145. //			Assert.AreEqual(ClassType.Class, td.Type);
    146. 

  146. //			Assert.AreEqual("Test", td.Name);
    147. 

  147. //			Assert.AreEqual(Modifiers.Public, td.Modifier);
    148. 

  148. //			Assert.AreEqual(0, td.BaseTypes.Count);
    149. 

  149. //			Assert.AreEqual(1, td.Templates.Count);
    150. 

  150. //			Assert.AreEqual("T", td.Templates[0].Name);
    151. 

  151. //		}
    152. 

  152. //		
    153. 

  153. //		[Test]
    154. 

  154. //		public void VBNetGenericClassWithConstraint()
    155. 

  155. //		{
    156. 

  156. //			string declr = @"
    157. 

  157. //Public Class Test(Of T As IMyInterface)
    158. 

  158. //
    159. 

  159. //End Class
    160. 

  160. //";
    161. 

  161. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
    162. 

  162. //			
    163. 

  163. //			Assert.AreEqual(ClassType.Class, td.Type);
    164. 

  164. //			Assert.AreEqual("Test", td.Name);
    165. 

  165. //			
    166. 

  166. //			Assert.AreEqual(1, td.Templates.Count);
    167. 

  167. //			Assert.AreEqual("T", td.Templates[0].Name);
    168. 

  168. //			Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
    169. 

  169. //		}
    170. 

  170. //		
    171. 

  171. //		[Test]
    172. 

  172. //		public void VBNetComplexGenericClassTypeDeclarationTest()
    173. 

  173. //		{
    174. 

  174. //			string declr = @"
    175. 

  175. //Public Class Generic(Of T As MyNamespace.IMyInterface, S As {G(Of T()), IAnotherInterface})
    176. 

  176. //	Implements System.IComparable
    177. 

  177. //
    178. 

  178. //End Class
    179. 

  179. //";
    180. 

  180. //			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
    181. 

  181. //			
    182. 

  182. //			Assert.AreEqual(ClassType.Class, td.Type);
    183. 

  183. //			Assert.AreEqual("Generic", td.Name);
    184. 

  184. //			Assert.AreEqual(Modifiers.Public, td.Modifier);
    185. 

  185. //			Assert.AreEqual(1, td.BaseTypes.Count);
    186. 

  186. //			Assert.AreEqual("System.IComparable", td.BaseTypes[0].Type);
    187. 

  187. //			
    188. 

  188. //			Assert.AreEqual(2, td.Templates.Count);
    189. 

  189. //			Assert.AreEqual("T", td.Templates[0].Name);
    190. 

  190. //			Assert.AreEqual("MyNamespace.IMyInterface", td.Templates[0].Bases[0].Type);
    191. 

  191. //			
    192. 

  192. //			Assert.AreEqual("S", td.Templates[1].Name);
    193. 

  193. //			Assert.AreEqual(2, td.Templates[1].Bases.Count);
    194. 

  194. //			Assert.AreEqual("G", td.Templates[1].Bases[0].Type);
    195. 

  195. //			Assert.AreEqual(1, td.Templates[1].Bases[0].GenericTypes.Count);
    196. 

  196. //			Assert.IsTrue(td.Templates[1].Bases[0].GenericTypes[0].IsArrayType);
    197. 

  197. //			Assert.AreEqual("T", td.Templates[1].Bases[0].GenericTypes[0].Type);
    198. 

  198. //			Assert.AreEqual(new int[] {0}, td.Templates[1].Bases[0].GenericTypes[0].RankSpecifier);
    199. 

  199. //			Assert.AreEqual("IAnotherInterface", td.Templates[1].Bases[1].Type);
    200. 

  200. //		}
    201. 

  201. //		#endregion
    202. 

  202. 	}
    203. 

  203. }
    204.