/Test/Mono.Cecil.Tests/FieldTests.cs

http://github.com/jbevain/cecil · C# · 372 lines · 292 code · 80 blank · 0 comment · 1 complexity · 7c2a5adbd10aff9d99f6104b6f0275ac MD5 · raw file

  1. using System;
  2. using Mono.Cecil.PE;
  3. using NUnit.Framework;
  4. namespace Mono.Cecil.Tests {
  5. [TestFixture]
  6. public class FieldTests : BaseTestFixture {
  7. [Test]
  8. public void TypeDefField ()
  9. {
  10. TestCSharp ("Fields.cs", module => {
  11. var type = module.Types [1];
  12. Assert.AreEqual ("Foo", type.Name);
  13. Assert.AreEqual (1, type.Fields.Count);
  14. var field = type.Fields [0];
  15. Assert.AreEqual ("bar", field.Name);
  16. Assert.AreEqual (1, field.MetadataToken.RID);
  17. Assert.IsNotNull (field.FieldType);
  18. Assert.AreEqual ("Bar", field.FieldType.FullName);
  19. Assert.AreEqual (TokenType.Field, field.MetadataToken.TokenType);
  20. Assert.IsFalse (field.HasConstant);
  21. Assert.IsNull (field.Constant);
  22. });
  23. }
  24. [Test]
  25. public void PrimitiveTypes ()
  26. {
  27. TestCSharp ("Fields.cs", module => {
  28. var type = module.GetType ("Baz");
  29. AssertField (type, "char", typeof (char));
  30. AssertField (type, "bool", typeof (bool));
  31. AssertField (type, "sbyte", typeof (sbyte));
  32. AssertField (type, "byte", typeof (byte));
  33. AssertField (type, "int16", typeof (short));
  34. AssertField (type, "uint16", typeof (ushort));
  35. AssertField (type, "int32", typeof (int));
  36. AssertField (type, "uint32", typeof (uint));
  37. AssertField (type, "int64", typeof (long));
  38. AssertField (type, "uint64", typeof (ulong));
  39. AssertField (type, "single", typeof (float));
  40. AssertField (type, "double", typeof (double));
  41. AssertField (type, "string", typeof (string));
  42. AssertField (type, "object", typeof (object));
  43. });
  44. }
  45. [Test]
  46. public void VolatileField ()
  47. {
  48. TestCSharp ("Fields.cs", module => {
  49. var type = module.GetType ("Bar");
  50. Assert.IsTrue (type.HasFields);
  51. Assert.AreEqual (1, type.Fields.Count);
  52. var field = type.Fields [0];
  53. Assert.AreEqual ("oiseau", field.Name);
  54. Assert.AreEqual ("System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile)", field.FieldType.FullName);
  55. Assert.IsFalse (field.HasConstant);
  56. });
  57. }
  58. [Test]
  59. public void FieldLayout ()
  60. {
  61. TestCSharp ("Layouts.cs", module => {
  62. var foo = module.GetType ("Foo");
  63. Assert.IsNotNull (foo);
  64. Assert.IsTrue (foo.HasFields);
  65. var fields = foo.Fields;
  66. var field = fields [0];
  67. Assert.AreEqual ("Bar", field.Name);
  68. Assert.IsTrue (field.HasLayoutInfo);
  69. Assert.AreEqual (0, field.Offset);
  70. field = fields [1];
  71. Assert.AreEqual ("Baz", field.Name);
  72. Assert.IsTrue (field.HasLayoutInfo);
  73. Assert.AreEqual (2, field.Offset);
  74. field = fields [2];
  75. Assert.AreEqual ("Gazonk", field.Name);
  76. Assert.IsTrue (field.HasLayoutInfo);
  77. Assert.AreEqual (4, field.Offset);
  78. });
  79. }
  80. [Test]
  81. public void FieldRVA ()
  82. {
  83. TestCSharp ("Layouts.cs", module => {
  84. var priv_impl = GetPrivateImplementationType (module);
  85. Assert.IsNotNull (priv_impl);
  86. Assert.AreEqual (1, priv_impl.Fields.Count);
  87. var field = priv_impl.Fields [0];
  88. Assert.IsNotNull (field);
  89. Assert.AreNotEqual (0, field.RVA);
  90. Assert.IsNotNull (field.InitialValue);
  91. Assert.AreEqual (16, field.InitialValue.Length);
  92. var buffer = new ByteBuffer (field.InitialValue);
  93. Assert.AreEqual (1, buffer.ReadUInt32 ());
  94. Assert.AreEqual (2, buffer.ReadUInt32 ());
  95. Assert.AreEqual (3, buffer.ReadUInt32 ());
  96. Assert.AreEqual (4, buffer.ReadUInt32 ());
  97. });
  98. }
  99. [Test]
  100. public void GenericFieldDefinition ()
  101. {
  102. TestCSharp ("Generics.cs", module => {
  103. var bar = module.GetType ("Bar`1");
  104. Assert.IsNotNull (bar);
  105. Assert.IsTrue (bar.HasGenericParameters);
  106. var t = bar.GenericParameters [0];
  107. Assert.AreEqual ("T", t.Name);
  108. Assert.AreEqual (t.Owner, bar);
  109. var bang = bar.GetField ("bang");
  110. Assert.IsNotNull (bang);
  111. Assert.AreEqual (t, bang.FieldType);
  112. });
  113. }
  114. [Test]
  115. public void ArrayFields ()
  116. {
  117. TestIL ("types.il", module => {
  118. var types = module.GetType ("Types");
  119. Assert.IsNotNull (types);
  120. var rank_two = types.GetField ("rank_two");
  121. var array = rank_two.FieldType as ArrayType;
  122. Assert.IsNotNull (array);
  123. Assert.AreEqual (2, array.Rank);
  124. Assert.IsFalse (array.Dimensions [0].IsSized);
  125. Assert.IsFalse (array.Dimensions [1].IsSized);
  126. var rank_two_low_bound_zero = types.GetField ("rank_two_low_bound_zero");
  127. array = rank_two_low_bound_zero.FieldType as ArrayType;
  128. Assert.IsNotNull (array);
  129. Assert.AreEqual (2, array.Rank);
  130. Assert.IsTrue (array.Dimensions [0].IsSized);
  131. Assert.AreEqual (0, array.Dimensions [0].LowerBound);
  132. Assert.AreEqual (null, array.Dimensions [0].UpperBound);
  133. Assert.IsTrue (array.Dimensions [1].IsSized);
  134. Assert.AreEqual (0, array.Dimensions [1].LowerBound);
  135. Assert.AreEqual (null, array.Dimensions [1].UpperBound);
  136. var rank_one_low_bound_m1 = types.GetField ("rank_one_low_bound_m1");
  137. array = rank_one_low_bound_m1.FieldType as ArrayType;
  138. Assert.IsNotNull (array);
  139. Assert.AreEqual (1, array.Rank);
  140. Assert.IsTrue (array.Dimensions [0].IsSized);
  141. Assert.AreEqual (-1, array.Dimensions [0].LowerBound);
  142. Assert.AreEqual (4, array.Dimensions [0].UpperBound);
  143. });
  144. }
  145. [Test]
  146. public void EnumFieldsConstant ()
  147. {
  148. TestCSharp ("Fields.cs", module => {
  149. var pim = module.GetType ("Pim");
  150. Assert.IsNotNull (pim);
  151. var field = pim.GetField ("Pam");
  152. Assert.IsTrue (field.HasConstant);
  153. Assert.AreEqual (1, (int) field.Constant);
  154. field = pim.GetField ("Poum");
  155. Assert.AreEqual (2, (int) field.Constant);
  156. });
  157. }
  158. [Test]
  159. public void StringAndClassConstant ()
  160. {
  161. TestCSharp ("Fields.cs", module => {
  162. var panpan = module.GetType ("PanPan");
  163. Assert.IsNotNull (panpan);
  164. var field = panpan.GetField ("Peter");
  165. Assert.IsTrue (field.HasConstant);
  166. Assert.IsNull (field.Constant);
  167. field = panpan.GetField ("QQ");
  168. Assert.AreEqual ("qq", (string) field.Constant);
  169. field = panpan.GetField ("nil");
  170. Assert.AreEqual (null, (string) field.Constant);
  171. });
  172. }
  173. [Test]
  174. public void ObjectConstant ()
  175. {
  176. TestCSharp ("Fields.cs", module => {
  177. var panpan = module.GetType ("PanPan");
  178. Assert.IsNotNull (panpan);
  179. var field = panpan.GetField ("obj");
  180. Assert.IsTrue (field.HasConstant);
  181. Assert.IsNull (field.Constant);
  182. });
  183. }
  184. [Test]
  185. public void NullPrimitiveConstant ()
  186. {
  187. TestIL ("types.il", module => {
  188. var fields = module.GetType ("Fields");
  189. var field = fields.GetField ("int32_nullref");
  190. Assert.IsTrue (field.HasConstant);
  191. Assert.AreEqual (null, field.Constant);
  192. });
  193. }
  194. [Test]
  195. public void ArrayConstant ()
  196. {
  197. TestCSharp ("Fields.cs", module => {
  198. var panpan = module.GetType ("PanPan");
  199. Assert.IsNotNull (panpan);
  200. var field = panpan.GetField ("ints");
  201. Assert.IsTrue (field.HasConstant);
  202. Assert.IsNull (field.Constant);
  203. });
  204. }
  205. [Test]
  206. public void ConstantCoalescing ()
  207. {
  208. TestIL ("types.il", module => {
  209. var fields = module.GetType ("Fields");
  210. var field = fields.GetField ("int32_int16");
  211. Assert.AreEqual ("System.Int32", field.FieldType.FullName);
  212. Assert.IsTrue (field.HasConstant);
  213. Assert.IsInstanceOf (typeof (short), field.Constant);
  214. Assert.AreEqual ((short) 1, field.Constant);
  215. field = fields.GetField ("int16_int32");
  216. Assert.AreEqual ("System.Int16", field.FieldType.FullName);
  217. Assert.IsTrue (field.HasConstant);
  218. Assert.IsInstanceOf (typeof (int), field.Constant);
  219. Assert.AreEqual (1, field.Constant);
  220. field = fields.GetField ("char_int16");
  221. Assert.AreEqual ("System.Char", field.FieldType.FullName);
  222. Assert.IsTrue (field.HasConstant);
  223. Assert.IsInstanceOf (typeof (short), field.Constant);
  224. Assert.AreEqual ((short) 1, field.Constant);
  225. field = fields.GetField ("int16_char");
  226. Assert.AreEqual ("System.Int16", field.FieldType.FullName);
  227. Assert.IsTrue (field.HasConstant);
  228. Assert.IsInstanceOf (typeof (char), field.Constant);
  229. Assert.AreEqual ('s', field.Constant);
  230. });
  231. }
  232. [Test]
  233. public void NestedEnumOfGenericTypeDefinition ()
  234. {
  235. TestCSharp ("Generics.cs", module => {
  236. var dang = module.GetType ("Bongo`1/Dang");
  237. Assert.IsNotNull (dang);
  238. var field = dang.GetField ("Ding");
  239. Assert.IsNotNull (field);
  240. Assert.AreEqual (2, field.Constant);
  241. field = dang.GetField ("Dong");
  242. Assert.IsNotNull (field);
  243. Assert.AreEqual (12, field.Constant);
  244. });
  245. }
  246. [Test]
  247. public void MarshalAsFixedStr ()
  248. {
  249. TestModule ("marshal.dll", module => {
  250. var boc = module.GetType ("Boc");
  251. var field = boc.GetField ("a");
  252. Assert.IsNotNull (field);
  253. Assert.IsTrue (field.HasMarshalInfo);
  254. var info = (FixedSysStringMarshalInfo) field.MarshalInfo;
  255. Assert.AreEqual (42, info.Size);
  256. });
  257. }
  258. [Test]
  259. public void MarshalAsFixedArray ()
  260. {
  261. TestModule ("marshal.dll", module => {
  262. var boc = module.GetType ("Boc");
  263. var field = boc.GetField ("b");
  264. Assert.IsNotNull (field);
  265. Assert.IsTrue (field.HasMarshalInfo);
  266. var info = (FixedArrayMarshalInfo) field.MarshalInfo;
  267. Assert.AreEqual (12, info.Size);
  268. Assert.AreEqual (NativeType.Boolean, info.ElementType);
  269. });
  270. }
  271. [Test]
  272. public void UnattachedField ()
  273. {
  274. var field = new FieldDefinition ("Field", FieldAttributes.Public, typeof (int).ToDefinition ());
  275. Assert.IsFalse (field.HasConstant);
  276. Assert.IsNull (field.Constant);
  277. }
  278. static TypeDefinition GetPrivateImplementationType (ModuleDefinition module)
  279. {
  280. foreach (var type in module.Types)
  281. if (type.FullName.Contains ("<PrivateImplementationDetails>"))
  282. return type;
  283. return null;
  284. }
  285. static void AssertField (TypeDefinition type, string name, Type expected)
  286. {
  287. var field = type.GetField (name);
  288. Assert.IsNotNull (field, name);
  289. Assert.AreEqual (expected.FullName, field.FieldType.FullName);
  290. }
  291. }
  292. }