/Test/Mono.Cecil.Tests/ParameterTests.cs

http://github.com/jbevain/cecil · C# · 274 lines · 206 code · 68 blank · 0 comment · 0 complexity · d9ac529508cb7ae6888e949b880282fc MD5 · raw file

  1. using System;
  2. using NUnit.Framework;
  3. namespace Mono.Cecil.Tests {
  4. [TestFixture]
  5. public class ParameterTests : BaseTestFixture {
  6. [Test]
  7. public void MarshalAsI4 ()
  8. {
  9. TestModule ("marshal.dll", module => {
  10. var bar = module.GetType ("Bar");
  11. var pan = bar.GetMethod ("Pan");
  12. Assert.AreEqual (1, pan.Parameters.Count);
  13. var parameter = pan.Parameters [0];
  14. Assert.IsTrue (parameter.HasMarshalInfo);
  15. var info = parameter.MarshalInfo;
  16. Assert.AreEqual (typeof (MarshalInfo), info.GetType ());
  17. Assert.AreEqual (NativeType.I4, info.NativeType);
  18. });
  19. }
  20. [Test]
  21. public void CustomMarshaler ()
  22. {
  23. TestModule ("marshal.dll", module => {
  24. var bar = module.GetType ("Bar");
  25. var pan = bar.GetMethod ("PanPan");
  26. var parameter = pan.Parameters [0];
  27. Assert.IsTrue (parameter.HasMarshalInfo);
  28. var info = (CustomMarshalInfo) parameter.MarshalInfo;
  29. Assert.AreEqual (Guid.Empty, info.Guid);
  30. Assert.AreEqual (string.Empty, info.UnmanagedType);
  31. Assert.AreEqual (NativeType.CustomMarshaler, info.NativeType);
  32. Assert.AreEqual ("nomnom", info.Cookie);
  33. Assert.AreEqual ("Boc", info.ManagedType.FullName);
  34. Assert.AreEqual (module, info.ManagedType.Scope);
  35. });
  36. }
  37. [Test]
  38. public void SafeArrayMarshaler ()
  39. {
  40. TestModule ("marshal.dll", module => {
  41. var bar = module.GetType ("Bar");
  42. var pan = bar.GetMethod ("PanPan");
  43. Assert.IsTrue (pan.MethodReturnType.HasMarshalInfo);
  44. var info = (SafeArrayMarshalInfo) pan.MethodReturnType.MarshalInfo;
  45. Assert.AreEqual (VariantType.Dispatch, info.ElementType);
  46. });
  47. }
  48. [Test]
  49. public void ArrayMarshaler ()
  50. {
  51. TestModule ("marshal.dll", module => {
  52. var bar = module.GetType ("Bar");
  53. var pan = bar.GetMethod ("PanPan");
  54. var parameter = pan.Parameters [1];
  55. Assert.IsTrue (parameter.HasMarshalInfo);
  56. var info = (ArrayMarshalInfo) parameter.MarshalInfo;
  57. Assert.AreEqual (NativeType.I8, info.ElementType);
  58. Assert.AreEqual (66, info.Size);
  59. Assert.AreEqual (2, info.SizeParameterIndex);
  60. parameter = pan.Parameters [3];
  61. Assert.IsTrue (parameter.HasMarshalInfo);
  62. info = (ArrayMarshalInfo) parameter.MarshalInfo;
  63. Assert.AreEqual (NativeType.I2, info.ElementType);
  64. Assert.AreEqual (-1, info.Size);
  65. Assert.AreEqual (-1, info.SizeParameterIndex);
  66. });
  67. }
  68. [Test]
  69. public void ArrayMarshalerSized ()
  70. {
  71. TestModule ("marshal.dll", module => {
  72. var delegate_type = module.GetType ("SomeMethod");
  73. var parameter = delegate_type.GetMethod ("Invoke").Parameters [1];
  74. Assert.IsTrue (parameter.HasMarshalInfo);
  75. var array_info = (ArrayMarshalInfo) parameter.MarshalInfo;
  76. Assert.IsNotNull (array_info);
  77. Assert.AreEqual (0, array_info.SizeParameterMultiplier);
  78. });
  79. }
  80. [Test]
  81. public void NullableConstant ()
  82. {
  83. TestModule ("nullable-constant.exe", module => {
  84. var type = module.GetType ("Program");
  85. var method = type.GetMethod ("Foo");
  86. Assert.IsTrue (method.Parameters [0].HasConstant);
  87. Assert.IsTrue (method.Parameters [1].HasConstant);
  88. Assert.IsTrue (method.Parameters [2].HasConstant);
  89. Assert.AreEqual (1234, method.Parameters [0].Constant);
  90. Assert.AreEqual (null, method.Parameters [1].Constant);
  91. Assert.AreEqual (12, method.Parameters [2].Constant);
  92. });
  93. }
  94. [Test]
  95. public void BoxedDefaultArgumentValue ()
  96. {
  97. TestModule ("boxedoptarg.dll", module => {
  98. var foo = module.GetType ("Foo");
  99. var bar = foo.GetMethod ("Bar");
  100. var baz = bar.Parameters [0];
  101. Assert.IsTrue (baz.HasConstant);
  102. Assert.AreEqual (-1, baz.Constant);
  103. });
  104. }
  105. [Test]
  106. public void AddParameterIndex ()
  107. {
  108. var object_ref = new TypeReference ("System", "Object", null, null, false);
  109. var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
  110. var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
  111. var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  112. method.Parameters.Add (x);
  113. method.Parameters.Add (y);
  114. Assert.AreEqual (0, x.Index);
  115. Assert.AreEqual (1, y.Index);
  116. Assert.AreEqual (method, x.Method);
  117. Assert.AreEqual (method, y.Method);
  118. }
  119. [Test]
  120. public void RemoveAtParameterIndex ()
  121. {
  122. var object_ref = new TypeReference ("System", "Object", null, null, false);
  123. var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
  124. var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
  125. var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  126. var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  127. method.Parameters.Add (x);
  128. method.Parameters.Add (y);
  129. method.Parameters.Add (z);
  130. Assert.AreEqual (0, x.Index);
  131. Assert.AreEqual (1, y.Index);
  132. Assert.AreEqual (2, z.Index);
  133. method.Parameters.RemoveAt (1);
  134. Assert.AreEqual (0, x.Index);
  135. Assert.AreEqual (-1, y.Index);
  136. Assert.AreEqual (1, z.Index);
  137. }
  138. [Test]
  139. public void RemoveParameterIndex ()
  140. {
  141. var object_ref = new TypeReference ("System", "Object", null, null, false);
  142. var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
  143. var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
  144. var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  145. var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  146. method.Parameters.Add (x);
  147. method.Parameters.Add (y);
  148. method.Parameters.Add (z);
  149. Assert.AreEqual (0, x.Index);
  150. Assert.AreEqual (1, y.Index);
  151. Assert.AreEqual (2, z.Index);
  152. method.Parameters.Remove (y);
  153. Assert.AreEqual (0, x.Index);
  154. Assert.AreEqual (-1, y.Index);
  155. Assert.AreEqual (1, z.Index);
  156. }
  157. [Test]
  158. public void InsertParameterIndex ()
  159. {
  160. var object_ref = new TypeReference ("System", "Object", null, null, false);
  161. var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
  162. var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
  163. var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  164. var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
  165. method.Parameters.Add (x);
  166. method.Parameters.Add (z);
  167. Assert.AreEqual (0, x.Index);
  168. Assert.AreEqual (-1, y.Index);
  169. Assert.AreEqual (1, z.Index);
  170. method.Parameters.Insert (1, y);
  171. Assert.AreEqual (0, x.Index);
  172. Assert.AreEqual (1, y.Index);
  173. Assert.AreEqual (2, z.Index);
  174. }
  175. [Test]
  176. public void GenericParameterConstant ()
  177. {
  178. TestIL ("hello.il", module => {
  179. var foo = module.GetType ("Foo");
  180. var method = foo.GetMethod ("GetState");
  181. Assert.IsNotNull (method);
  182. var parameter = method.Parameters [1];
  183. Assert.IsTrue (parameter.HasConstant);
  184. Assert.IsNull (parameter.Constant);
  185. });
  186. }
  187. [Test]
  188. public void NullablePrimitiveParameterConstant ()
  189. {
  190. TestModule ("nullable-parameter.dll", module => {
  191. var test = module.GetType ("Test");
  192. var method = test.GetMethod ("Foo");
  193. Assert.IsNotNull (method);
  194. var param = method.Parameters [0];
  195. Assert.IsTrue (param.HasConstant);
  196. Assert.AreEqual (1234, param.Constant);
  197. param = method.Parameters [1];
  198. Assert.IsTrue (param.HasConstant);
  199. Assert.AreEqual (null, param.Constant);
  200. param = method.Parameters [2];
  201. Assert.IsTrue (param.HasConstant);
  202. Assert.AreEqual (12, param.Constant);
  203. });
  204. }
  205. }
  206. }