/Test/Mono.Cecil.Tests/TypeTests.cs

http://github.com/jbevain/cecil · C# · 298 lines · 234 code · 63 blank · 1 comment · 3 complexity · 7180539f2ea019d25ba85fd2732e4113 MD5 · raw file

  1. using System;
  2. using System.Linq;
  3. using Mono.Cecil;
  4. using Mono.Cecil.Cil;
  5. using Mono.Cecil.Metadata;
  6. using NUnit.Framework;
  7. namespace Mono.Cecil.Tests {
  8. [TestFixture]
  9. public class TypeTests : BaseTestFixture {
  10. [Test]
  11. public void TypeLayout ()
  12. {
  13. TestCSharp ("Layouts.cs", module => {
  14. var foo = module.GetType ("Foo");
  15. Assert.IsNotNull (foo);
  16. Assert.IsTrue (foo.IsValueType);
  17. Assert.IsTrue (foo.HasLayoutInfo);
  18. Assert.AreEqual (16, foo.ClassSize);
  19. var babar = module.GetType ("Babar");
  20. Assert.IsNotNull (babar);
  21. Assert.IsFalse (babar.IsValueType);
  22. Assert.IsFalse (babar.HasLayoutInfo);
  23. });
  24. }
  25. [Test]
  26. public void EmptyStructLayout ()
  27. {
  28. TestModule ("hello.exe", module =>
  29. {
  30. var foo = new TypeDefinition ("", "Foo",
  31. TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit | TypeAttributes.SequentialLayout,
  32. module.ImportReference (typeof (ValueType))) ;
  33. module.Types.Add (foo) ;
  34. }) ;
  35. }
  36. [Test]
  37. public void SimpleInterfaces ()
  38. {
  39. TestIL ("types.il", module => {
  40. var ibaz = module.GetType ("IBaz");
  41. Assert.IsNotNull (ibaz);
  42. Assert.IsTrue (ibaz.HasInterfaces);
  43. var interfaces = ibaz.Interfaces;
  44. Assert.AreEqual (2, interfaces.Count);
  45. // Mono's ilasm and .NET's are ordering interfaces differently
  46. Assert.IsNotNull (interfaces.Single (i => i.InterfaceType.FullName == "IBar"));
  47. Assert.IsNotNull (interfaces.Single (i => i.InterfaceType.FullName == "IFoo"));
  48. });
  49. }
  50. [Test]
  51. public void GenericTypeDefinition ()
  52. {
  53. TestCSharp ("Generics.cs", module => {
  54. var foo = module.GetType ("Foo`2");
  55. Assert.IsNotNull (foo);
  56. Assert.IsTrue (foo.HasGenericParameters);
  57. Assert.AreEqual (2, foo.GenericParameters.Count);
  58. var tbar = foo.GenericParameters [0];
  59. Assert.AreEqual ("TBar", tbar.Name);
  60. Assert.AreEqual (foo, tbar.Owner);
  61. var tbaz = foo.GenericParameters [1];
  62. Assert.AreEqual ("TBaz", tbaz.Name);
  63. Assert.AreEqual (foo, tbaz.Owner);
  64. });
  65. }
  66. [Test]
  67. public void ConstrainedGenericType ()
  68. {
  69. TestCSharp ("Generics.cs", module => {
  70. var bongo_t = module.GetType ("Bongo`1");
  71. Assert.IsNotNull (bongo_t);
  72. var t = bongo_t.GenericParameters [0];
  73. Assert.IsNotNull (t);
  74. Assert.AreEqual ("T", t.Name);
  75. Assert.IsTrue (t.HasConstraints);
  76. Assert.AreEqual (2, t.Constraints.Count);
  77. Assert.AreEqual ("Zap", t.Constraints [0].ConstraintType.FullName);
  78. Assert.AreEqual ("IZoom", t.Constraints [1].ConstraintType.FullName);
  79. });
  80. }
  81. [Test]
  82. public void GenericBaseType ()
  83. {
  84. TestCSharp ("Generics.cs", module => {
  85. var child = module.GetType ("Child`1");
  86. var child_t = child.GenericParameters [0];
  87. Assert.IsNotNull (child_t);
  88. var instance = child.BaseType as GenericInstanceType;
  89. Assert.IsNotNull (instance);
  90. Assert.AreNotEqual (0, instance.MetadataToken.RID);
  91. Assert.AreEqual (child_t, instance.GenericArguments [0]);
  92. });
  93. }
  94. [Test]
  95. public void GenericConstraintOnGenericParameter ()
  96. {
  97. TestCSharp ("Generics.cs", module => {
  98. var duel = module.GetType ("Duel`3");
  99. Assert.AreEqual (3, duel.GenericParameters.Count);
  100. var t1 = duel.GenericParameters [0];
  101. var t2 = duel.GenericParameters [1];
  102. var t3 = duel.GenericParameters [2];
  103. Assert.AreEqual (t1, t2.Constraints [0].ConstraintType);
  104. Assert.AreEqual (t2, t3.Constraints [0].ConstraintType);
  105. });
  106. }
  107. [Test]
  108. public void GenericForwardBaseType ()
  109. {
  110. TestCSharp ("Generics.cs", module => {
  111. var tamchild = module.GetType ("TamChild");
  112. Assert.IsNotNull (tamchild);
  113. Assert.IsNotNull (tamchild.BaseType);
  114. var generic_instance = tamchild.BaseType as GenericInstanceType;
  115. Assert.IsNotNull (generic_instance);
  116. Assert.AreEqual (1, generic_instance.GenericArguments.Count);
  117. Assert.AreEqual (module.GetType ("Tamtam"), generic_instance.GenericArguments [0]);
  118. });
  119. }
  120. [Test]
  121. public void TypeExtentingGenericOfSelf ()
  122. {
  123. TestCSharp ("Generics.cs", module => {
  124. var rec_child = module.GetType ("RecChild");
  125. Assert.IsNotNull (rec_child);
  126. Assert.IsNotNull (rec_child.BaseType);
  127. var generic_instance = rec_child.BaseType as GenericInstanceType;
  128. Assert.IsNotNull (generic_instance);
  129. Assert.AreEqual (1, generic_instance.GenericArguments.Count);
  130. Assert.AreEqual (rec_child, generic_instance.GenericArguments [0]);
  131. });
  132. }
  133. [Test]
  134. public void TypeReferenceValueType ()
  135. {
  136. TestCSharp ("Methods.cs", module => {
  137. var baz = module.GetType ("Baz");
  138. var method = baz.GetMethod ("PrintAnswer");
  139. var box = method.Body.Instructions.Where (i => i.OpCode == OpCodes.Box).First ();
  140. var int32 = (TypeReference) box.Operand;
  141. Assert.IsTrue (int32.IsValueType);
  142. });
  143. }
  144. [Test]
  145. public void GenericInterfaceReference ()
  146. {
  147. TestModule ("gifaceref.exe", module => {
  148. var type = module.GetType ("Program");
  149. var iface = type.Interfaces [0];
  150. var instance = (GenericInstanceType) iface.InterfaceType;
  151. var owner = instance.ElementType;
  152. Assert.AreEqual (1, instance.GenericArguments.Count);
  153. Assert.AreEqual (1, owner.GenericParameters.Count);
  154. });
  155. }
  156. [Test]
  157. public void UnboundGenericParameter ()
  158. {
  159. TestModule ("cscgpbug.dll", module => {
  160. var type = module.GetType ("ListViewModel");
  161. var method = type.GetMethod ("<>n__FabricatedMethod1");
  162. var parameter = method.ReturnType as GenericParameter;
  163. Assert.IsNotNull (parameter);
  164. Assert.AreEqual (0, parameter.Position);
  165. Assert.IsNull (parameter.Owner);
  166. }, verify: false);
  167. }
  168. [Test]
  169. public void GenericMultidimensionalArray ()
  170. {
  171. TestCSharp ("Generics.cs", module => {
  172. var type = module.GetType ("LaMatrix");
  173. var method = type.GetMethod ("At");
  174. var call = method.Body.Instructions.Where (i => i.Operand is MethodReference).First ();
  175. var get = (MethodReference) call.Operand;
  176. Assert.IsNotNull (get);
  177. Assert.AreEqual (0, get.GenericParameters.Count);
  178. Assert.AreEqual (MethodCallingConvention.Default, get.CallingConvention);
  179. Assert.AreEqual (method.GenericParameters [0], get.ReturnType);
  180. });
  181. }
  182. [Test]
  183. public void CorlibPrimitive ()
  184. {
  185. var module = typeof (TypeTests).ToDefinition ().Module;
  186. var int32 = module.TypeSystem.Int32;
  187. Assert.IsTrue (int32.IsPrimitive);
  188. Assert.AreEqual (MetadataType.Int32, int32.MetadataType);
  189. var int32_def = int32.Resolve ();
  190. Assert.IsTrue (int32_def.IsPrimitive);
  191. Assert.AreEqual (MetadataType.Int32, int32_def.MetadataType);
  192. }
  193. [Test]
  194. public void ExplicitThis ()
  195. {
  196. TestIL ("explicitthis.il", module => {
  197. var type = module.GetType ("MakeDecision");
  198. var method = type.GetMethod ("Decide");
  199. var fptr = method.ReturnType as FunctionPointerType;
  200. Assert.IsNotNull (fptr);
  201. Assert.IsTrue (fptr.HasThis);
  202. Assert.IsTrue (fptr.ExplicitThis);
  203. Assert.AreEqual (0, fptr.Parameters [0].Sequence);
  204. Assert.AreEqual (1, fptr.Parameters [1].Sequence);
  205. }, verify: false);
  206. }
  207. [Test]
  208. public void DeferredCorlibTypeDef ()
  209. {
  210. using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location, new ReaderParameters (ReadingMode.Deferred))) {
  211. var object_type = module.TypeSystem.Object;
  212. Assert.IsInstanceOf<TypeDefinition> (object_type);
  213. }
  214. }
  215. [Test]
  216. public void CorlibTypesMetadataType ()
  217. {
  218. using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location)) {
  219. var type = module.GetType ("System.String");
  220. Assert.IsNotNull (type);
  221. Assert.IsNotNull (type.BaseType);
  222. Assert.AreEqual ("System.Object", type.BaseType.FullName);
  223. Assert.IsInstanceOf<TypeDefinition> (type.BaseType);
  224. Assert.AreEqual (MetadataType.String, type.MetadataType);
  225. Assert.AreEqual (MetadataType.Object, type.BaseType.MetadataType);
  226. }
  227. }
  228. [Test]
  229. public void SelfReferencingTypeRef ()
  230. {
  231. TestModule ("self-ref-typeref.dll", module => {
  232. }, verify: false);
  233. }
  234. }
  235. }