PageRenderTime 67ms CodeModel.GetById 26ms RepoModel.GetById 1ms app.codeStats 0ms

/mcs/tests/gtest-etree-01.cs

https://bitbucket.org/steenlund/mono-2.6.7-for-amiga
C# | 2711 lines | 2283 code | 389 blank | 39 comment | 62 complexity | 450c281616aaa928b1015080e9858293 MD5 | raw file
Possible License(s): LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

  1. // Compiler options: -unsafe
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Linq.Expressions;
  6. using System.Reflection;
  7. public struct InverseLogicalOperator
  8. {
  9. bool value;
  10. public InverseLogicalOperator (bool value)
  11. {
  12. this.value = value;
  13. }
  14. public static bool operator true (InverseLogicalOperator u)
  15. {
  16. return u.value;
  17. }
  18. public static bool operator false (InverseLogicalOperator u)
  19. {
  20. return u.value;
  21. }
  22. }
  23. /* TODO: Add tests for every numeric expression where a type has only 1 implicit
  24. numeric conversion
  25. public struct MyType<T>
  26. {
  27. T value;
  28. public MyType (T value)
  29. {
  30. this.value = value;
  31. }
  32. public static implicit operator T (MyType<T> o)
  33. {
  34. return o.value;
  35. }
  36. }
  37. */
  38. // TODO: Create a clone which uses +(MyType, int) pattern and an implicit conversion
  39. // is required to do the user-conversion
  40. public struct MyType
  41. {
  42. int value;
  43. public MyType (int value) : this ()
  44. {
  45. this.value = value;
  46. }
  47. public short ShortProp { get; set; }
  48. public override int GetHashCode ()
  49. {
  50. throw new NotImplementedException ();
  51. }
  52. public static implicit operator int (MyType o)
  53. {
  54. return o.value;
  55. }
  56. public static bool operator true (MyType a)
  57. {
  58. return a.value == a;
  59. }
  60. public static bool operator false (MyType a)
  61. {
  62. return a.value != a;
  63. }
  64. public static MyType operator + (MyType a, MyType b)
  65. {
  66. return new MyType (a.value + b.value);
  67. }
  68. public static MyType operator - (MyType a, MyType b)
  69. {
  70. return new MyType (a.value - b.value);
  71. }
  72. public static MyType operator / (MyType a, MyType b)
  73. {
  74. return new MyType (a.value / b.value);
  75. }
  76. public static MyType operator * (MyType a, MyType b)
  77. {
  78. return new MyType (a.value * b.value);
  79. }
  80. public static MyType operator % (MyType a, MyType b)
  81. {
  82. return new MyType (a.value % b.value);
  83. }
  84. public static MyType operator &(MyType a, MyType b)
  85. {
  86. return new MyType (a.value & b.value);
  87. }
  88. public static MyType operator | (MyType a, MyType b)
  89. {
  90. return new MyType (a.value | b.value);
  91. }
  92. public static MyType operator ^ (MyType a, MyType b)
  93. {
  94. return new MyType (a.value ^ b.value);
  95. }
  96. public static bool operator == (MyType a, MyType b)
  97. {
  98. return a.value == b.value;
  99. }
  100. public static bool operator != (MyType a, MyType b)
  101. {
  102. return a.value != b.value;
  103. }
  104. public static bool operator > (MyType a, MyType b)
  105. {
  106. return a.value > b.value;
  107. }
  108. public static bool operator < (MyType a, MyType b)
  109. {
  110. return a.value < b.value;
  111. }
  112. public static bool operator >= (MyType a, MyType b)
  113. {
  114. return a.value >= b.value;
  115. }
  116. public static bool operator <= (MyType a, MyType b)
  117. {
  118. return a.value <= b.value;
  119. }
  120. public static bool operator ! (MyType a)
  121. {
  122. return a.value > 0;
  123. }
  124. public static int operator >> (MyType a, int b)
  125. {
  126. return a.value >> b;
  127. }
  128. public static int operator << (MyType a, int b)
  129. {
  130. return a.value << b;
  131. }
  132. public static MyType operator - (MyType a)
  133. {
  134. return new MyType (-a.value);
  135. }
  136. public static MyType operator + (MyType a)
  137. {
  138. return new MyType (+a.value);
  139. }
  140. public override string ToString ()
  141. {
  142. return value.ToString ();
  143. }
  144. }
  145. class MyTypeExplicit
  146. {
  147. int value;
  148. public MyTypeExplicit (int value)
  149. {
  150. this.value = value;
  151. }
  152. public static explicit operator int (MyTypeExplicit m)
  153. {
  154. return m.value;
  155. }
  156. }
  157. struct MyTypeImplicitOnly
  158. {
  159. short b;
  160. public MyTypeImplicitOnly (short b)
  161. {
  162. this.b = b;
  163. }
  164. public static implicit operator short (MyTypeImplicitOnly m)
  165. {
  166. return m.b;
  167. }
  168. }
  169. class MemberAccessData
  170. {
  171. public bool BoolValue;
  172. public static decimal DecimalValue = decimal.MinValue;
  173. public volatile uint VolatileValue;
  174. public string [] StringValues;
  175. public List<string> ListValues;
  176. event Func<bool> EventField;
  177. public Expression<Func<Func<bool>>> GetEvent ()
  178. {
  179. return () => EventField;
  180. }
  181. MyType mt;
  182. public MyType MyTypeProperty {
  183. set {
  184. mt = value;
  185. }
  186. get {
  187. return mt;
  188. }
  189. }
  190. public static string StaticProperty {
  191. get {
  192. return "alo";
  193. }
  194. }
  195. }
  196. enum MyEnum : byte
  197. {
  198. Value_1 = 1,
  199. Value_2 = 2
  200. }
  201. enum MyEnumUlong : ulong
  202. {
  203. Value_1 = 1
  204. }
  205. class NewTest<T>
  206. {
  207. T [] t;
  208. public NewTest (T i)
  209. {
  210. t = new T [] { i };
  211. }
  212. public NewTest (params T [] t)
  213. {
  214. this.t = t;
  215. }
  216. public override int GetHashCode ()
  217. {
  218. return base.GetHashCode ();
  219. }
  220. public override bool Equals (object obj)
  221. {
  222. NewTest<T> obj_t = obj as NewTest<T>;
  223. if (obj_t == null)
  224. return false;
  225. for (int i = 0; i < t.Length; ++i) {
  226. if (!t [i].Equals (obj_t.t [i]))
  227. return false;
  228. }
  229. return true;
  230. }
  231. }
  232. class Indexer
  233. {
  234. public int this [int i] { get { return i; } set { } }
  235. public string this [params string[] i] { get { return string.Concat (i); } }
  236. }
  237. // TODO: Add more nullable tests, follow AddTest pattern.
  238. class Tester
  239. {
  240. delegate void EmptyDelegate ();
  241. delegate int IntDelegate ();
  242. static void AssertNodeType (LambdaExpression e, ExpressionType et)
  243. {
  244. if (e.Body.NodeType != et)
  245. throw new ApplicationException (e.Body.NodeType + " != " + et);
  246. }
  247. static void Assert<T> (T expected, T value)
  248. {
  249. Assert (expected, value, null);
  250. }
  251. static void Assert<T> (T expected, T value, string name)
  252. {
  253. if (!EqualityComparer<T>.Default.Equals (expected, value)) {
  254. if (!string.IsNullOrEmpty (name))
  255. name += ": ";
  256. throw new ApplicationException (name + expected + " != " + value);
  257. }
  258. }
  259. static void Assert<T> (T [] expected, T [] value)
  260. {
  261. if (expected == null) {
  262. if (value != null)
  263. throw new ApplicationException ("Both arrays expected to be null");
  264. return;
  265. }
  266. if (expected.Length != value.Length)
  267. throw new ApplicationException ("Array length does not match " + expected.Length + " != " + value.Length);
  268. for (int i = 0; i < expected.Length; ++i) {
  269. if (!EqualityComparer<T>.Default.Equals (expected [i], value [i]))
  270. throw new ApplicationException ("Index " + i + ": " + expected [i] + " != " + value [i]);
  271. }
  272. }
  273. #pragma warning disable 169
  274. void AddTest ()
  275. {
  276. Expression<Func<int, int, int>> e = (int a, int b) => a + b;
  277. AssertNodeType (e, ExpressionType.Add);
  278. Assert (50, e.Compile ().Invoke (20, 30));
  279. }
  280. void AddTest_2 ()
  281. {
  282. Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
  283. AssertNodeType (e2, ExpressionType.Add);
  284. Assert (null, e2.Compile ().Invoke (null, 3));
  285. }
  286. void AddTest_3 ()
  287. {
  288. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
  289. AssertNodeType (e3, ExpressionType.Add);
  290. Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
  291. }
  292. void AddTest_4 ()
  293. {
  294. Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a + b;
  295. AssertNodeType (e4, ExpressionType.Add);
  296. Assert (new MyType (10), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
  297. Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
  298. }
  299. void AddTest_5 ()
  300. {
  301. Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a + b;
  302. AssertNodeType (e5, ExpressionType.Add);
  303. Assert (31, e5.Compile ().Invoke (1, new MyType (30)));
  304. }
  305. void AddTest_6 ()
  306. {
  307. Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a + b;
  308. AssertNodeType (e6, ExpressionType.Add);
  309. Assert (-1, e6.Compile ().Invoke (-31, new MyType (30)));
  310. }
  311. void AddTest_7 ()
  312. {
  313. Expression<Func<MyEnum, byte, MyEnum>> e7 = (a, b) => a + b;
  314. AssertNodeType (e7, ExpressionType.Convert);
  315. Assert (MyEnum.Value_2, e7.Compile ().Invoke (MyEnum.Value_1, 1));
  316. }
  317. void AddTest_8 ()
  318. {
  319. // CSC BUG: probably due to missing numeric promotion
  320. Expression<Func<MyEnum?, byte?, MyEnum?>> e8 = (a, b) => a + b;
  321. AssertNodeType (e8, ExpressionType.Convert);
  322. Assert<MyEnum?> (0, e8.Compile ().Invoke (MyEnum.Value_1, 255));
  323. Assert (null, e8.Compile ().Invoke (MyEnum.Value_1, null));
  324. Assert (null, e8.Compile ().Invoke (null, null));
  325. }
  326. void AddTest_9 ()
  327. {
  328. Expression<Func<byte, MyEnum, MyEnum>> e9 = (a, b) => a + b;
  329. AssertNodeType (e9, ExpressionType.Convert);
  330. Assert (MyEnum.Value_2, e9.Compile ().Invoke (1, MyEnum.Value_1));
  331. }
  332. void AddCheckedTest ()
  333. {
  334. checked {
  335. Expression<Func<int, int, int>> e = (int a, int b) => a + b;
  336. AssertNodeType (e, ExpressionType.AddChecked);
  337. Assert (50, e.Compile ().Invoke (20, 30));
  338. }
  339. }
  340. void AddCheckedTest_2 ()
  341. {
  342. checked {
  343. Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
  344. AssertNodeType (e2, ExpressionType.AddChecked);
  345. Assert (null, e2.Compile ().Invoke (null, 3));
  346. }
  347. }
  348. void AddCheckedTest_3 ()
  349. {
  350. checked {
  351. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
  352. AssertNodeType (e3, ExpressionType.Add);
  353. Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
  354. }
  355. }
  356. void AddStringTest ()
  357. {
  358. Expression<Func<string, string>> e6 = (a) => 1 + a;
  359. AssertNodeType (e6, ExpressionType.Add);
  360. Assert ("1to", e6.Compile ().Invoke ("to"));
  361. }
  362. void AddStringTest_2 ()
  363. {
  364. Expression<Func<object, string, string>> e7 = (object a, string b) => a + b;
  365. AssertNodeType (e7, ExpressionType.Add);
  366. Assert ("testme", e7.Compile ().Invoke ("test", "me"));
  367. Assert ("test", e7.Compile ().Invoke ("test", null));
  368. Assert ("", e7.Compile ().Invoke (null, null));
  369. }
  370. void AddStringTest_3 ()
  371. {
  372. Expression<Func<string, int, string>> e8 = (a, b) => a + " " + "-" + "> " + b;
  373. AssertNodeType (e8, ExpressionType.Add);
  374. Assert ("test -> 2", e8.Compile ().Invoke ("test", 2));
  375. }
  376. void AddStringTest_4 ()
  377. {
  378. Expression<Func<string, ushort?, string>> e9 = (a, b) => a + b;
  379. AssertNodeType (e9, ExpressionType.Add);
  380. Assert ("test2", e9.Compile ().Invoke ("test", 2));
  381. Assert ("test", e9.Compile ().Invoke ("test", null));
  382. }
  383. void AndTest ()
  384. {
  385. Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
  386. AssertNodeType (e, ExpressionType.And);
  387. Func<bool, bool, bool> c = e.Compile ();
  388. Assert (true, c (true, true));
  389. Assert (false, c (true, false));
  390. Assert (false, c (false, true));
  391. Assert (false, c (false, false));
  392. }
  393. void AndTest_2 ()
  394. {
  395. Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a & b;
  396. AssertNodeType (e2, ExpressionType.And);
  397. var c2 = e2.Compile ();
  398. Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
  399. Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
  400. }
  401. void AndTest_3 ()
  402. {
  403. Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a & b;
  404. AssertNodeType (e3, ExpressionType.Convert);
  405. Assert<MyEnum> (0, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
  406. Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  407. }
  408. void AndTest_4 ()
  409. {
  410. Expression<Func<int, int>> e = (a) => a & 0;
  411. AssertNodeType (e, ExpressionType.And);
  412. var c = e.Compile ();
  413. Assert (0, c (1));
  414. }
  415. void AndNullableTest ()
  416. {
  417. Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
  418. AssertNodeType (e, ExpressionType.And);
  419. Func<bool?, bool?, bool?> c = e.Compile ();
  420. Assert (true, c (true, true));
  421. Assert (false, c (true, false));
  422. Assert (false, c (false, true));
  423. Assert (false, c (false, false));
  424. Assert (null, c (true, null));
  425. Assert (false, c (false, null));
  426. Assert (false, c (null, false));
  427. Assert (null, c (true, null));
  428. Assert (null, c (null, null));
  429. }
  430. void AndNullableTest_2 ()
  431. {
  432. Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
  433. AssertNodeType (e2, ExpressionType.And);
  434. var c2 = e2.Compile ();
  435. Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
  436. Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
  437. Assert (null, c2 (new MyType (0xFF), null));
  438. }
  439. void AndNullableTest_3 ()
  440. {
  441. Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e3 = (a, b) => a & b;
  442. AssertNodeType (e3, ExpressionType.Convert);
  443. Assert (null, e3.Compile ().Invoke (null, MyEnum.Value_2));
  444. Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  445. }
  446. void AndAlsoTest ()
  447. {
  448. Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
  449. AssertNodeType (e, ExpressionType.AndAlso);
  450. Assert (false, e.Compile ().Invoke (true, false));
  451. }
  452. void AndAlsoTest_2 ()
  453. {
  454. Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a && b;
  455. AssertNodeType (e2, ExpressionType.AndAlso);
  456. Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
  457. Assert (new MyType (0), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
  458. }
  459. void AndAlsoTest_3 ()
  460. {
  461. Expression<Func<bool, bool>> e3 = (bool a) => a && true;
  462. AssertNodeType (e3, ExpressionType.AndAlso);
  463. Assert (false, e3.Compile ().Invoke (false));
  464. Assert (true, e3.Compile ().Invoke (true));
  465. }
  466. void ArrayIndexTest ()
  467. {
  468. Expression<Func<string [], long, string>> e = (string [] a, long i) => a [i];
  469. AssertNodeType (e, ExpressionType.ArrayIndex);
  470. Assert ("b", e.Compile ().Invoke (new string [] { "a", "b", "c" }, 1));
  471. }
  472. void ArrayIndexTest_2 ()
  473. {
  474. Expression<Func<string [], string>> e2 = (string [] a) => a [0];
  475. AssertNodeType (e2, ExpressionType.ArrayIndex);
  476. Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
  477. }
  478. void ArrayIndexTest_3 ()
  479. {
  480. Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
  481. AssertNodeType (e3, ExpressionType.Call);
  482. Assert ("z", e3.Compile ().Invoke (
  483. new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
  484. }
  485. void ArrayIndexTest_4 ()
  486. {
  487. Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
  488. AssertNodeType (e4, ExpressionType.ArrayIndex);
  489. decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
  490. Assert (90, e4.Compile ().Invoke (array, 1));
  491. }
  492. void ArrayIndexTest_5 ()
  493. {
  494. Expression<Func<int>> e5 = () => (new int [1]) [0];
  495. AssertNodeType (e5, ExpressionType.ArrayIndex);
  496. Assert (0, e5.Compile ().Invoke ());
  497. }
  498. void ArrayIndexTest_6 ()
  499. {
  500. const ulong max = 3;
  501. Expression<Func<int[], int>> e = a => a [max];
  502. AssertNodeType (e, ExpressionType.ArrayIndex);
  503. Assert (4, e.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }));
  504. }
  505. void ArrayIndexTest_7 ()
  506. {
  507. const ulong max = uint.MaxValue;
  508. Expression<Func<int[], int>> e = a => a [max];
  509. AssertNodeType (e, ExpressionType.ArrayIndex);
  510. try {
  511. e.Compile ().Invoke (new int [0]);
  512. throw new ApplicationException ("ArrayIndexTest_7");
  513. } catch (System.OverflowException) {
  514. // Check whether CheckedConversion was generated
  515. }
  516. }
  517. void ArrayLengthTest ()
  518. {
  519. Expression<Func<double [], int>> e = (double [] a) => a.Length;
  520. AssertNodeType (e, ExpressionType.ArrayLength);
  521. Assert (0, e.Compile ().Invoke (new double [0]));
  522. Assert (9, e.Compile ().Invoke (new double [9]));
  523. }
  524. void ArrayLengthTest_2 ()
  525. {
  526. Expression<Func<string [,], int>> e2 = (string [,] a) => a.Length;
  527. AssertNodeType (e2, ExpressionType.MemberAccess);
  528. Assert (0, e2.Compile ().Invoke (new string [0, 0]));
  529. }
  530. void CallTest ()
  531. {
  532. Expression<Func<int, int>> e = (int a) => Math.Max (a, 5);
  533. AssertNodeType (e, ExpressionType.Call);
  534. Assert (5, e.Compile ().Invoke (2));
  535. Assert (9, e.Compile ().Invoke (9));
  536. }
  537. void CallTest_2 ()
  538. {
  539. Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
  540. AssertNodeType (e2, ExpressionType.Call);
  541. Assert ("abc", e2.Compile ().Invoke ("abc"));
  542. }
  543. void CallTest_3 ()
  544. {
  545. Expression<Func<int, string, int, object>> e3 = (int index, string a, int b) => InstanceParamsMethod (index, a, b);
  546. AssertNodeType (e3, ExpressionType.Call);
  547. Assert<object> (4, e3.Compile ().Invoke (1, "a", 4));
  548. }
  549. void CallTest_4 ()
  550. {
  551. Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
  552. AssertNodeType (e4, ExpressionType.Call);
  553. Assert<object> ("<empty>", e4.Compile ().Invoke ());
  554. }
  555. void CallTest_5 ()
  556. {
  557. Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
  558. AssertNodeType (e5, ExpressionType.Call);
  559. Assert (5, e5.Compile ().Invoke (5));
  560. }
  561. void CallTest_6 ()
  562. {
  563. Expression<Action> e6 = () => Console.WriteLine ("call test");
  564. AssertNodeType (e6, ExpressionType.Call);
  565. }
  566. void CallTest_7 ()
  567. {
  568. Expression<Func<Indexer, int, int>> e7 = (a, b) => a [b];
  569. AssertNodeType (e7, ExpressionType.Call);
  570. Assert (3, e7.Compile ().Invoke (new Indexer (), 3));
  571. }
  572. void CallTest_8 ()
  573. {
  574. Expression<Func<Indexer, string, string, string, string>> e8 = (a, b, c , d) => a [b, c, d];
  575. AssertNodeType (e8, ExpressionType.Call);
  576. Assert ("zyb", e8.Compile ().Invoke (new Indexer (), "z", "y", "b"));
  577. }
  578. void CallTest_9 ()
  579. {
  580. Expression<Action<int>> e9 = (a) => RefMethod (ref a);
  581. AssertNodeType (e9, ExpressionType.Call);
  582. e9.Compile ().Invoke (1);
  583. }
  584. void CoalesceTest ()
  585. {
  586. Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
  587. AssertNodeType (e, ExpressionType.Coalesce);
  588. var r = e.Compile ();
  589. Assert ((uint) 5, r.Invoke (5));
  590. Assert ((uint) 99, r.Invoke (null));
  591. }
  592. void CoalesceTest_2 ()
  593. {
  594. Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
  595. AssertNodeType (e2, ExpressionType.Coalesce);
  596. var r2 = e2.Compile ();
  597. Assert (2, r2.Invoke (new MyType (2)));
  598. Assert (-3, r2.Invoke (null));
  599. }
  600. void ConditionTest ()
  601. {
  602. Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
  603. AssertNodeType (e, ExpressionType.Conditional);
  604. var r = e.Compile ();
  605. Assert (3, r.Invoke (true, 3, 999999));
  606. Assert (999999, r.Invoke (false, 3, 999999));
  607. }
  608. void ConditionTest_2 ()
  609. {
  610. Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
  611. AssertNodeType (e2, ExpressionType.Conditional);
  612. var r2 = e2.Compile ();
  613. Assert (null, r2.Invoke (0, 10));
  614. Assert (50, r2.Invoke (1, 50));
  615. Assert (30, r2.Invoke (-7, -30));
  616. }
  617. void ConditionTest_3 ()
  618. {
  619. Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
  620. AssertNodeType (e3, ExpressionType.Convert);
  621. var r3 = e3.Compile ();
  622. Assert (3, r3.Invoke (true));
  623. Assert (-2, r3.Invoke (false));
  624. }
  625. void ConditionTest_4 ()
  626. {
  627. Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
  628. AssertNodeType (e4, ExpressionType.Conditional);
  629. var r4 = e4.Compile ();
  630. Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
  631. Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
  632. }
  633. void ConditionTest_5 ()
  634. {
  635. // CSC bug ?
  636. Expression<Func<int>> e = () => false ? 1 : 4;
  637. AssertNodeType (e, ExpressionType.Conditional);
  638. var r = e.Compile ();
  639. Assert (4, r.Invoke ());
  640. }
  641. void ConstantTest ()
  642. {
  643. Expression<Func<int>> e1 = () => default (int);
  644. AssertNodeType (e1, ExpressionType.Constant);
  645. Assert (0, e1.Compile ().Invoke ());
  646. }
  647. void ConstantTest_2 ()
  648. {
  649. Expression<Func<int?>> e2 = () => default (int?);
  650. AssertNodeType (e2, ExpressionType.Constant);
  651. Assert (null, e2.Compile ().Invoke ());
  652. }
  653. void ConstantTest_3 ()
  654. {
  655. Expression<Func<Tester>> e3 = () => default (Tester);
  656. AssertNodeType (e3, ExpressionType.Constant);
  657. Assert (null, e3.Compile ().Invoke ());
  658. }
  659. void ConstantTest_4 ()
  660. {
  661. Expression<Func<object>> e4 = () => null;
  662. AssertNodeType (e4, ExpressionType.Constant);
  663. Assert (null, e4.Compile ().Invoke ());
  664. }
  665. void ConstantTest_5 ()
  666. {
  667. Expression<Func<int>> e5 = () => 8 / 4;
  668. AssertNodeType (e5, ExpressionType.Constant);
  669. Assert (2, e5.Compile ().Invoke ());
  670. }
  671. void ConstantTest_6 ()
  672. {
  673. Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
  674. AssertNodeType (e6, ExpressionType.Constant);
  675. Assert (0xFFFFFF, e6.Compile ().Invoke ());
  676. }
  677. void ConstantTest_7 ()
  678. {
  679. Expression<Func<object>> e7 = () => "Alleluia";
  680. AssertNodeType (e7, ExpressionType.Constant);
  681. Assert ("Alleluia", e7.Compile ().Invoke ());
  682. }
  683. void ConstantTest_8 ()
  684. {
  685. Expression<Func<Type>> e8 = () => typeof (int);
  686. AssertNodeType (e8, ExpressionType.Constant);
  687. Assert (typeof (int), e8.Compile ().Invoke ());
  688. }
  689. void ConstantTest_9 ()
  690. {
  691. Expression<Func<Type>> e9 = () => typeof (void);
  692. AssertNodeType (e9, ExpressionType.Constant);
  693. Assert (typeof (void), e9.Compile ().Invoke ());
  694. }
  695. void ConstantTest_10 ()
  696. {
  697. Expression<Func<Type>> e10 = () => typeof (Func<,>);
  698. AssertNodeType (e10, ExpressionType.Constant);
  699. Assert (typeof (Func<,>), e10.Compile ().Invoke ());
  700. }
  701. void ConstantTest_11 ()
  702. {
  703. Expression<Func<MyEnum>> e11 = () => MyEnum.Value_2;
  704. AssertNodeType (e11, ExpressionType.Constant);
  705. Assert (MyEnum.Value_2, e11.Compile ().Invoke ());
  706. }
  707. void ConstantTest_13 ()
  708. {
  709. Expression<Func<int>> e13 = () => sizeof (byte);
  710. AssertNodeType (e13, ExpressionType.Constant);
  711. Assert (1, e13.Compile ().Invoke ());
  712. }
  713. unsafe void ConstantTest_14 ()
  714. {
  715. Expression<Func<Type>> e14 = () => typeof (bool*);
  716. AssertNodeType (e14, ExpressionType.Constant);
  717. Assert (typeof (bool*), e14.Compile ().Invoke ());
  718. }
  719. void ConstantTest_15 ()
  720. {
  721. Expression<Func<int?>> e15 = () => null;
  722. AssertNodeType (e15, ExpressionType.Constant);
  723. Assert (null, e15.Compile ().Invoke ());
  724. }
  725. void ConvertTest ()
  726. {
  727. Expression<Func<int, byte>> e = (int a) => ((byte) a);
  728. AssertNodeType (e, ExpressionType.Convert);
  729. Assert (100, e.Compile ().Invoke (100));
  730. }
  731. void ConvertTest_2 ()
  732. {
  733. Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
  734. AssertNodeType (e2, ExpressionType.Convert);
  735. Assert (100, e2.Compile ().Invoke (100));
  736. }
  737. void ConvertTest_3 ()
  738. {
  739. Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
  740. AssertNodeType (e3, ExpressionType.Convert);
  741. Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
  742. }
  743. void ConvertTest_4 ()
  744. {
  745. Expression<Func<MyType, int>> e4 = (MyType a) => (a);
  746. AssertNodeType (e4, ExpressionType.Convert);
  747. Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
  748. }
  749. void ConvertTest_5 ()
  750. {
  751. Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
  752. AssertNodeType (e5, ExpressionType.Convert);
  753. }
  754. void ConvertTest_6 ()
  755. {
  756. Expression<Func<MyType?, MyType?, bool?>> e6 = (MyType? a, MyType? b) => a == b;
  757. AssertNodeType (e6, ExpressionType.Convert);
  758. Assert (false, e6.Compile ().Invoke (null, new MyType (-20)));
  759. Assert (true, e6.Compile ().Invoke (null, null));
  760. Assert (true, e6.Compile ().Invoke (new MyType (120), new MyType (120)));
  761. }
  762. void ConvertTest_7 ()
  763. {
  764. Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
  765. AssertNodeType (e7, ExpressionType.Convert);
  766. Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
  767. }
  768. void ConvertTest_8 ()
  769. {
  770. Expression<Func<int?, object>> e8 = x => (object)x;
  771. AssertNodeType (e8, ExpressionType.Convert);
  772. Assert (null, e8.Compile ().Invoke (null));
  773. Assert (-100, e8.Compile ().Invoke (-100));
  774. }
  775. unsafe void ConvertTest_9 ()
  776. {
  777. int*[] p = new int* [1];
  778. Expression<Func<object>> e9 = () => (object)p;
  779. AssertNodeType (e9, ExpressionType.Convert);
  780. Assert (p, e9.Compile ().Invoke ());
  781. }
  782. void ConvertTest_10 ()
  783. {
  784. Expression<Func<Func<int>, Delegate>> e10 = (a) => a + a;
  785. AssertNodeType (e10, ExpressionType.Convert);
  786. Assert (null, e10.Compile ().Invoke (null));
  787. Assert (new Func<int> (TestInt) + new Func<int> (TestInt), e10.Compile ().Invoke (TestInt));
  788. }
  789. void ConvertTest_11 ()
  790. {
  791. Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
  792. AssertNodeType (e11, ExpressionType.Convert);
  793. Assert (null, e11.Compile ().Invoke (null));
  794. }
  795. void ConvertTest_12 ()
  796. {
  797. Expression<Func<Func<int>>> e12 = () => TestInt;
  798. AssertNodeType (e12, ExpressionType.Convert);
  799. Assert (29, e12.Compile ().Invoke () ());
  800. }
  801. void ConvertTest_13 ()
  802. {
  803. Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
  804. AssertNodeType (e13, ExpressionType.Convert);
  805. Assert (6, e13.Compile ().Invoke (6));
  806. }
  807. void ConvertTest_14 ()
  808. {
  809. Expression<Func<long, decimal>> e14 = a => a;
  810. AssertNodeType (e14, ExpressionType.Convert);
  811. Assert (-66, e14.Compile ().Invoke (-66));
  812. }
  813. void ConvertTest_15 ()
  814. {
  815. Expression<Func<ulong?, decimal?>> e15 = a => a;
  816. AssertNodeType (e15, ExpressionType.Convert);
  817. Assert (null, e15.Compile ().Invoke (null));
  818. Assert (9, e15.Compile ().Invoke (9));
  819. }
  820. void ConvertCheckedTest ()
  821. {
  822. Expression<Func<int, byte>> e = (int a) => checked((byte) a);
  823. AssertNodeType (e, ExpressionType.ConvertChecked);
  824. Assert (100, e.Compile ().Invoke (100));
  825. }
  826. void ConvertCheckedTest_2 ()
  827. {
  828. checked {
  829. Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
  830. AssertNodeType (e2, ExpressionType.Convert);
  831. Assert (100, e2.Compile ().Invoke (100));
  832. }
  833. }
  834. void ConvertCheckedTest_3 ()
  835. {
  836. checked {
  837. Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
  838. AssertNodeType (e3, ExpressionType.ConvertChecked);
  839. Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
  840. }
  841. }
  842. void ConvertCheckedTest_4 ()
  843. {
  844. checked {
  845. Expression<Func<MyType, int>> e4 = (MyType a) => (a);
  846. AssertNodeType (e4, ExpressionType.Convert);
  847. Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
  848. }
  849. }
  850. void DivideTest ()
  851. {
  852. Expression<Func<int, int, int>> e = (int a, int b) => a / b;
  853. AssertNodeType (e, ExpressionType.Divide);
  854. Assert (2, e.Compile ().Invoke (60, 30));
  855. }
  856. void DivideTest_2 ()
  857. {
  858. Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
  859. AssertNodeType (e2, ExpressionType.Divide);
  860. Assert (null, e2.Compile ().Invoke (null, 3));
  861. Assert (1.5, e2.Compile ().Invoke (3, 2));
  862. }
  863. void DivideTest_3 ()
  864. {
  865. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
  866. AssertNodeType (e3, ExpressionType.Divide);
  867. Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  868. }
  869. void DivideTest_4 ()
  870. {
  871. Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
  872. AssertNodeType (e4, ExpressionType.Divide);
  873. Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
  874. Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  875. }
  876. void DivideTest_5 ()
  877. {
  878. Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a / b;
  879. AssertNodeType (e5, ExpressionType.Divide);
  880. Assert (50, e5.Compile ().Invoke (100, new MyType (2)));
  881. }
  882. void DivideTest_6 ()
  883. {
  884. Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a / b;
  885. AssertNodeType (e6, ExpressionType.Divide);
  886. Assert (50, e6.Compile ().Invoke (100, new MyType (2)));
  887. Assert (null, e6.Compile ().Invoke (20, null));
  888. }
  889. void EqualTest ()
  890. {
  891. Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
  892. AssertNodeType (e, ExpressionType.Equal);
  893. Assert (false, e.Compile ().Invoke (60, 30));
  894. Assert (true, e.Compile ().Invoke (-1, -1));
  895. }
  896. void EqualTest_2 ()
  897. {
  898. Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
  899. AssertNodeType (e2, ExpressionType.Equal);
  900. Assert (true, e2.Compile ().Invoke (3, 3));
  901. Assert (false, e2.Compile ().Invoke (3, 2));
  902. }
  903. void EqualTest_3 ()
  904. {
  905. Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
  906. AssertNodeType (e3, ExpressionType.Equal);
  907. Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  908. }
  909. void EqualTest_4 ()
  910. {
  911. Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
  912. AssertNodeType (e4, ExpressionType.Equal);
  913. Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
  914. Assert (true, e4.Compile ().Invoke (null, null));
  915. Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
  916. }
  917. void EqualTest_5 ()
  918. {
  919. Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a == b;
  920. AssertNodeType (e5, ExpressionType.Equal);
  921. Assert (false, e5.Compile ().Invoke (true, null));
  922. Assert (true, e5.Compile ().Invoke (null, null));
  923. Assert (true, e5.Compile ().Invoke (false, false));
  924. }
  925. void EqualTest_6 ()
  926. {
  927. Expression<Func<bool, bool>> e6 = (bool a) => a == null;
  928. AssertNodeType (e6, ExpressionType.Equal);
  929. Assert (false, e6.Compile ().Invoke (true));
  930. Assert (false, e6.Compile ().Invoke (false));
  931. }
  932. void EqualTest_7 ()
  933. {
  934. Expression<Func<string, string, bool>> e7 = (string a, string b) => a == b;
  935. AssertNodeType (e7, ExpressionType.Equal);
  936. Assert (true, e7.Compile ().Invoke (null, null));
  937. Assert (false, e7.Compile ().Invoke ("a", "A"));
  938. Assert (true, e7.Compile ().Invoke ("a", "a"));
  939. }
  940. void EqualTest_8 ()
  941. {
  942. Expression<Func<object, bool>> e8 = (object a) => null == a;
  943. AssertNodeType (e8, ExpressionType.Equal);
  944. Assert (true, e8.Compile ().Invoke (null));
  945. Assert (false, e8.Compile ().Invoke ("a"));
  946. Assert (false, e8.Compile ().Invoke (this));
  947. }
  948. void EqualTest_9 ()
  949. {
  950. Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a == b;
  951. AssertNodeType (e9, ExpressionType.Equal);
  952. Assert (false, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
  953. Assert (true, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  954. }
  955. void EqualTest_10 ()
  956. {
  957. Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a == b;
  958. AssertNodeType (e10, ExpressionType.Equal);
  959. Assert (false, e10.Compile ().Invoke (MyEnum.Value_1, null));
  960. Assert (true, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  961. }
  962. void EqualTest_11 ()
  963. {
  964. Expression<Func<MyEnum?, bool>> e11 = (a) => a == null;
  965. AssertNodeType (e11, ExpressionType.Equal);
  966. Assert (false, e11.Compile ().Invoke (MyEnum.Value_1));
  967. Assert (true, e11.Compile ().Invoke (null));
  968. }
  969. void EqualTest_12 ()
  970. {
  971. Expression<Func<MyEnumUlong, bool>> e12 = (a) => a == 0;
  972. AssertNodeType (e12, ExpressionType.Equal);
  973. Assert (false, e12.Compile ().Invoke (MyEnumUlong.Value_1));
  974. Assert (true, e12.Compile ().Invoke (0));
  975. }
  976. void EqualTest_13 ()
  977. {
  978. Expression<Func<MyEnum, bool>> e13 = (a) => a == MyEnum.Value_2;
  979. AssertNodeType (e13, ExpressionType.Equal);
  980. Assert (true, e13.Compile ().Invoke (MyEnum.Value_2));
  981. Assert (false, e13.Compile ().Invoke (0));
  982. }
  983. void EqualTest_14 ()
  984. {
  985. Expression<Func<MyEnum, bool>> e = (a) => a == null;
  986. AssertNodeType (e, ExpressionType.Equal);
  987. Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
  988. }
  989. void EqualTest_15 ()
  990. {
  991. Expression<Func<int?, uint, bool>> e = (a, b) => a == b;
  992. AssertNodeType (e, ExpressionType.Equal);
  993. Assert (false, e.Compile ().Invoke (null, 0));
  994. Assert (true, e.Compile ().Invoke (4, 4));
  995. }
  996. void EqualTestDelegate ()
  997. {
  998. Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
  999. AssertNodeType (e1, ExpressionType.Equal);
  1000. Assert (true, e1.Compile ().Invoke (null, null));
  1001. }
  1002. void EqualTestDelegate_2 ()
  1003. {
  1004. EmptyDelegate ed = delegate () {};
  1005. Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
  1006. AssertNodeType (e2, ExpressionType.Equal);
  1007. Assert (false, e2.Compile ().Invoke (delegate () {}, null));
  1008. Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
  1009. Assert (false, e2.Compile ().Invoke (ed, delegate {}));
  1010. Assert (true, e2.Compile ().Invoke (ed, ed));
  1011. }
  1012. void ExclusiveOrTest ()
  1013. {
  1014. Expression<Func<int, short, int>> e = (int a, short b) => a ^ b;
  1015. AssertNodeType (e, ExpressionType.ExclusiveOr);
  1016. Assert (34, e.Compile ().Invoke (60, 30));
  1017. }
  1018. void ExclusiveOrTest_2 ()
  1019. {
  1020. Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
  1021. AssertNodeType (e2, ExpressionType.ExclusiveOr);
  1022. Assert (null, e2.Compile ().Invoke (null, 3));
  1023. Assert (1, e2.Compile ().Invoke (3, 2));
  1024. }
  1025. void ExclusiveOrTest_3 ()
  1026. {
  1027. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
  1028. AssertNodeType (e3, ExpressionType.ExclusiveOr);
  1029. Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1030. }
  1031. void ExclusiveOrTest_4 ()
  1032. {
  1033. Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
  1034. AssertNodeType (e4, ExpressionType.ExclusiveOr);
  1035. Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
  1036. Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  1037. }
  1038. void ExclusiveOrTest_5 ()
  1039. {
  1040. Expression<Func<MyType?, byte, int?>> e5 = (MyType? a, byte b) => a ^ b;
  1041. AssertNodeType (e5, ExpressionType.ExclusiveOr);
  1042. Assert (null, e5.Compile ().Invoke (null, 64));
  1043. Assert (96, e5.Compile ().Invoke (new MyType (64), 32));
  1044. }
  1045. void ExclusiveOrTest_6 ()
  1046. {
  1047. Expression<Func<MyEnum, MyEnum, MyEnum>> e6 = (a, b) => a ^ b;
  1048. AssertNodeType (e6, ExpressionType.Convert);
  1049. Assert ((MyEnum)3, e6.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
  1050. Assert<MyEnum> (0, e6.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1051. }
  1052. void ExclusiveOrTest_7 ()
  1053. {
  1054. Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e7 = (a, b) => a ^ b;
  1055. AssertNodeType (e7, ExpressionType.Convert);
  1056. Assert (null, e7.Compile ().Invoke (MyEnum.Value_1, null));
  1057. Assert<MyEnum?> (0, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1058. }
  1059. void ExclusiveOrTest_8 ()
  1060. {
  1061. Expression<Func<MyEnum?, MyEnum?>> e8 = (a) => a ^ null;
  1062. AssertNodeType (e8, ExpressionType.Convert);
  1063. Assert (null, e8.Compile ().Invoke (MyEnum.Value_1));
  1064. Assert (null, e8.Compile ().Invoke (null));
  1065. }
  1066. void GreaterThanTest ()
  1067. {
  1068. Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
  1069. AssertNodeType (e, ExpressionType.GreaterThan);
  1070. Assert (true, e.Compile ().Invoke (60, 30));
  1071. }
  1072. void GreaterThanTest_2 ()
  1073. {
  1074. Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
  1075. AssertNodeType (e2, ExpressionType.GreaterThan);
  1076. Assert (false, e2.Compile ().Invoke (null, 3));
  1077. Assert (false, e2.Compile ().Invoke (2, 2));
  1078. }
  1079. void GreaterThanTest_3 ()
  1080. {
  1081. Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
  1082. AssertNodeType (e3, ExpressionType.GreaterThan);
  1083. Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1084. }
  1085. void GreaterThanTest_4 ()
  1086. {
  1087. Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
  1088. AssertNodeType (e4, ExpressionType.GreaterThan);
  1089. Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
  1090. Assert (false, e4.Compile ().Invoke (null, null));
  1091. Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  1092. }
  1093. void GreaterThanTest_5 ()
  1094. {
  1095. Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a > b;
  1096. AssertNodeType (e5, ExpressionType.GreaterThan);
  1097. Assert (false, e5.Compile ().Invoke (null, 33));
  1098. Assert (false, e5.Compile ().Invoke (null, 0));
  1099. Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
  1100. }
  1101. void GreaterThanTest_6 ()
  1102. {
  1103. Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
  1104. AssertNodeType (e6, ExpressionType.GreaterThan);
  1105. Assert (false, e6.Compile ().Invoke (60));
  1106. }
  1107. void GreaterThanTest_7 ()
  1108. {
  1109. Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a > b;
  1110. AssertNodeType (e7, ExpressionType.GreaterThan);
  1111. Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
  1112. Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1113. }
  1114. void GreaterThanTest_8 ()
  1115. {
  1116. Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a > b;
  1117. AssertNodeType (e8, ExpressionType.GreaterThan);
  1118. Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
  1119. Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1120. }
  1121. void GreaterThanOrEqualTest ()
  1122. {
  1123. Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
  1124. AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
  1125. Assert (true, e.Compile ().Invoke (60, 30));
  1126. }
  1127. void GreaterThanOrEqualTest_2 ()
  1128. {
  1129. Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
  1130. AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
  1131. Assert (false, e2.Compile ().Invoke (null, 3));
  1132. Assert (true, e2.Compile ().Invoke (2, 2));
  1133. }
  1134. void GreaterThanOrEqualTest_3 ()
  1135. {
  1136. Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
  1137. AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
  1138. Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
  1139. }
  1140. void GreaterThanOrEqualTest_4 ()
  1141. {
  1142. Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= b;
  1143. AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
  1144. Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
  1145. Assert (false, e4.Compile ().Invoke (null, null));
  1146. Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  1147. }
  1148. void GreaterThanOrEqualTest_5 ()
  1149. {
  1150. Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a >= b;
  1151. AssertNodeType (e5, ExpressionType.GreaterThanOrEqual);
  1152. Assert (false, e5.Compile ().Invoke (null, 33));
  1153. Assert (false, e5.Compile ().Invoke (null, 0));
  1154. Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
  1155. }
  1156. void GreaterThanOrEqualTest_6 ()
  1157. {
  1158. Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
  1159. AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
  1160. Assert (false, e6.Compile ().Invoke (60));
  1161. }
  1162. void GreaterThanOrEqualTest_7 ()
  1163. {
  1164. Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a >= b;
  1165. AssertNodeType (e7, ExpressionType.GreaterThanOrEqual);
  1166. Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
  1167. Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1168. }
  1169. void GreaterThanOrEqualTest_8 ()
  1170. {
  1171. Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a >= b;
  1172. AssertNodeType (e8, ExpressionType.GreaterThanOrEqual);
  1173. Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
  1174. Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1175. }
  1176. void InvokeTest ()
  1177. {
  1178. var del = new IntDelegate (TestInt);
  1179. Expression<Func<IntDelegate, int>> e = (a) => a ();
  1180. AssertNodeType (e, ExpressionType.Invoke);
  1181. Assert (29, e.Compile ().Invoke (del));
  1182. }
  1183. void InvokeTest_2 ()
  1184. {
  1185. Expression<Func<Func<int, string>, int, string>> e2 = (a, b) => a (b);
  1186. AssertNodeType (e2, ExpressionType.Invoke);
  1187. Assert ("4", e2.Compile ().Invoke ((a) => (a+1).ToString (), 3));
  1188. }
  1189. void LambdaTest ()
  1190. {
  1191. Expression<Func<string, Func<string>>> e = (string s) => () => s;
  1192. AssertNodeType (e, ExpressionType.Lambda);
  1193. Assert ("xx", e.Compile ().Invoke ("xx") ());
  1194. }
  1195. void LeftShiftTest ()
  1196. {
  1197. Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a << b;
  1198. AssertNodeType (e, ExpressionType.LeftShift);
  1199. Assert ((ulong) 0x7F000, e.Compile ().Invoke (0xFE, 11));
  1200. Assert ((ulong) 0x1FFFFFFFE, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
  1201. // .net produces a strange result
  1202. // see https://bugzilla.novell.com/show_bug.cgi?id=398358
  1203. // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
  1204. }
  1205. void LeftShiftTest_2 ()
  1206. {
  1207. Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a << b;
  1208. AssertNodeType (e2, ExpressionType.LeftShift);
  1209. var c2 = e2.Compile ();
  1210. Assert (1024, c2 (new MyType (256), new MyType (2)));
  1211. }
  1212. void LeftShiftTest_3 ()
  1213. {
  1214. Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a << b;
  1215. AssertNodeType (e3, ExpressionType.LeftShift);
  1216. Assert (null, e3.Compile ().Invoke (null, 11));
  1217. Assert (2048, e3.Compile ().Invoke (1024, 1));
  1218. }
  1219. void LeftShiftTest_4 ()
  1220. {
  1221. Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a << b;
  1222. AssertNodeType (e4, ExpressionType.LeftShift);
  1223. var c4 = e4.Compile ();
  1224. Assert (null, c4 (new MyType (8), null));
  1225. Assert (null, c4 (null, new MyType (8)));
  1226. Assert (1024, c4 (new MyType (256), new MyType (2)));
  1227. }
  1228. void LeftShiftTest_5 ()
  1229. {
  1230. Expression<Func<ushort, int?>> e5 = (ushort a) => a << null;
  1231. AssertNodeType (e5, ExpressionType.LeftShift);
  1232. Assert (null, e5.Compile ().Invoke (30));
  1233. }
  1234. void LessThanTest ()
  1235. {
  1236. Expression<Func<int, int, bool>> e = (int a, int b) => a < b;
  1237. AssertNodeType (e, ExpressionType.LessThan);
  1238. Assert (false, e.Compile ().Invoke (60, 30));
  1239. }
  1240. void LessThanTest_2 ()
  1241. {
  1242. Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a < b;
  1243. AssertNodeType (e2, ExpressionType.LessThan);
  1244. Assert (false, e2.Compile ().Invoke (null, 3));
  1245. Assert (false, e2.Compile ().Invoke (2, 2));
  1246. }
  1247. void LessThanTest_3 ()
  1248. {
  1249. Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a < b;
  1250. AssertNodeType (e3, ExpressionType.LessThan);
  1251. Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1252. }
  1253. void LessThanTest_4 ()
  1254. {
  1255. Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a < b;
  1256. AssertNodeType (e4, ExpressionType.LessThan);
  1257. Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
  1258. Assert (false, e4.Compile ().Invoke (null, null));
  1259. Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  1260. }
  1261. void LessThanTest_5 ()
  1262. {
  1263. Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a < b;
  1264. AssertNodeType (e5, ExpressionType.LessThan);
  1265. Assert (false, e5.Compile ().Invoke (null, 33));
  1266. Assert (false, e5.Compile ().Invoke (null, 0));
  1267. Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
  1268. }
  1269. void LessThanTest_6 ()
  1270. {
  1271. Expression<Func<ushort, bool>> e6 = (ushort a) => a < null;
  1272. AssertNodeType (e6, ExpressionType.LessThan);
  1273. Assert (false, e6.Compile ().Invoke (60));
  1274. }
  1275. void LessThanTest_7 ()
  1276. {
  1277. Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a < b;
  1278. AssertNodeType (e7, ExpressionType.LessThan);
  1279. Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
  1280. Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1281. }
  1282. void LessThanTest_8 ()
  1283. {
  1284. Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a < b;
  1285. AssertNodeType (e8, ExpressionType.LessThan);
  1286. Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
  1287. Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1288. }
  1289. void LessThanOrEqualTest ()
  1290. {
  1291. Expression<Func<int, int, bool>> e = (int a, int b) => a <= b;
  1292. AssertNodeType (e, ExpressionType.LessThanOrEqual);
  1293. Assert (false, e.Compile ().Invoke (60, 30));
  1294. }
  1295. void LessThanOrEqualTest_2 ()
  1296. {
  1297. Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a <= b;
  1298. AssertNodeType (e2, ExpressionType.LessThanOrEqual);
  1299. Assert (false, e2.Compile ().Invoke (null, 3));
  1300. Assert (true, e2.Compile ().Invoke (2, 2));
  1301. }
  1302. void LessThanOrEqualTest_3 ()
  1303. {
  1304. Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a <= b;
  1305. AssertNodeType (e3, ExpressionType.LessThanOrEqual);
  1306. Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1307. }
  1308. void LessThanOrEqualTest_4 ()
  1309. {
  1310. Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a <= b;
  1311. AssertNodeType (e4, ExpressionType.LessThanOrEqual);
  1312. Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
  1313. Assert (false, e4.Compile ().Invoke (null, null));
  1314. Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
  1315. }
  1316. void LessThanOrEqualTest_5 ()
  1317. {
  1318. Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a <= b;
  1319. AssertNodeType (e5, ExpressionType.LessThanOrEqual);
  1320. Assert (false, e5.Compile ().Invoke (null, 33));
  1321. Assert (false, e5.Compile ().Invoke (null, 0));
  1322. Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
  1323. }
  1324. void LessThanOrEqualTest_6 ()
  1325. {
  1326. Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
  1327. AssertNodeType (e6, ExpressionType.LessThanOrEqual);
  1328. Assert (false, e6.Compile ().Invoke (60));
  1329. }
  1330. void LessThanOrEqualTest_7 ()
  1331. {
  1332. Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a <= b;
  1333. AssertNodeType (e7, ExpressionType.LessThanOrEqual);
  1334. Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
  1335. Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1336. }
  1337. void LessThanOrEqualTest_8 ()
  1338. {
  1339. Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a <= b;
  1340. AssertNodeType (e8, ExpressionType.LessThanOrEqual);
  1341. Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
  1342. Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
  1343. }
  1344. void ListInitTest ()
  1345. {
  1346. Expression<Func<List<object>>> e1 = () => new List<object> { "Hello", "", null, "World", 5 };
  1347. AssertNodeType (e1, ExpressionType.ListInit);
  1348. var re1 = e1.Compile ().Invoke ();
  1349. Assert (null, re1 [2]);
  1350. Assert ("World", re1 [3]);
  1351. Assert (5, re1 [4]);
  1352. }
  1353. void ListInitTest_2 ()
  1354. {
  1355. Expression<Func<int, Dictionary<string, int>>> e2 = (int value) => new Dictionary<string, int> (3) { { "A", value }, { "B", 2 } };
  1356. AssertNodeType (e2, ExpressionType.ListInit);
  1357. var re2 = e2.Compile ().Invoke (3456);
  1358. Assert (3456, re2 ["A"]);
  1359. }
  1360. void MemberAccessTest ()
  1361. {
  1362. MemberAccessData d = new MemberAccessData ();
  1363. d.BoolValue = true;
  1364. Expression<Func<bool>> e = () => d.BoolValue;
  1365. AssertNodeType (e, ExpressionType.MemberAccess);
  1366. Assert (true, e.Compile ().Invoke ());
  1367. d.BoolValue = false;
  1368. Assert (false, e.Compile ().Invoke ());
  1369. }
  1370. void MemberAccessTest_2 ()
  1371. {
  1372. Expression<Func<decimal>> e2 = () => MemberAccessData.DecimalValue;
  1373. AssertNodeType (e2, ExpressionType.MemberAccess);
  1374. Assert (decimal.MinValue, e2.Compile ().Invoke ());
  1375. }
  1376. void MemberAccessTest_3 ()
  1377. {
  1378. MemberAccessData d = new MemberAccessData ();
  1379. d.VolatileValue = 492;
  1380. Expression<Func<uint>> e3 = () => d.VolatileValue;
  1381. AssertNodeType (e3, ExpressionType.MemberAccess);
  1382. Assert<uint> (492, e3.Compile ().Invoke ());
  1383. }
  1384. void MemberAccessTest_4 ()
  1385. {
  1386. MemberAccessData d = new MemberAccessData ();
  1387. Expression<Func<string[]>> e4 = () => d.StringValues;
  1388. AssertNodeType (e4, ExpressionType.MemberAccess);
  1389. Assert (null, e4.Compile ().Invoke ());
  1390. }
  1391. void MemberAccessTest_5 ()
  1392. {
  1393. MemberAccessData d = new MemberAccessData ();
  1394. var e5 = d.GetEvent ();
  1395. AssertNodeType (e5, ExpressionType.MemberAccess);
  1396. Assert (null, e5.Compile ().Invoke ());
  1397. }
  1398. void MemberAccessTest_6 ()
  1399. {
  1400. MemberAccessData d = new MemberAccessData ();
  1401. Expression<Func<MyType>> e6 = () => d.MyTypeProperty;
  1402. AssertNodeType (e6, ExpressionType.MemberAccess);
  1403. Assert (new MyType (), e6.Compile ().Invoke ());
  1404. }
  1405. void MemberAccessTest_7 ()
  1406. {
  1407. MemberAccessData d = new MemberAccessData ();
  1408. Expression<Func<MyType, short>> e7 = a => a.ShortProp;
  1409. AssertNodeType (e7, ExpressionType.MemberAccess);
  1410. MyType mt = new MyType ();
  1411. mt.ShortProp = 124;
  1412. Assert (124, e7.Compile ().Invoke (mt));
  1413. }
  1414. void MemberAccessTest_8 ()
  1415. {
  1416. Expression<Func<string>> e8 = () => MemberAccessData.StaticProperty;
  1417. AssertNodeType (e8, ExpressionType.MemberAccess);
  1418. Assert ("alo", e8.Compile ().Invoke ());
  1419. }
  1420. void MemberAccessTest_9 ()
  1421. {
  1422. string s = "localvar";
  1423. Expression<Func<string>> e9 = () => s;
  1424. AssertNodeType (e9, ExpressionType.MemberAccess);
  1425. Assert ("localvar", e9.Compile ().Invoke ());
  1426. }
  1427. void MemberInitTest ()
  1428. {
  1429. Expression<Func<MemberAccessData>> e = () => new MemberAccessData {
  1430. VolatileValue = 2, StringValues = new string [] { "sv" }, MyTypeProperty = new MyType (692)
  1431. };
  1432. AssertNodeType (e, ExpressionType.MemberInit);
  1433. var r1 = e.Compile ().Invoke ();
  1434. Assert<uint> (2, r1.VolatileValue);
  1435. Assert (new string[] { "sv" }, r1.StringValues);
  1436. Assert (new MyType (692), r1.MyTypeProperty);
  1437. }
  1438. void MemberInitTest_2 ()
  1439. {
  1440. Expression<Func<MemberAccessData>> e2 = () => new MemberAccessData {
  1441. ListValues = new List<string> { "a", null }
  1442. };
  1443. AssertNodeType (e2, ExpressionType.MemberInit);
  1444. var r2 = e2.Compile ().Invoke ();
  1445. Assert ("a", r2.ListValues [0]);
  1446. }
  1447. void MemberInitTest_3 ()
  1448. {
  1449. Expression<Func<short, MyType>> e3 = a => new MyType { ShortProp = a };
  1450. AssertNodeType (e3, ExpressionType.MemberInit);
  1451. var r3 = e3.Compile ().Invoke (33);
  1452. Assert (33, r3.ShortProp);
  1453. }
  1454. void MemberInitTest_4 ()
  1455. {
  1456. Expression<Func<int>> e = () => new int { };
  1457. AssertNodeType (e, ExpressionType.MemberInit);
  1458. var r = e.Compile ().Invoke ();
  1459. Assert (0, r);
  1460. }
  1461. void ModuloTest ()
  1462. {
  1463. Expression<Func<int, int, int>> e = (int a, int b) => a % b;
  1464. AssertNodeType (e, ExpressionType.Modulo);
  1465. Assert (29, e.Compile ().Invoke (60, 31));
  1466. }
  1467. void ModuloTest_2 ()
  1468. {
  1469. Expression<Func<double?, double?, double?>> e2 = (a, b) => a % b;
  1470. AssertNodeType (e2, ExpressionType.Modulo);
  1471. Assert (null, e2.Compile ().Invoke (null, 3));
  1472. Assert (1.1, e2.Compile ().Invoke (3.1, 2));
  1473. }
  1474. void ModuloTest_3 ()
  1475. {
  1476. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a % b;
  1477. AssertNodeType (e3, ExpressionType.Modulo);
  1478. Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1479. }
  1480. void ModuloTest_4 ()
  1481. {
  1482. Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a % b;
  1483. AssertNodeType (e4, ExpressionType.Modulo);
  1484. Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
  1485. Assert (new MyType (12), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
  1486. }
  1487. void ModuloTest_5 ()
  1488. {
  1489. Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a % b;
  1490. AssertNodeType (e5, ExpressionType.Modulo);
  1491. Assert (1, e5.Compile ().Invoke (99, new MyType (2)));
  1492. }
  1493. void ModuloTest_6 ()
  1494. {
  1495. Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a % b;
  1496. AssertNodeType (e6, ExpressionType.Modulo);
  1497. Assert (100, e6.Compile ().Invoke (100, new MyType (200)));
  1498. Assert (null, e6.Compile ().Invoke (20, null));
  1499. }
  1500. void ModuloTest_7 ()
  1501. {
  1502. Expression<Func<ushort, int?>> e7 = (ushort a) => a % null;
  1503. AssertNodeType (e7, ExpressionType.Modulo);
  1504. Assert (null, e7.Compile ().Invoke (60));
  1505. }
  1506. void MultiplyTest ()
  1507. {
  1508. Expression<Func<int, int, int>> e = (int a, int b) => a * b;
  1509. AssertNodeType (e, ExpressionType.Multiply);
  1510. Assert (1860, e.Compile ().Invoke (60, 31));
  1511. Assert (2147483617, e.Compile ().Invoke (int.MaxValue, 31));
  1512. }
  1513. void MultiplyTest_2 ()
  1514. {
  1515. Expression<Func<double?, double?, double?>> e2 = (a, b) => a * b;
  1516. AssertNodeType (e2, ExpressionType.Multiply);
  1517. Assert (null, e2.Compile ().Invoke (null, 3));
  1518. Assert (6.2, e2.Compile ().Invoke (3.1, 2));
  1519. }
  1520. void MultiplyTest_3 ()
  1521. {
  1522. Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
  1523. AssertNodeType (e3, ExpressionType.Multiply);
  1524. Assert (400, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
  1525. }
  1526. void MultiplyTest_4 ()
  1527. {
  1528. Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a * b;
  1529. AssertNodeType (e4, Expr

Large files files are truncated, but you can click here to view the full file