/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. // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
  3. using System;
  4. using ICSharpCode.NRefactory.VB.Ast;
  5. using NUnit.Framework;
  6. namespace ICSharpCode.NRefactory.VB.Tests.Ast
  7. {
  8. [TestFixture]
  9. public class TypeDeclarationTests
  10. {
  11. // #region VB.NET
  12. // [Test]
  13. // public void VBNetSimpleClassTypeDeclarationTest()
  14. // {
  15. // string program = "Class TestClass\n" +
  16. // "End Class\n";
  17. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  18. //
  19. // Assert.AreEqual("TestClass", td.Name);
  20. // Assert.AreEqual(ClassType.Class, td.Type);
  21. // Assert.AreEqual(1, td.StartLocation.Line, "start line");
  22. // Assert.AreEqual(1, td.BodyStartLocation.Line, "bodystart line");
  23. // Assert.AreEqual(16, td.BodyStartLocation.Column, "bodystart col");
  24. // Assert.AreEqual(2, td.EndLocation.Line, "end line");
  25. // Assert.AreEqual(10, td.EndLocation.Column, "end col");
  26. // }
  27. //
  28. // [Test]
  29. // public void VBNetMissingBaseClassTest()
  30. // {
  31. // // SD2-1499: test that this invalid code doesn't crash
  32. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>("public class test inherits", true);
  33. // Assert.AreEqual(0, td.BaseTypes.Count);
  34. // }
  35. //
  36. // [Test]
  37. // public void VBNetEnumWithBaseClassDeclarationTest()
  38. // {
  39. // string program = "Enum TestEnum As Byte\n" +
  40. // "End Enum\n";
  41. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  42. //
  43. // Assert.AreEqual("TestEnum", td.Name);
  44. // Assert.AreEqual(ClassType.Enum, td.Type);
  45. // Assert.AreEqual("System.Byte", td.BaseTypes[0].Type);
  46. // Assert.AreEqual(0, td.Children.Count);
  47. // }
  48. //
  49. // [Test]
  50. // public void VBNetEnumOnSingleLine()
  51. // {
  52. // string program = "Enum TestEnum : A : B = 1 : C : End Enum";
  53. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  54. //
  55. // Assert.AreEqual("TestEnum", td.Name);
  56. // Assert.AreEqual(ClassType.Enum, td.Type);
  57. // Assert.AreEqual(3, td.Children.Count);
  58. // }
  59. //
  60. // [Test]
  61. // public void VBNetEnumOnSingleLine2()
  62. // {
  63. // string program = "Enum TestEnum : A : : B = 1 :: C : End Enum";
  64. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  65. //
  66. // Assert.AreEqual("TestEnum", td.Name);
  67. // Assert.AreEqual(ClassType.Enum, td.Type);
  68. // Assert.AreEqual(3, td.Children.Count);
  69. // }
  70. //
  71. //
  72. // [Test]
  73. // public void VBNetEnumWithSystemBaseClassDeclarationTest()
  74. // {
  75. // string program = "Enum TestEnum As System.UInt16\n" +
  76. // "End Enum\n";
  77. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  78. //
  79. // Assert.AreEqual("TestEnum", td.Name);
  80. // Assert.AreEqual(ClassType.Enum, td.Type);
  81. // Assert.AreEqual("System.UInt16", td.BaseTypes[0].Type);
  82. // Assert.AreEqual(0, td.Children.Count);
  83. // }
  84. //
  85. // [Test]
  86. // public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
  87. // {
  88. // string program = "Class TestClass\n" +
  89. // "End Class";
  90. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  91. //
  92. // Assert.AreEqual("TestClass", td.Name);
  93. // Assert.AreEqual(ClassType.Class, td.Type);
  94. // Assert.AreEqual(1, td.StartLocation.Line, "start line");
  95. // Assert.AreEqual(2, td.EndLocation.Line, "end line");
  96. // }
  97. //
  98. // [Test]
  99. // public void VBNetSimpleClassTypeDeclarationWithColon()
  100. // {
  101. // string program = "Class TestClass\n" +
  102. // " : \n" +
  103. // "End Class";
  104. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  105. //
  106. // Assert.AreEqual("TestClass", td.Name);
  107. // Assert.AreEqual(ClassType.Class, td.Type);
  108. // }
  109. //
  110. // [Test]
  111. // public void VBNetSimplePartialClassTypeDeclarationTest()
  112. // {
  113. // string program = "Partial Class TestClass\n" +
  114. // "End Class\n";
  115. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  116. //
  117. // Assert.AreEqual("TestClass", td.Name);
  118. // Assert.AreEqual(ClassType.Class, td.Type);
  119. // Assert.AreEqual(Modifiers.Partial, td.Modifier);
  120. // }
  121. //
  122. // [Test]
  123. // public void VBNetPartialPublicClass()
  124. // {
  125. // string program = "Partial Public Class TestClass\nEnd Class\n";
  126. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
  127. //
  128. // Assert.AreEqual("TestClass", td.Name);
  129. // Assert.AreEqual(ClassType.Class, td.Type);
  130. // Assert.AreEqual(Modifiers.Partial | Modifiers.Public, td.Modifier);
  131. // }
  132. //
  133. // [Test]
  134. // public void VBNetGenericClassTypeDeclarationTest()
  135. // {
  136. // string declr = @"
  137. //Public Class Test(Of T)
  138. //
  139. //End Class
  140. //";
  141. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
  142. //
  143. // Assert.AreEqual(ClassType.Class, td.Type);
  144. // Assert.AreEqual("Test", td.Name);
  145. // Assert.AreEqual(Modifiers.Public, td.Modifier);
  146. // Assert.AreEqual(0, td.BaseTypes.Count);
  147. // Assert.AreEqual(1, td.Templates.Count);
  148. // Assert.AreEqual("T", td.Templates[0].Name);
  149. // }
  150. //
  151. // [Test]
  152. // public void VBNetGenericClassWithConstraint()
  153. // {
  154. // string declr = @"
  155. //Public Class Test(Of T As IMyInterface)
  156. //
  157. //End Class
  158. //";
  159. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
  160. //
  161. // Assert.AreEqual(ClassType.Class, td.Type);
  162. // Assert.AreEqual("Test", td.Name);
  163. //
  164. // Assert.AreEqual(1, td.Templates.Count);
  165. // Assert.AreEqual("T", td.Templates[0].Name);
  166. // Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
  167. // }
  168. //
  169. // [Test]
  170. // public void VBNetComplexGenericClassTypeDeclarationTest()
  171. // {
  172. // string declr = @"
  173. //Public Class Generic(Of T As MyNamespace.IMyInterface, S As {G(Of T()), IAnotherInterface})
  174. // Implements System.IComparable
  175. //
  176. //End Class
  177. //";
  178. // TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
  179. //
  180. // Assert.AreEqual(ClassType.Class, td.Type);
  181. // Assert.AreEqual("Generic", td.Name);
  182. // Assert.AreEqual(Modifiers.Public, td.Modifier);
  183. // Assert.AreEqual(1, td.BaseTypes.Count);
  184. // Assert.AreEqual("System.IComparable", td.BaseTypes[0].Type);
  185. //
  186. // Assert.AreEqual(2, td.Templates.Count);
  187. // Assert.AreEqual("T", td.Templates[0].Name);
  188. // Assert.AreEqual("MyNamespace.IMyInterface", td.Templates[0].Bases[0].Type);
  189. //
  190. // Assert.AreEqual("S", td.Templates[1].Name);
  191. // Assert.AreEqual(2, td.Templates[1].Bases.Count);
  192. // Assert.AreEqual("G", td.Templates[1].Bases[0].Type);
  193. // Assert.AreEqual(1, td.Templates[1].Bases[0].GenericTypes.Count);
  194. // Assert.IsTrue(td.Templates[1].Bases[0].GenericTypes[0].IsArrayType);
  195. // Assert.AreEqual("T", td.Templates[1].Bases[0].GenericTypes[0].Type);
  196. // Assert.AreEqual(new int[] {0}, td.Templates[1].Bases[0].GenericTypes[0].RankSpecifier);
  197. // Assert.AreEqual("IAnotherInterface", td.Templates[1].Bases[1].Type);
  198. // }
  199. // #endregion
  200. }
  201. }