PageRenderTime 87ms CodeModel.GetById 34ms RepoModel.GetById 1ms app.codeStats 0ms

/mcs/tools/mdoc/Test/DocTest-v1.cs

https://bitbucket.org/danipen/mono
C# | 722 lines | 293 code | 120 blank | 309 comment | 8 complexity | c1bb0aa8bdf90189bbd2a67caf4ae9d8 MD5 | raw file
Possible License(s): Unlicense, Apache-2.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. /// <summary>Namespace Test: [<see cref="N:Mono.DocTest" />]</summary>
  6. /// <remarks><c>T:NoNamespace</c></remarks>
  7. public class NoNamespace {}
  8. namespace System {
  9. /*
  10. * The System namespace gets special treatment, e.g. instead of
  11. * System.Environment C# declarations it's just Environment.
  12. */
  13. /// <remarks><c>T:System.Action`1</c></remarks>
  14. public delegate void Action<T> (T obj);
  15. /// <remarks><c>T:System.Environment</c></remarks>
  16. public static class Environment {
  17. /// <remarks><c>T:System.Environment+SpecialFolder</c></remarks>
  18. public enum SpecialFolder {}
  19. /// <param name="folder">
  20. /// A <see cref="T:System.Environment+SpecialFolder" /> instance.
  21. /// </param>
  22. /// <remarks>
  23. /// <c>M:System.Environment.GetFolderPath(System.Environment+SpecialFolder)</c>
  24. /// </remarks>
  25. public static string GetFolderPath (SpecialFolder folder)
  26. {
  27. throw new NotSupportedException ();
  28. }
  29. }
  30. // to test ECMA doc importing...
  31. public class Array {
  32. // the ECMA docs have a different return type than .NET -- skip.
  33. public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T> (T[] array)
  34. {
  35. throw new NotImplementedException ();
  36. }
  37. // ECMA docs use <T,U> instead of <TInput,TOutput> --> map them.
  38. public static TOutput[] ConvertAll<TInput, TOutput> (TInput[] array, Converter<TInput, TOutput> converter)
  39. {
  40. throw new InvalidOperationException ();
  41. }
  42. // ECMA docs *incorrectly* document parameter -- skip
  43. public static void Resize<T> (ref T[] array, int newSize)
  44. {
  45. throw new Exception ();
  46. }
  47. }
  48. // to test ECMA doc importing...
  49. public delegate void AsyncCallback (IAsyncResult ar);
  50. }
  51. namespace Mono.DocTest {
  52. internal class Internal {
  53. public class ShouldNotBeDocumented {
  54. }
  55. }
  56. internal class MonoTODOAttribute : Attribute {
  57. }
  58. /// <remarks>
  59. /// <para>
  60. /// cref=<c>T:Mono.DocTest.DocAttribute</c>.
  61. /// </para>
  62. /// <format type="text/html">
  63. /// <table width="100%">
  64. /// <tr>
  65. /// <td style="color:red">red</td>
  66. /// <td style="color:blue">blue</td>
  67. /// <td style="color:green">green</td>
  68. /// </tr>
  69. /// </table>
  70. /// </format>
  71. /// <code lang="C#" src="../DocTest.cs#DocAttribute Example" />
  72. /// </remarks>
  73. [AttributeUsage (AttributeTargets.All)]
  74. public class DocAttribute : Attribute {
  75. #region DocAttribute Example
  76. [Doc ("documented class")]
  77. class Example {
  78. [Doc ("documented field")] public string field;
  79. }
  80. #endregion
  81. /// <remarks><c>C:Mono.DocTest.DocAttribute(System.String)</c></remarks>
  82. public DocAttribute (string docs)
  83. {
  84. if (docs == null)
  85. throw new ArgumentNullException ("docs");
  86. }
  87. /// <remarks><c>P:Mono.DocTest.DocAttribute.Property</c></remarks>
  88. public Type Property { get; set; }
  89. /// <remarks><c>F:Mono.DocTest.DocAttribute.Field</c></remarks>
  90. public bool Field;
  91. /// <remarks><c>F:Mono.DocTest.DocAttribute.FlagsEnum</c></remarks>
  92. public ConsoleModifiers FlagsEnum;
  93. /// <remarks><c>F:Mono.DocTest.DocAttribute.NonFlagsEnum</c></remarks>
  94. public Color NonFlagsEnum;
  95. }
  96. /// <summary>Possible colors</summary>
  97. /// <remarks>
  98. /// <see cref="T:Mono.DocTest.Color"/>.
  99. /// Namespace Test: [<see cref="N:Mono.DocTest" />]
  100. /// </remarks>
  101. [MonoTODO]
  102. public enum Color {
  103. /// <summary>Insert Red summary here</summary>
  104. /// <remarks><c>F:Mono.DocTest.Color.Red</c>.</remarks>
  105. Red,
  106. /// <summary>Insert Blue summary here</summary>
  107. /// <remarks><c>F:Mono.DocTest.Color.Blue</c>.</remarks>
  108. Blue,
  109. /// <summary>Insert Green summary here</summary>
  110. /// <remarks><c>F:Mono.DocTest.Color.Green</c>.</remarks>
  111. Green,
  112. AnotherGreen = Green,
  113. }
  114. /// <summary>Process interface</summary>
  115. /// <remarks><c>T:Mono.DocTest.IProcess</c>.</remarks>
  116. public interface IProcess {}
  117. /// <summary>Process interface</summary>
  118. /// <remarks><c>T:Mono.DocTest.DocValueType</c>.</remarks>
  119. public struct DocValueType : IProcess {
  120. /// <remarks><c>F:Mono.DocTest.DocValueType.total</c>.</remarks>
  121. public int total;
  122. /// <param name="i">A <see cref="T:System.Int32" />.</param>
  123. /// <remarks><see cref="M:Mono.DocTest.DocValueType.M(System.Int32)"/>.</remarks>
  124. public void M (int i)
  125. {
  126. if ((new Random().Next() % 2) == 0)
  127. throw new SystemException ();
  128. throw new ApplicationException ();
  129. }
  130. }
  131. /// <remarks><c>T:Mono.DocTest.D</c></remarks>
  132. public delegate dynamic D (Func<string, dynamic, object> value);
  133. /// <remarks><c>T:Mono.DocTest.Widget</c>.</remarks>
  134. /// <seealso cref="P:Mono.DocTest.Widget.Item(System.Int32)" />
  135. /// <extra>Some extra tag value</extra>
  136. public unsafe class Widget : IProcess {
  137. /// <remarks><c>T:Mono.DocTest.Widget.NestedClass</c>.</remarks>
  138. public class NestedClass {
  139. /// <remarks><c>F:Mono.DocTest.Widget.NestedClass.value</c>.</remarks>
  140. public int value;
  141. /// <param name="i">Some <see cref="T:System.Int32" />.</param>
  142. /// <remarks><c>M:Mono.DocTest.Widget.NestedClass.M(System.Int32)</c>.</remarks>
  143. public void M (int i) {}
  144. /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double</c>.</remarks>
  145. public class Double {
  146. /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple</c>.</remarks>
  147. public class Triple {
  148. /// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple</c>.</remarks>
  149. public class Quadruple {} // for good measure
  150. }
  151. }
  152. }
  153. /// <remarks><c>T:Mono.DocTest.Widget.NestedClass`1</c>.</remarks>
  154. public class NestedClass<T> {
  155. /// <remarks><c>F:Mono.DocTest.Widget.NestedClass`1.value</c>.</remarks>
  156. public int value;
  157. /// <param name="i">Another <see cref="T:System.Int32" />.</param>
  158. /// <remarks><c>M:Mono.DocTest.Widget.NestedClass`1.M(System.Int32)</c>.</remarks>
  159. public void M (int i) {}
  160. }
  161. /// <remarks><c>F:Mono.DocTest.Widget.classCtorError</c>.</remarks>
  162. public static readonly string[] classCtorError = CreateArray ();
  163. private static string[] CreateArray ()
  164. {
  165. throw new NotSupportedException ();
  166. }
  167. /// <remarks><c>F:Mono.DocTest.Widget.message</c>.</remarks>
  168. public string message;
  169. /// <remarks><c>F:Mono.DocTest.Widget.defaultColor</c>.</remarks>
  170. protected static Color defaultColor;
  171. /// <remarks><c>F:Mono.DocTest.Widget.PI</c>.</remarks>
  172. protected internal const double PI = 3.14159;
  173. /// <remarks><c>F:Mono.DocTest.Widget.monthlyAverage</c>.</remarks>
  174. internal protected readonly double monthlyAverage;
  175. /// <remarks><c>F:Mono.DocTest.Widget.array1</c>.</remarks>
  176. public long[] array1;
  177. /// <remarks><c>F:Mono.DocTest.Widget.array2</c>.</remarks>
  178. public Widget[,] array2;
  179. /// <remarks><c>F:Mono.DocTest.Widget.pCount</c>.</remarks>
  180. public unsafe int *pCount;
  181. /// <remarks><c>F:Mono.DocTest.Widget.ppValues</c>.</remarks>
  182. public unsafe float **ppValues;
  183. /// <remarks><c>T:Mono.DocTest.Widget.IMenuItem</c>.</remarks>
  184. public interface IMenuItem {
  185. /// <remarks><c>M:Mono.DocTest.Widget.IMenuItem.A</c>.</remarks>
  186. void A ();
  187. /// <remarks><c>P:Mono.DocTest.Widget.IMenuItem.P</c>.</remarks>
  188. int B {get; set;}
  189. }
  190. /// <remarks><c>T:Mono.DocTest.Widget.Del</c>.</remarks>
  191. public delegate void Del (int i);
  192. /// <remarks><c>T:Mono.DocTest.Widget.Direction</c>.</remarks>
  193. [Flags]
  194. protected internal enum Direction {
  195. /// <remarks><c>T:Mono.DocTest.Widget.Direction.North</c>.</remarks>
  196. North,
  197. /// <remarks><c>T:Mono.DocTest.Widget.Direction.South</c>.</remarks>
  198. South,
  199. /// <remarks><c>T:Mono.DocTest.Widget.Direction.East</c>.</remarks>
  200. East,
  201. /// <remarks><c>T:Mono.DocTest.Widget.Direction.West</c>.</remarks>
  202. West,
  203. }
  204. /// <remarks>
  205. /// <para><c>C:Mono.DocTest.Widget</c>.</para>
  206. /// <para><c>M:Mono.DocTest.Widget.#ctor</c>.</para>
  207. /// <para><see cref="C:Mono.DocTest.Widget(System.String)" /></para>
  208. /// <para><see cref="C:Mono.DocTest.Widget(System.Converter{System.String,System.String})" /></para>
  209. /// </remarks>
  210. public Widget () {}
  211. /// <param name="s">A <see cref="T:System.String" />.</param>
  212. /// <remarks>
  213. /// <para><c>C:Mono.DocTest.Widget(System.String)</c>.</para>
  214. /// <para><c>M:Mono.DocTest.Widget.#ctor(System.String)</c>.</para>
  215. /// </remarks>
  216. public Widget (string s) {}
  217. /// <param name="c">A <see cref="T:System.Converter{System.String,System.String}" />.</param>
  218. /// <remarks>
  219. /// <para><c>C:Mono.DocTest.Widget(System.Converter{System.String,System.String})</c>.</para>
  220. /// </remarks>
  221. public Widget (Converter<string,string> c) {}
  222. /// <remarks><c>M:Mono.DocTest.Widget.M0</c>.</remarks>
  223. public static void M0 () {}
  224. /// <param name="c">A <see cref="T:System.Char" />.</param>
  225. /// <param name="f">A <see cref="T:System.Single" />.</param>
  226. /// <param name="v">A <see cref="T:Mono.DocTest.DocValueType" />.</param>
  227. /// <remarks><c>M:Mono.DocTest.Widget.M1(System.Char,System.Signle@,Mono.DocTest.DocValueType@)</c>.</remarks>
  228. [return:Doc ("return:DocAttribute", Property=typeof(Widget))]
  229. [Doc("normal DocAttribute", Field=true)]
  230. public void M1 ([Doc ("c", FlagsEnum=ConsoleModifiers.Alt | ConsoleModifiers.Control)] char c,
  231. [Doc ("f", NonFlagsEnum=Color.Red)] out float f,
  232. [Doc ("v")] ref DocValueType v) {f=0;}
  233. /// <param name="x1">A <see cref="T:System.Int16" /> array.</param>
  234. /// <param name="x2">A <see cref="T:System.Int32" /> array.</param>
  235. /// <param name="x3">A <see cref="T:System.Int64" /> array.</param>
  236. /// <remarks><c>M:Mono.DocTest.Widget.M2(System.Int16[],System.Int32[0:,0:],System.Int64[][])</c>.</remarks>
  237. public void M2 (short[] x1, int[,] x2, long[][] x3) {}
  238. /// <param name="x3">Another <see cref="T:System.Int64" /> array.</param>
  239. /// <param name="x4">A <see cref="T:Mono.DocTest.Widget" /> array.</param>
  240. /// <remarks><c>M:Mono.DocTest.Widget.M3(System.Int64[][],Mono.DocTest.Widget[0:,0:,0:][])</c>.</remarks>
  241. protected void M3 (long[][] x3, Widget[][,,] x4) {}
  242. /// <param name="pc">A <see cref="T:System.Char" /> pointer.</param>
  243. /// <param name="ppf">A <see cref="T:Mono.DocTest.Color" /> pointer.</param>
  244. /// <remarks><c>M:Mono.DocTest.Widget.M4(System.Char*,Mono.DocTest.Color**)</c>.</remarks>
  245. protected unsafe void M4 (char *pc, Color **ppf) {}
  246. /// <param name="pv">A <see cref="T:System.Void" /> pointer.</param>
  247. /// <param name="pd">A <see cref="T:System.Double" /> array.</param>
  248. /// <remarks><c>M:Mono.DocTest.Widget.M5(System.Void*,System.Double*[0:,0:][])</c>.</remarks>
  249. protected unsafe void M5 (void *pv, double *[][,] pd) {}
  250. /// <param name="i">Yet another <see cref="T:System.Int32" />.</param>
  251. /// <param name="args">An <see cref="T:System.Object" /> array.</param>
  252. /// <remarks><c>M:Mono.DocTest.Widget.M6(System.Int32,System.Object[])</c>.</remarks>
  253. protected void M6 (int i, params object[] args) {}
  254. /// <remarks><c>M:Mono.DocTest.Widget.M7(Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple)</c>.</remarks>
  255. public void M7(Widget.NestedClass.Double.Triple.Quadruple a) {}
  256. /// <value>A <see cref="T:System.Int32" /> value...</value>
  257. /// <remarks><c>P:Mono.DocTest.Widget.Width</c>.</remarks>
  258. [Doc ("Width property")]
  259. public int Width {
  260. [Doc ("Width get accessor")]
  261. get {return 0;}
  262. [Doc ("Width set accessor")]
  263. protected set {}
  264. }
  265. /// <value>A <see cref="T:System.Int64" /> value...</value>
  266. /// <remarks><c>P:Mono.DocTest.Widget.Height</c>.</remarks>
  267. [Doc ("Height property")]
  268. protected long Height {get {return 0;}}
  269. /// <value>A <see cref="T:System.Int16" /> value...</value>
  270. /// <remarks><c>P:Mono.DocTest.Widget.X</c>.</remarks>
  271. protected internal short X {set {}}
  272. /// <value>A <see cref="T:System.Double" /> value...</value>
  273. /// <remarks><c>P:Mono.DocTest.Widget.Y</c>.</remarks>
  274. internal protected double Y {get {return 0;} set {}}
  275. /// <param name="i">TODO</param>
  276. /// <remarks><c>P:Mono.DocTest.Widget.Item(System.Int32)</c>.</remarks>
  277. /// <value>A <see cref="T:System.Int32" /> instance.</value>
  278. [Doc ("Item property")]
  279. public int this [int i] {
  280. get {return 0;}
  281. [Doc ("Item property set accessor")]
  282. set {}
  283. }
  284. /// <param name="s">Some <see cref="T:System.String" />.</param>
  285. /// <param name="i">I love <see cref="T:System.Int32" />s.</param>
  286. /// <remarks><c>P:Mono.DocTest.Widget.Item(System.String,System.Int32)</c>.</remarks>
  287. /// <value>A <see cref="T:System.Int32" /> instance.</value>
  288. public int this [string s, int i] {get {return 0;} set {}}
  289. /// <remarks><c>E:Mono.DocTest.Widget.AnEvent</c>.</remarks>
  290. [Doc ("Del event")]
  291. public event Del AnEvent {
  292. [Doc ("Del add accessor")]
  293. add {}
  294. [Doc ("Del remove accessor")]
  295. remove {}
  296. }
  297. /// <remarks><c>E:Mono.DocTest.Widget.AnotherEvent</c>.</remarks>
  298. protected event Del AnotherEvent;
  299. /// <param name="x">Another <see cref="T:Mono.DocTest.Widget" />.</param>
  300. /// <remarks><c>M:Mono.DocTest.Widget.op_UnaryPlus(Mono.DocTest.Widget)</c>.</remarks>
  301. /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance.</returns>
  302. public static Widget operator+ (Widget x) {return null;}
  303. /// <param name="x1">Yet Another <see cref="T:Mono.DocTest.Widget" />.</param>
  304. /// <param name="x2">Yay, <see cref="T:Mono.DocTest.Widget" />s.</param>
  305. /// <remarks><c>M:Mono.DocTest.Widget.op_Addition(Mono.DocTest.Widget,Mono.DocTest.Widget)</c>.</remarks>
  306. /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance (2).</returns>
  307. public static Widget operator+ (Widget x1, Widget x2) {return null;}
  308. /// <param name="x"><see cref="T:Mono.DocTest.Widget" />s are fun!.</param>
  309. /// <remarks><c>M:Mono.DocTest.Widget.op_Explicit(Mono.DocTest.Widget)~System.Int32</c>.</remarks>
  310. /// <returns>A <see cref="T:System.Int32" /> instance.</returns>
  311. public static explicit operator int (Widget x) {return 0;}
  312. /// <param name="x"><c>foo</c>; <see cref="T:Mono.DocTest.Widget" />.</param>
  313. /// <remarks><c>M:Mono.DocTest.Widget.op_Implicit(Mono.DocTest.Widget)~System.Int64</c>.</remarks>
  314. /// <returns>A <see cref="T:System.Int64" /> instance.</returns>
  315. public static implicit operator long (Widget x) {return 0;}
  316. /// <remarks><c>M:Mono.DocTest.Widget.Default(System.Int32,System.Int32)</c></remarks>
  317. public void Default (int a = 1, int b = 2) {}
  318. /// <remarks><c>M:Mono.DocTest.Widget.Default(System.String,System.Char)</c></remarks>
  319. public void Default (string a = "a", char b = 'b') {}
  320. /// <remarks><c>M:Mono.DocTest.Widget.Dynamic0(System.Object,System.Object)</c></remarks>
  321. public dynamic Dynamic0 (dynamic a, dynamic b) {return a + b;}
  322. /// <remarks><c>M:Mono.DocTest.Widget.Dynamic1(System.Collections.Generic.Dictionary{System.Object,System.Object})</c></remarks>
  323. public Dictionary<dynamic, string> Dynamic1 (Dictionary<dynamic, string> value) {return value;}
  324. /// <remarks><c>M:Mono.DocTest.Widget.Dynamic2(System.Func{System.String,System.Object})</c></remarks>
  325. public Func<string, dynamic> Dynamic2 (Func<string, dynamic> value) {return value;}
  326. /// <remarks><c>M:Mono.DocTest.Widget.Dynamic3(System.Func{System.Func{System.String,System.Object},System.Func{System.Object,System.String}})</c></remarks>
  327. public Func<Func<string, dynamic>, Func<dynamic, string>> Dynamic3 (
  328. Func<Func<string, dynamic>, Func<dynamic, string>> value) {return value;}
  329. /// <remarks><c>P:Mono.DocTest.Widget.DynamicP</c></remarks>
  330. public Func<Func<string, dynamic, string>, Func<dynamic, Func<dynamic>, string>> DynamicP {
  331. get {return null;}
  332. }
  333. /// <remarks><c>F:Mono.DocTest.Widget.DynamicF</c></remarks>
  334. public Func<Func<string, dynamic, string>, Func<dynamic, Func<dynamic>, string>> DynamicF;
  335. /// <remarks><c>E:Mono.DocTest.Widget.DynamicE1</c></remarks>
  336. [Obsolete ("why not")]
  337. public event Func<dynamic> DynamicE1;
  338. /// <remarks><c>E:Mono.DocTest.Widget.DynamicE2</c></remarks>
  339. public event Func<dynamic> DynamicE2 {
  340. add {}
  341. remove {}
  342. }
  343. }
  344. /// <remarks><c>T:Mono.DocTest.UseLists</c>.</remarks>
  345. public class UseLists
  346. {
  347. /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param>
  348. /// <remarks><c>M:Mono.DocTest.UseLists.Process(Mono.DocTest.MyList{System.Int32})</c>.</remarks>
  349. public void Process (Generic.MyList<int> list) {}
  350. /// <param name="value">A <c>T</c>.</param>
  351. /// <typeparam name="T">Something</typeparam>
  352. /// <remarks><c>M:Mono.DocTest.UseLists.GetValues``1(``0)</c>.</remarks>
  353. /// <returns>A <see cref="T:Mono.DocTest.Generic.MyList`1" /> instance.</returns>
  354. public Generic.MyList<T> GetValues <T> (T value) where T : struct {return null;}
  355. /// <param name="list">Another <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param>
  356. /// <remarks>
  357. /// <para><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Int32})</c>.</para>
  358. /// <para><see cref="M:System.Collections.Generic.List{System.Int32}.Remove(`0)" /></para>
  359. /// </remarks>
  360. /// <exception invalid="foo">text!</exception>
  361. public void Process (List<int> list)
  362. {
  363. // Bug: only creation is looked for, so this generates an <exception/>
  364. // node:
  365. new Exception ();
  366. // Bug? We only look at "static" types, so we can't follow
  367. // delegates/interface calls:
  368. Func<int, int> a = x => {throw new InvalidOperationException ();};
  369. a (1);
  370. // Multi-dimensional arrays have "phantom" methods that Cecil can't
  371. // resolve, as they're provided by the runtime. These should be
  372. // ignored.
  373. int[,] array = new int[1,1];
  374. array[0,0] = 42;
  375. }
  376. /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{System.Int32}}" />.</param>
  377. /// <remarks><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Predicate{System.Int32}})</c>.</remarks>
  378. public void Process (List<Predicate<int>> list)
  379. {
  380. if (list == null)
  381. throw new ArgumentNullException ("list");
  382. Process<int> (list);
  383. }
  384. /// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{``0}}" />.</param>
  385. /// <typeparam name="T">Something Else</typeparam>
  386. /// <remarks><c>M:Mono.DocTest.UseLists.Process``1(System.Collections.Generic.List{System.Predicate{``0}})</c>.</remarks>
  387. public void Process<T> (List<Predicate<T>> list)
  388. {
  389. if (list.Any (p => p == null))
  390. throw new ArgumentException ("predicate null");
  391. }
  392. /// <param name="helper">A <see cref="T:Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2}" />.</param>
  393. /// <typeparam name="T"><c>T</c></typeparam>
  394. /// <typeparam name="U"><c>U</c></typeparam>
  395. /// <typeparam name="V"><c>V</c></typeparam>
  396. /// <remarks><c>M:Mono.DocTest.UseLists.UseHelper``3(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2})</c>.</remarks>
  397. public void UseHelper<T,U,V> (Generic.MyList<T>.Helper<U,V> helper) {}
  398. }
  399. }
  400. namespace Mono.DocTest.Generic {
  401. // Need to place this into a separate namespace to work around gmcs bug
  402. // where XML docs for type *following* this one aren't extracted.
  403. /// <typeparam name="TArg">argument type, with attributes!</typeparam>
  404. /// <typeparam name="TRet">return type, with attributes!</typeparam>
  405. /// <remarks><c>T:Mono.DocTest.Generic.Func`2</c>.</remarks>
  406. [Doc ("method")]
  407. [return:Doc ("return", Field=false)]
  408. public delegate TRet Func<[Doc ("arg!")] in TArg, [Doc ("ret!")] out TRet> (
  409. [Doc ("arg-actual")] TArg a
  410. ) where TArg : Exception;
  411. }
  412. namespace Mono.DocTest.Generic {
  413. using Mono.DocTest;
  414. /// <summary>extension methods!</summary>
  415. /// <remarks><c>T:Mono.DocTest.Generic.Extensions</c></remarks>
  416. public static class Extensions {
  417. /// <summary><c>System.Object</c> extension method</summary>
  418. /// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToEnumerable``1</c></remarks>
  419. public static IEnumerable<T> ToEnumerable<T> (this T self)
  420. {
  421. yield return self;
  422. }
  423. /// <summary><see cref="T:System.Collections.Generic.IEnumerable`1" /> extension method</summary>
  424. /// <remarks><c>M:Mono.DocTest.Generic.Extensions.ForEach``1</c></remarks>
  425. public static void ForEach<T> (this IEnumerable<T> self, Action<T> a)
  426. {
  427. }
  428. /// <summary><see cref="T:Mono.DocTest.Generic.IFoo`1" /> extension method</summary>
  429. /// <remarks><c>M:Mono.DocTest.Generic.Extensions.Bar``1</c></remarks>
  430. public static void Bar <T> (this IFoo<T> self, string s)
  431. {
  432. }
  433. /// <summary>
  434. /// <see cref="T:System.Collections.Generic.IEnumerable{System.Int32}" />
  435. /// extension method.
  436. /// </summary>
  437. /// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToDouble</c></remarks>
  438. public static IEnumerable<double> ToDouble (this IEnumerable<int> list)
  439. {
  440. return null;
  441. }
  442. /// <summary>
  443. /// <see cref="T:Mono.DocTest.Generic.IFoo`1" /> extension method.
  444. /// </summary>
  445. /// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToDouble</c></remarks>
  446. public static double ToDouble<T> (this T val) where T : IFoo<T>
  447. {
  448. // the target type is T:...IFoo<T>, NOT T:System.Object.
  449. return 0.0;
  450. }
  451. }
  452. /// <typeparam name="U">Insert <c>text</c> here.</typeparam>
  453. /// <remarks><c>T:Mono.DocTest.Generic.GenericBase`1</c>.</remarks>
  454. public class GenericBase<U> {
  455. /// <param name="genericParameter">Something</param>
  456. /// <typeparam name="S">Insert more <c>text</c> here.</typeparam>
  457. /// <remarks><c>M:Mono.DocTest.GenericBase`1.BaseMethod``1(``0)</c>.</remarks>
  458. /// <returns>The default value.</returns>
  459. public U BaseMethod<[Doc ("S")] S> (S genericParameter) {
  460. return default(U);
  461. }
  462. /// <remarks><c>F:Mono.DocTest.GenericBase`1.StaticField1</c></remarks>
  463. public static readonly GenericBase<U> StaticField1 = new GenericBase<U> ();
  464. /// <remarks><c>F:Mono.DocTest.GenericBase`1.ConstField1</c></remarks>
  465. public const int ConstField1 = 1;
  466. /// <param name="list">Insert description here</param>
  467. /// <remarks><c>M:Mono.DocTest.GenericBase`1.op_Explicit(Mono.DocTest.GenericBase{`0})~`0</c></remarks>
  468. /// <returns>The default value for <typeparamref name="U"/>.</returns>
  469. public static explicit operator U (GenericBase<U> list) {return default(U);}
  470. /// <remarks>T:Mono.DocTest.Generic.GenericBase`1.FooEventArgs</remarks>
  471. public class FooEventArgs : EventArgs {
  472. }
  473. /// <remarks>E:Mono.DocTest.Generic.GenericBase`1.MyEvent</remarks>
  474. public event EventHandler<FooEventArgs> MyEvent;
  475. /// <remarks>E:Mono.DocTest.Generic.GenericBase`1.ItemChanged</remarks>
  476. public event Action<MyList<U>, MyList<U>.Helper<U, U>> ItemChanged;
  477. /// <remarks>T:Mono.DocTest.Generic.GenericBase`1.NestedCollection</remarks>
  478. public class NestedCollection {
  479. /// <remarks>T:Mono.DocTest.Generic.GenericBase`1.NestedCollection.Enumerator</remarks>
  480. protected internal struct Enumerator {
  481. }
  482. }
  483. }
  484. /// <typeparam name="T">I'm Dying Here!</typeparam>
  485. /// <remarks><c>T:Mono.DocTest.Generic.MyList`1</c>.</remarks>
  486. public class MyList<[Mono.DocTest.Doc("Type Parameter!")] T> : GenericBase <T>, IEnumerable<int[]>
  487. {
  488. /// <typeparam name="U">Seriously!</typeparam>
  489. /// <typeparam name="V">Too <c>many</c> docs!</typeparam>
  490. /// <remarks><c>T:Mono.DocTest.MyList`1.Helper`2</c>.</remarks>
  491. public class Helper <U, V> {
  492. /// <param name="a">Ako</param>
  493. /// <param name="b">bko</param>
  494. /// <param name="c">cko</param>
  495. /// <remarks><c>M:Mono.DocTest.MyList`1.Helper`2.UseT(`0,`1,`2)</c>.</remarks>
  496. public void UseT(T a, U b, V c) { }
  497. }
  498. /// <param name="t">tko</param>
  499. /// <remarks><c>M:Mono.DocTest.MyList`1.Test(`0)</c>.</remarks>
  500. public void Test (T t) {}
  501. /// <param name="t">Class generic type</param>
  502. /// <param name="u">Method generic type</param>
  503. /// <typeparam name="U">Method generic parameter</typeparam>
  504. /// <remarks><c>M:Mono.DocTest.MyList`1.Method``1(`0,``0)</c>.</remarks>
  505. public void Method <U> (T t, U u) {}
  506. // mcs "crashes" (CS1569) on this method; exclude it for now.
  507. // <remarks><c>M:Mono.DocTest.MyList`1.RefMethod``1(`0@,``0@)</c>.</remarks>
  508. public void RefMethod<U> (ref T t, ref U u) {}
  509. /// <param name="helper">A <see cref="T:Mono.DocTest.Generic.MyList`1.Helper`2" />.</param>
  510. /// <typeparam name="U">Argh!</typeparam>
  511. /// <typeparam name="V">Foo Argh!</typeparam>
  512. /// <remarks><c>M:Mono.DocTest.Generic.MyList`1.UseHelper``2(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2})</c>.</remarks>
  513. public void UseHelper<U,V> (Helper<U,V> helper) {}
  514. /// <remarks><c>M:Mono.DocTest.Generic.MyList`1.GetHelper``2</c>.</remarks>
  515. /// <returns><see langword="null" />.</returns>
  516. public Helper<U,V> GetHelper<U,V> () {return null;}
  517. /// <remarks><c>M:Mono.DocTest.MyList`1.System#Collections#GetEnumerator</c>.</remarks>
  518. IEnumerator IEnumerable.GetEnumerator () {return null;}
  519. /// <remarks><c>M:Mono.DocTest.MyList`1.GetEnumerator</c>.</remarks>
  520. public IEnumerator<int[]> GetEnumerator () {return null;}
  521. }
  522. /// <typeparam name="T">T generic param</typeparam>
  523. /// <remarks><c>T:Mono.DocTest.IFoo`1</c>.</remarks>
  524. public interface IFoo<T> {
  525. /// <typeparam name="U">U generic param</typeparam>
  526. /// <remarks><c>T:Mono.DocTest.IFoo`1.Method``1(`0,``0)</c>.</remarks>
  527. T Method <U> (T t, U u);
  528. }
  529. /// <typeparam name="A">Ako generic param</typeparam>
  530. /// <typeparam name="B">Bko generic param</typeparam>
  531. /// <remarks><c>T:Mono.DocTest.MyList`2</c>.</remarks>
  532. public class MyList<A,B> : GenericBase<Dictionary<A,B>>, IEnumerable<A>,
  533. IEnumerator<A>, ICollection<A>, IFoo<A>
  534. where A : class, IList<B>, new()
  535. where B : class, A
  536. {
  537. // IEnumerator
  538. // shown?
  539. object IEnumerator.Current {get {return null;}}
  540. /// <remarks><c>M:Mono.DocTest.MyList`2.MoveNext</c>.</remarks>
  541. /// <returns><see cref="T:System.Boolean" /></returns>
  542. public bool MoveNext () {return false;}
  543. /// <remarks><c>M:Mono.DocTest.MyList`2.Reset</c>.</remarks>
  544. public void Reset () {}
  545. // IDisposable
  546. /// <remarks><c>M:Mono.DocTest.MyList`2.Dispose</c>.</remarks>
  547. public void Dispose () {}
  548. // IEnumerator<T>
  549. /// <remarks><c>P:Mono.DocTest.MyList`2.Current</c>.</remarks>
  550. /// <value>The current value.</value>
  551. public A Current {get {return default(A);}}
  552. /// <remarks><c>P:Mono.DocTest.MyList`2.Current</c>.</remarks>
  553. /// <value>The current value.</value>
  554. A IEnumerator<A>.Current {get {return default(A);}}
  555. // IEnumerable
  556. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#GetEnumerator</c>.</remarks>
  557. IEnumerator IEnumerable.GetEnumerator () {return this;}
  558. // IEnumerable<T>
  559. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#IEnumerable{A}#GetEnumerator</c>.</remarks>
  560. /// <returns>A <see cref="T:System.Collections.Generic.IEnumerator{`0}" />.</returns>
  561. IEnumerator<A> IEnumerable<A>.GetEnumerator () {return this;}
  562. /// <remarks><c>M:Mono.DocTest.MyList`2.GetEnumerator</c>.</remarks>
  563. /// <returns>A <see cref="T:System.Collections.Generic.List{`0}.Enumerator" />.</returns>
  564. public List<A>.Enumerator GetEnumerator () {return new List<A>.Enumerator ();}
  565. // ICollection<T>
  566. /// <remarks><c>P:Mono.DocTest.MyList`2.Count</c>.</remarks>
  567. /// <value>A <see cref="T:System.Int32" />.</value>
  568. public int Count {get {return 0;}}
  569. /// <remarks><c>P:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#IsReadOnly</c>.</remarks>
  570. /// <value>A <see cref="T:System.Boolean" />.</value>
  571. bool ICollection<A>.IsReadOnly {get {return false;}}
  572. /// <param name="item">The item to add.</param>
  573. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Add(`0)</c>.</remarks>
  574. void ICollection<A>.Add (A item) {}
  575. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Clear</c>.</remarks>
  576. void ICollection<A>.Clear () {}
  577. /// <param name="item">The item to check for</param>
  578. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}.Contains(`0)</c>.</remarks>
  579. /// <returns>A <see cref="T:System.Boolean" /> instance (<see langword="false" />).</returns>
  580. bool ICollection<A>.Contains (A item) {return false;}
  581. /// <param name="array">Where to copy elements to</param>
  582. /// <param name="arrayIndex">Where to start copyingto</param>
  583. /// <remarks><c>M:Mono.DocTest.MyList`2.CopyTo(`0[],System.Int32)</c>.</remarks>
  584. public void CopyTo (A[] array, int arrayIndex) {}
  585. /// <param name="item">the item to remove</param>
  586. /// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Remove(`0)</c>.</remarks>
  587. /// <returns>Whether the item was removed.</returns>
  588. bool ICollection<A>.Remove (A item) {return false;}
  589. /// <remarks>M:Mono.DocTest.Generic.MyList`2.Foo</remarks>
  590. public KeyValuePair<IEnumerable<A>, IEnumerable<B>> Foo ()
  591. {
  592. return new KeyValuePair<IEnumerable<A>, IEnumerable<B>> ();
  593. }
  594. // IFoo members
  595. /// <typeparam name="U">U generic param on MyList`2</typeparam>
  596. /// <remarks><c>M:Mono.DocTest.Generic.MyList`2.Mono#DocTest#Generic#IFoo{A}#Method``1(`0,``0)</c>.</remarks>
  597. A IFoo<A>.Method <U> (A a, U u)
  598. {
  599. return default (A);
  600. }
  601. }
  602. }