PageRenderTime 116ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 3ms

/IronPython_Main/Runtime/Tests/ETScenariosCSLinq/CSLinq/ExpressionTreeNodes/Not.cs

#
C# | 13447 lines | 11483 code | 1922 blank | 42 comment | 4914 complexity | 666008fde201bf2127369f0fca935e49 MD5 | raw file
Possible License(s): GPL-2.0, MPL-2.0-no-copyleft-exception, CPL-1.0, CC-BY-SA-3.0, BSD-3-Clause, ISC, AGPL-3.0, LGPL-2.1, Apache-2.0 
    

  1. #if !CLR2

    2. 

  2. using System.Linq.Expressions;

    3. 

  3. #else

    4. 

  4. using Microsoft.Scripting.Ast;

    5. 

  5. using Microsoft.Scripting.Utils;

    6. 

  6. #endif

    7. 

  7. 

    8. 

  8. using System.Reflection;

    9. 

  9. using System.Collections;

    10. 

  10. using System.Text;

    11. 

  11. using System.Collections.Generic;

    12. 

  12. using System;

    13. 

  13. namespace ExpressionTreeNodes

    14. 

  14. {

    15. 

  15. 

    16. 

  16. 

    17. 

  17.     //-------- Scenario 782

    18. 

  18.     namespace Scenario782

    19. 

  19.     {

    20. 

  20. 

    21. 

  21.         namespace Not

    22. 

  22.         {

    23. 

  23.             public class Test

    24. 

  24.             {

    25. 

  25.                 // expression = null

    26. 

  26.                 public static int Test1()

    27. 

  27.                 {

    28. 

  28.                     ConstantExpression ce = Expression.Constant(10);

    29. 

  29. 

    30. 

  30.                     try

    31. 

  31.                     {

    32. 

  32.                         ce = null;

    33. 

  33.                         UnaryExpression result = Expression.Not(ce);

    34. 

  34.                         return 1;

    35. 

  35.                     }

    36. 

  36.                     catch (ArgumentNullException ane)

    37. 

  37.                     {

    38. 

  38.                         if (ane.CompareParamName("expression")) return 0;

    39. 

  39.                         return 1;

    40. 

  40.                     }

    41. 

  41.                 }

    42. 

  42. 

    43. 

  43. 

    44. 

  44.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not1__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    45. 

  45.                 public static Expression Not1__()

    46. 

  46.                 {

    47. 

  47.                     if (Main() != 0)

    48. 

  48.                     {

    49. 

  49.                         throw new Exception();

    50. 

  50.                     }

    51. 

  51.                     else

    52. 

  52.                     {

    53. 

  53.                         return Expression.Constant(0);

    54. 

  54.                     }

    55. 

  55.                 }

    56. 

  56.                 public static int Main()

    57. 

  57.                 {

    58. 

  58.                     return Test1();

    59. 

  59.                 }

    60. 

  60.             }

    61. 

  61.         }

    62. 

  62. 

    63. 

  63. 

    64. 

  64. 

    65. 

  65.         public static class Extension

    66. 

  66.         {

    67. 

  67.             public static bool CompareParamName(this ArgumentException ex, string expected)

    68. 

  68.             {

    69. 

  69. #if SILVERLIGHT

    70. 

  70. #if SLRESOURCES

    71. 

  71. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    72. 

  72. #else

    73. 

  73. 			        return true;

    74. 

  74. #endif

    75. 

  75. #else

    76. 

  76.                 return ex.ParamName == expected;

    77. 

  77. #endif

    78. 

  78.             }

    79. 

  79. 

    80. 

  80.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    81. 

  81.             {

    82. 

  82. #if SILVERLIGHT

    83. 

  83. #if SLRESOURCES

    84. 

  84. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    85. 

  85. #else

    86. 

  86. 			        return true;

    87. 

  87. #endif

    88. 

  88. #else

    89. 

  89.                 return ex.ParamName == expected;

    90. 

  90. #endif

    91. 

  91.             }

    92. 

  92.         }

    93. 

  93. 

    94. 

  94.         public static class Verification

    95. 

  95.         {

    96. 

  96.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    97. 

  97.             {

    98. 

  98.                 if (!(result.NodeType == et))

    99. 

  99.                 {

    100. 

  100.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    101. 

  101.                     return 1;

    102. 

  102.                 }

    103. 

  103.                 if (!(result.Type == type))

    104. 

  104.                 {

    105. 

  105.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    106. 

  106.                     return 1;

    107. 

  107.                 }

    108. 

  108.                 if (val == null)

    109. 

  109.                 {

    110. 

  110.                     if (result.Value != null) return 1;

    111. 

  111.                 }

    112. 

  112.                 else

    113. 

  113.                 {

    114. 

  114.                     if (!(result.Value.Equals(val))) return 1;

    115. 

  115.                 }

    116. 

  116.                 if (!(result.ToString() == str)) return 1;

    117. 

  117.                 return 0;

    118. 

  118.             }

    119. 

  119. 

    120. 

  120.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    121. 

  121.             {

    122. 

  122.                 if (!(result.NodeType == et))

    123. 

  123.                 {

    124. 

  124.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    125. 

  125.                     return 1;

    126. 

  126.                 }

    127. 

  127.                 if (!(result.Type == type))

    128. 

  128.                 {

    129. 

  129.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    130. 

  130.                     return 1;

    131. 

  131.                 }

    132. 

  132.                 if (operand == null)

    133. 

  133.                 {

    134. 

  134.                     if (result.Operand != null) return 1;

    135. 

  135.                 }

    136. 

  136.                 else

    137. 

  137.                 {

    138. 

  138.                     if (!(result.Operand.Equals(operand))) return 1;

    139. 

  139.                 }

    140. 

  140.                 if (!(result.ToString() == str))

    141. 

  141.                 {

    142. 

  142.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    143. 

  143.                     return 1;

    144. 

  144.                 }

    145. 

  145. 

    146. 

  146.                 if (result.Method != mi) return 1;

    147. 

  147.                 if (result.IsLifted != islifted) return 1;

    148. 

  148.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    149. 

  149. 

    150. 

  150.                 return 0;

    151. 

  151.             }

    152. 

  152. 

    153. 

  153.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    154. 

  154.             {

    155. 

  155.                 if (!(result.NodeType == et))

    156. 

  156.                 {

    157. 

  157.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    158. 

  158.                     return 1;

    159. 

  159.                 }

    160. 

  160.                 if (!(result.Type == type))

    161. 

  161.                 {

    162. 

  162.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    163. 

  163.                     return 1;

    164. 

  164.                 }

    165. 

  165. 

    166. 

  166.                 if (left == null)

    167. 

  167.                 {

    168. 

  168.                     if (result.Left != null)

    169. 

  169.                     {

    170. 

  170.                         Console.WriteLine("left was null");

    171. 

  171.                         return 1;

    172. 

  172.                     }

    173. 

  173.                 }

    174. 

  174.                 else

    175. 

  175.                 {

    176. 

  176.                     if (!(result.Left.Equals(left)))

    177. 

  177.                     {

    178. 

  178.                         Console.WriteLine("left was different");

    179. 

  179.                         return 1;

    180. 

  180.                     }

    181. 

  181.                 }

    182. 

  182. 

    183. 

  183.                 if (right == null)

    184. 

  184.                 {

    185. 

  185.                     if (result.Right != null) return 1;

    186. 

  186.                 }

    187. 

  187.                 else

    188. 

  188.                 {

    189. 

  189.                     if (!(result.Right.Equals(right))) return 1;

    190. 

  190.                 }

    191. 

  191. 

    192. 

  192.                 if (!(result.ToString() == str))

    193. 

  193.                 {

    194. 

  194.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    195. 

  195.                     return 1;

    196. 

  196.                 }

    197. 

  197. 

    198. 

  198.                 if (result.Method != mi) return 1;

    199. 

  199.                 if (result.IsLifted != islifted) return 1;

    200. 

  200.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    201. 

  201. 

    202. 

  202.                 if (result.Conversion != null) return 1;

    203. 

  203. 

    204. 

  204.                 return 0;

    205. 

  205.             }

    206. 

  206. 

    207. 

  207.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    208. 

  208.             {

    209. 

  209.                 if (!(result.NodeType == et))

    210. 

  210.                 {

    211. 

  211.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    212. 

  212.                     return 1;

    213. 

  213.                 }

    214. 

  214.                 if (!(result.Type == type))

    215. 

  215.                 {

    216. 

  216.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    217. 

  217.                     return 1;

    218. 

  218.                 }

    219. 

  219. 

    220. 

  220.                 if (left == null)

    221. 

  221.                 {

    222. 

  222.                     if (result.Left != null) return 1;

    223. 

  223.                 }

    224. 

  224.                 else

    225. 

  225.                 {

    226. 

  226.                     if (!(result.Left.Equals(left))) return 1;

    227. 

  227.                 }

    228. 

  228. 

    229. 

  229.                 if (right == null)

    230. 

  230.                 {

    231. 

  231.                     if (result.Right != null) return 1;

    232. 

  232.                 }

    233. 

  233.                 else

    234. 

  234.                 {

    235. 

  235.                     if (!(result.Right.Equals(right))) return 1;

    236. 

  236.                 }

    237. 

  237. 

    238. 

  238.                 if (!(result.ToString() == str)) return 1;

    239. 

  239. 

    240. 

  240.                 if (result.Method != mi) return 1;

    241. 

  241.                 if (result.IsLifted != islifted) return 1;

    242. 

  242.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    243. 

  243. 

    244. 

  244.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    245. 

  245. 

    246. 

  246.                 return 0;

    247. 

  247.             }

    248. 

  248. 

    249. 

  249.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    250. 

  250.             {

    251. 

  251.                 if (!(result.NodeType == et))

    252. 

  252.                 {

    253. 

  253.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    254. 

  254.                     return 1;

    255. 

  255.                 }

    256. 

  256.                 if (!(result.Type == type))

    257. 

  257.                 {

    258. 

  258.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    259. 

  259.                     return 1;

    260. 

  260.                 }

    261. 

  261. 

    262. 

  262.                 if (!(result.Method == method)) return 1;

    263. 

  263. 

    264. 

  264.                 if (obj == null)

    265. 

  265.                 {

    266. 

  266.                     if (result.Object != null)

    267. 

  267.                     {

    268. 

  268.                         Console.WriteLine("Expected object to be null.");

    269. 

  269.                         return 1;

    270. 

  270.                     }

    271. 

  271.                 }

    272. 

  272.                 else

    273. 

  273.                 {

    274. 

  274.                     if (!(result.Object.Equals(obj)))

    275. 

  275.                     {

    276. 

  276.                         Console.WriteLine("Object on which call is made is different from the result.");

    277. 

  277.                         return 1;

    278. 

  278.                     }

    279. 

  279.                 }

    280. 

  280. 

    281. 

  281.                 if (!(result.ToString() == str))

    282. 

  282.                 {

    283. 

  283.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    284. 

  284.                     return 1;

    285. 

  285.                 }

    286. 

  286. 

    287. 

  287.                 if (result.Arguments.Count != arguments.Length) return 1;

    288. 

  288. 

    289. 

  289.                 for (int i = 0; i < arguments.Length; i++)

    290. 

  290.                 {

    291. 

  291.                     if (result.Arguments[i] != arguments[i]) return 1;

    292. 

  292.                 }

    293. 

  293. 

    294. 

  294.                 return 0;

    295. 

  295.             }

    296. 

  296. 

    297. 

  297.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    298. 

  298.             {

    299. 

  299.                 if (!(result.NodeType == et))

    300. 

  300.                 {

    301. 

  301.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    302. 

  302.                     return 1;

    303. 

  303.                 }

    304. 

  304.                 if (!(result.Type == type))

    305. 

  305.                 {

    306. 

  306.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    307. 

  307.                     return 1;

    308. 

  308.                 }

    309. 

  309. 

    310. 

  310.                 if (expr == null)

    311. 

  311.                 {

    312. 

  312.                     Console.WriteLine("expr was null.");

    313. 

  313.                     if (result.Expression != null) return 1;

    314. 

  314.                 }

    315. 

  315.                 else

    316. 

  316.                 {

    317. 

  317.                     if (!(result.Expression.Equals(expr)))

    318. 

  318.                     {

    319. 

  319.                         return 1;

    320. 

  320.                     }

    321. 

  321.                 }

    322. 

  322. 

    323. 

  323.                 if (!(result.TypeOperand == typeop)) return 1;

    324. 

  324. 

    325. 

  325.                 if (!(result.ToString() == str))

    326. 

  326.                 {

    327. 

  327.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    328. 

  328.                     return 1;

    329. 

  329.                 }

    330. 

  330. 

    331. 

  331.                 return 0;

    332. 

  332.             }

    333. 

  333. 

    334. 

  334.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    335. 

  335.             {

    336. 

  336.                 if (!(result.NodeType == et))

    337. 

  337.                 {

    338. 

  338.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    339. 

  339.                     return 1;

    340. 

  340.                 }

    341. 

  341.                 if (!(result.Type == type))

    342. 

  342.                 {

    343. 

  343.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    344. 

  344.                     return 1;

    345. 

  345.                 }

    346. 

  346. 

    347. 

  347.                 if (test == null)

    348. 

  348.                 {

    349. 

  349.                     if (result.Test != null) return 1;

    350. 

  350.                 }

    351. 

  351.                 else

    352. 

  352.                 {

    353. 

  353.                     if (!(result.Test.Equals(test))) return 1;

    354. 

  354.                 }

    355. 

  355. 

    356. 

  356.                 if (ifTrue == null)

    357. 

  357.                 {

    358. 

  358.                     if (result.IfTrue != null) return 1;

    359. 

  359.                 }

    360. 

  360.                 else

    361. 

  361.                 {

    362. 

  362.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    363. 

  363.                 }

    364. 

  364. 

    365. 

  365.                 if (ifFalse == null)

    366. 

  366.                 {

    367. 

  367.                     if (result.IfFalse != null) return 1;

    368. 

  368.                 }

    369. 

  369.                 else

    370. 

  370.                 {

    371. 

  371.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    372. 

  372.                 }

    373. 

  373. 

    374. 

  374.                 if (!(result.ToString() == str)) return 1;

    375. 

  375. 

    376. 

  376.                 return 0;

    377. 

  377.             }

    378. 

  378. 

    379. 

  379.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    380. 

  380.             {

    381. 

  381.                 if (!(result.NodeType == et))

    382. 

  382.                 {

    383. 

  383.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    384. 

  384.                     return 1;

    385. 

  385.                 }

    386. 

  386.                 if (!(result.Type == type))

    387. 

  387.                 {

    388. 

  388.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    389. 

  389.                     return 1;

    390. 

  390.                 }

    391. 

  391. 

    392. 

  392.                 if (exp_expr == null)

    393. 

  393.                 {

    394. 

  394.                     if (result.Expression != null)

    395. 

  395.                     {

    396. 

  396.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    397. 

  397.                         return 1;

    398. 

  398.                     }

    399. 

  399.                 }

    400. 

  400.                 else

    401. 

  401.                 {

    402. 

  402.                     if (!(result.Expression.Equals(exp_expr)))

    403. 

  403.                     {

    404. 

  404.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    405. 

  405.                         return 1;

    406. 

  406.                     }

    407. 

  407.                 }

    408. 

  408. 

    409. 

  409.                 if (!(result.Member == exp_member))

    410. 

  410.                 {

    411. 

  411.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    412. 

  412.                     return 1;

    413. 

  413.                 }

    414. 

  414. 

    415. 

  415.                 if (!(result.ToString() == str))

    416. 

  416.                 {

    417. 

  417.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    418. 

  418.                     return 1;

    419. 

  419.                 }

    420. 

  420. 

    421. 

  421.                 return 0;

    422. 

  422.             }

    423. 

  423. 

    424. 

  424.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    425. 

  425.             {

    426. 

  426.                 if (!(result.NodeType == et))

    427. 

  427.                 {

    428. 

  428.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    429. 

  429.                     return 1;

    430. 

  430.                 }

    431. 

  431.                 if (!(result.Type == type))

    432. 

  432.                 {

    433. 

  433.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    434. 

  434.                     return 1;

    435. 

  435.                 }

    436. 

  436. 

    437. 

  437.                 if (!(result.Constructor == constructor))

    438. 

  438.                 {

    439. 

  439.                     Console.WriteLine("Unexpected constructor");

    440. 

  440.                     return 1;

    441. 

  441.                 }

    442. 

  442. 

    443. 

  443.                 if (!(result.ToString() == str))

    444. 

  444.                 {

    445. 

  445.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    446. 

  446.                     return 1;

    447. 

  447.                 }

    448. 

  448. 

    449. 

  449.                 if (arguments == null)

    450. 

  450.                 {

    451. 

  451.                     if (result.Arguments.Count != 0)

    452. 

  452.                     {

    453. 

  453.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    454. 

  454.                         return 1;

    455. 

  455.                     }

    456. 

  456.                 }

    457. 

  457.                 else

    458. 

  458.                 {

    459. 

  459.                     if (result.Arguments.Count != arguments.Length)

    460. 

  460.                     {

    461. 

  461.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    462. 

  462.                         return 1;

    463. 

  463.                     }

    464. 

  464.                     for (int i = 0; i < arguments.Length; i++)

    465. 

  465.                     {

    466. 

  466.                         if (result.Arguments[i] != arguments[i])

    467. 

  467.                         {

    468. 

  468.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    469. 

  469.                             return 1;

    470. 

  470.                         }

    471. 

  471.                     }

    472. 

  472.                 }

    473. 

  473. 

    474. 

  474.                 if (result.Members == null)

    475. 

  475.                 {

    476. 

  476.                     Console.WriteLine("result.Members was null");

    477. 

  477.                     return 1;

    478. 

  478.                 }

    479. 

  479. 

    480. 

  480.                 if (members == null)

    481. 

  481.                 {

    482. 

  482.                     if (result.Members.Count != 0)

    483. 

  483.                     {

    484. 

  484.                         Console.WriteLine("Got more than zero members");

    485. 

  485.                         return 1;

    486. 

  486.                     }

    487. 

  487.                 }

    488. 

  488.                 else

    489. 

  489.                 {

    490. 

  490.                     if (result.Members.Count != members.Length)

    491. 

  491.                     {

    492. 

  492.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    493. 

  493.                         return 1;

    494. 

  494.                     }

    495. 

  495. 

    496. 

  496.                     for (int i = 0; i < members.Length; i++)

    497. 

  497.                     {

    498. 

  498.                         if (result.Members[i] != members[i])

    499. 

  499.                         {

    500. 

  500.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    501. 

  501.                             return 1;

    502. 

  502.                         }

    503. 

  503.                     }

    504. 

  504.                 }

    505. 

  505. 

    506. 

  506.                 return 0;

    507. 

  507.             }

    508. 

  508. 

    509. 

  509.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    510. 

  510.             {

    511. 

  511.                 if (!(result.NodeType == et))

    512. 

  512.                 {

    513. 

  513.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    514. 

  514.                     return 1;

    515. 

  515.                 }

    516. 

  516.                 if (!(result.Type == type))

    517. 

  517.                 {

    518. 

  518.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    519. 

  519.                     return 1;

    520. 

  520.                 }

    521. 

  521. 

    522. 

  522.                 if (!(result.Constructor == constructor))

    523. 

  523.                 {

    524. 

  524.                     Console.WriteLine("Constructor is different from expected.");

    525. 

  525.                     return 1;

    526. 

  526.                 }

    527. 

  527. 

    528. 

  528.                 if (!(result.ToString() == str))

    529. 

  529.                 {

    530. 

  530.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    531. 

  531.                     return 1;

    532. 

  532.                 }

    533. 

  533. 

    534. 

  534.                 if (result.Arguments.Count != arguments.Length)

    535. 

  535.                 {

    536. 

  536.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    537. 

  537.                     return 1;

    538. 

  538.                 }

    539. 

  539. 

    540. 

  540.                 for (int i = 0; i < arguments.Length; i++)

    541. 

  541.                 {

    542. 

  542.                     if (result.Arguments[i] != arguments[i])

    543. 

  543.                     {

    544. 

  544.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    545. 

  545.                         return 1;

    546. 

  546.                     }

    547. 

  547.                 }

    548. 

  548. 

    549. 

  549.                 if (result.Members != null)

    550. 

  550.                 {

    551. 

  551.                     Console.WriteLine("result.Members isn't null");

    552. 

  552.                     return 1;

    553. 

  553.                 }

    554. 

  554. 

    555. 

  555.                 return 0;

    556. 

  556.             }

    557. 

  557. 

    558. 

  558.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    559. 

  559.             {

    560. 

  560.                 if (!(result.NodeType == et))

    561. 

  561.                 {

    562. 

  562.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    563. 

  563.                     return 1;

    564. 

  564.                 }

    565. 

  565.                 if (!(result.Type == type))

    566. 

  566.                 {

    567. 

  567.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    568. 

  568.                     return 1;

    569. 

  569.                 }

    570. 

  570. 

    571. 

  571.                 if (!(result.NewExpression == newExpression)) return 1;

    572. 

  572. 

    573. 

  573.                 if (!(result.ToString() == str))

    574. 

  574.                 {

    575. 

  575.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    576. 

  576.                     return 1;

    577. 

  577.                 }

    578. 

  578. 

    579. 

  579.                 if (result.Initializers.Count != initializers.Length) return 1;

    580. 

  580. 

    581. 

  581.                 for (int i = 0; i < initializers.Length; i++)

    582. 

  582.                 {

    583. 

  583.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    584. 

  584. 

    585. 

  585.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    586. 

  586. 

    587. 

  587.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    588. 

  588.                     {

    589. 

  589.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    590. 

  590.                     }

    591. 

  591.                 }

    592. 

  592. 

    593. 

  593.                 return 0;

    594. 

  594.             }

    595. 

  595. 

    596. 

  596.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    597. 

  597.             {

    598. 

  598.                 if (result.AddMethod != exp_mi) return 1;

    599. 

  599.                 if (!(result.ToString() == str))

    600. 

  600.                 {

    601. 

  601.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    602. 

  602.                     return 1;

    603. 

  603.                 }

    604. 

  604. 

    605. 

  605.                 if (result.Arguments.Count != args.Length) return 1;

    606. 

  606. 

    607. 

  607.                 for (int i = 0; i < args.Length; i++)

    608. 

  608.                 {

    609. 

  609.                     if (result.Arguments[i] != args[i]) return 1;

    610. 

  610.                 }

    611. 

  611. 

    612. 

  612.                 return 0;

    613. 

  613.             }

    614. 

  614. 

    615. 

  615.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    616. 

  616.             {

    617. 

  617.                 if (!(result.BindingType == bt)) return 1;

    618. 

  618.                 if (!(result.Expression == expr)) return 1;

    619. 

  619.                 if (!(result.Member.Equals(member))) return 1;

    620. 

  620.                 if (!(result.ToString() == str))

    621. 

  621.                 {

    622. 

  622.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    623. 

  623.                     return 1;

    624. 

  624.                 }

    625. 

  625. 

    626. 

  626.                 return 0;

    627. 

  627.             }

    628. 

  628. 

    629. 

  629.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    630. 

  630.             {

    631. 

  631.                 if (!(result.BindingType == bt)) return 1;

    632. 

  632. 

    633. 

  633.                 if (!(result.Member.Equals(member))) return 1;

    634. 

  634.                 if (!(result.ToString() == str))

    635. 

  635.                 {

    636. 

  636.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    637. 

  637.                     return 1;

    638. 

  638.                 }

    639. 

  639. 

    640. 

  640.                 if (result.Initializers.Count != initializers.Length) return 1;

    641. 

  641. 

    642. 

  642.                 for (int i = 0; i < initializers.Length; i++)

    643. 

  643.                 {

    644. 

  644.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    645. 

  645. 

    646. 

  646.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    647. 

  647. 

    648. 

  648.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    649. 

  649.                     {

    650. 

  650.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    651. 

  651.                     }

    652. 

  652.                 }

    653. 

  653. 

    654. 

  654. 

    655. 

  655.                 return 0;

    656. 

  656.             }

    657. 

  657. 

    658. 

  658.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    659. 

  659.             {

    660. 

  660.                 if (!(result.BindingType == bt)) return 1;

    661. 

  661. 

    662. 

  662.                 if (!(result.Member.Equals(member))) return 1;

    663. 

  663.                 if (!(result.ToString() == str))

    664. 

  664.                 {

    665. 

  665.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    666. 

  666.                     return 1;

    667. 

  667.                 }

    668. 

  668. 

    669. 

  669.                 if (result.Bindings.Count != bindings.Length) return 1;

    670. 

  670. 

    671. 

  671.                 for (int i = 0; i < bindings.Length; i++)

    672. 

  672.                 {

    673. 

  673.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    674. 

  674.                 }

    675. 

  675. 

    676. 

  676.                 return 0;

    677. 

  677.             }

    678. 

  678. 

    679. 

  679.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    680. 

  680.             {

    681. 

  681.                 if (!(result.NodeType == et))

    682. 

  682.                 {

    683. 

  683.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    684. 

  684.                     return 1;

    685. 

  685.                 }

    686. 

  686.                 if (!(result.Type == type))

    687. 

  687.                 {

    688. 

  688.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    689. 

  689.                     return 1;

    690. 

  690.                 }

    691. 

  691.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    692. 

  692.                 if (!(result.ToString() == str)) return 1;

    693. 

  693. 

    694. 

  694.                 if (result.Bindings.Count != bindings.Length) return 1;

    695. 

  695. 

    696. 

  696.                 for (int i = 0; i < bindings.Length; i++)

    697. 

  697.                 {

    698. 

  698.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    699. 

  699.                 }

    700. 

  700. 

    701. 

  701.                 return 0;

    702. 

  702.             }

    703. 

  703. 

    704. 

  704.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    705. 

  705.             {

    706. 

  706.                 if (!(result.NodeType == et))

    707. 

  707.                 {

    708. 

  708.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    709. 

  709.                     return 1;

    710. 

  710.                 }

    711. 

  711.                 if (!(result.Type == type))

    712. 

  712.                 {

    713. 

  713.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    714. 

  714.                     return 1;

    715. 

  715.                 }

    716. 

  716. 

    717. 

  717.                 if (result.Expressions.Count != expr.Length) return 1;

    718. 

  718. 

    719. 

  719.                 for (int i = 0; i < expr.Length; i++)

    720. 

  720.                 {

    721. 

  721.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    722. 

  722.                 }

    723. 

  723.                 if (!(result.ToString() == str))

    724. 

  724.                 {

    725. 

  725.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    726. 

  726.                     return 1;

    727. 

  727.                 }

    728. 

  728. 

    729. 

  729.                 return 0;

    730. 

  730.             }

    731. 

  731. 

    732. 

  732.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    733. 

  733.             {

    734. 

  734.                 if (!(result.NodeType == et))

    735. 

  735.                 {

    736. 

  736.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    737. 

  737.                     return 1;

    738. 

  738.                 }

    739. 

  739.                 if (!(result.Type == type))

    740. 

  740.                 {

    741. 

  741.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    742. 

  742.                     return 1;

    743. 

  743.                 }

    744. 

  744.                 if (!(result.Name == name)) return 1;

    745. 

  745. 

    746. 

  746.                 if (!(result.ToString() == str))

    747. 

  747.                 {

    748. 

  748.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    749. 

  749.                     return 1;

    750. 

  750.                 }

    751. 

  751. 

    752. 

  752.                 return 0;

    753. 

  753.             }

    754. 

  754. 

    755. 

  755.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    756. 

  756.             {

    757. 

  757.                 if (!(result.NodeType == et))

    758. 

  758.                 {

    759. 

  759.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    760. 

  760.                     return 1;

    761. 

  761.                 }

    762. 

  762.                 if (!(result.Type == type))

    763. 

  763.                 {

    764. 

  764.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    765. 

  765.                     return 1;

    766. 

  766.                 }

    767. 

  767. 

    768. 

  768.                 if (expr == null)

    769. 

  769.                 {

    770. 

  770.                     if (result.Body != null) return 1;

    771. 

  771.                 }

    772. 

  772.                 else

    773. 

  773.                 {

    774. 

  774.                     if (!(result.Body.Equals(expr))) return 1;

    775. 

  775.                 }

    776. 

  776. 

    777. 

  777.                 if (result.Parameters.Count != parms.Length) return 1;

    778. 

  778. 

    779. 

  779.                 for (int i = 0; i < parms.Length; i++)

    780. 

  780.                 {

    781. 

  781.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    782. 

  782.                 }

    783. 

  783. 

    784. 

  784.                 if (!(result.ToString() == str))

    785. 

  785.                 {

    786. 

  786.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    787. 

  787.                     return 1;

    788. 

  788.                 }

    789. 

  789. 

    790. 

  790.                 return 0;

    791. 

  791.             }

    792. 

  792. 

    793. 

  793.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    794. 

  794.             {

    795. 

  795.                 if (!(result.NodeType == et))

    796. 

  796.                 {

    797. 

  797.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    798. 

  798.                     return 1;

    799. 

  799.                 }

    800. 

  800.                 if (!(result.Type == type))

    801. 

  801.                 {

    802. 

  802.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    803. 

  803.                     return 1;

    804. 

  804.                 }

    805. 

  805. 

    806. 

  806.                 if (expr == null)

    807. 

  807.                 {

    808. 

  808.                     if (result.Expression != null) return 1;

    809. 

  809.                 }

    810. 

  810.                 else

    811. 

  811.                 {

    812. 

  812.                     if (!(result.Expression.Equals(expr))) return 1;

    813. 

  813.                 }

    814. 

  814. 

    815. 

  815.                 if (result.Arguments.Count != args.Length) return 1;

    816. 

  816. 

    817. 

  817.                 for (int i = 0; i < args.Length; i++)

    818. 

  818.                 {

    819. 

  819.                     if (!(result.Arguments[i].Equals(args[i])))

    820. 

  820.                     {

    821. 

  821.                         return 1;

    822. 

  822.                     }

    823. 

  823.                 }

    824. 

  824. 

    825. 

  825.                 if (result.ToString() != str)

    826. 

  826.                 {

    827. 

  827.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    828. 

  828.                     return 1;

    829. 

  829.                 }

    830. 

  830. 

    831. 

  831.                 return 0;

    832. 

  832.             }

    833. 

  833.         }

    834. 

  834. 

    835. 

  835. 

    836. 

  836.     }

    837. 

  837. 

    838. 

  838.     //-------- Scenario 783

    839. 

  839.     namespace Scenario783

    840. 

  840.     {

    841. 

  841. 

    842. 

  842.         namespace Not

    843. 

  843.         {

    844. 

  844.             public class Test

    845. 

  845.             {

    846. 

  846.                 // Test for functionality: Argument is of type integer

    847. 

  847.                 public static int Test2()

    848. 

  848.                 {

    849. 

  849.                     ConstantExpression ce = Expression.Constant(10);

    850. 

  850.                     Type exp_type = ce.Type;

    851. 

  851.                     ExpressionType exp_et = ExpressionType.Not;

    852. 

  852.                     string exp_str = "Not(" + ce.ToString() + ")";

    853. 

  853.                     Expression exp_operand = ce;

    854. 

  854. 

    855. 

  855.                     UnaryExpression result = Expression.Not(ce);

    856. 

  856. 

    857. 

  857.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, null, false, false);

    858. 

  858.                 }

    859. 

  859. 

    860. 

  860. 

    861. 

  861.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not2__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    862. 

  862.                 public static Expression Not2__()

    863. 

  863.                 {

    864. 

  864.                     if (Main() != 0)

    865. 

  865.                     {

    866. 

  866.                         throw new Exception();

    867. 

  867.                     }

    868. 

  868.                     else

    869. 

  869.                     {

    870. 

  870.                         return Expression.Constant(0);

    871. 

  871.                     }

    872. 

  872.                 }

    873. 

  873.                 public static int Main()

    874. 

  874.                 {

    875. 

  875.                     return Test2();

    876. 

  876.                 }

    877. 

  877.             }

    878. 

  878.         }

    879. 

  879. 

    880. 

  880. 

    881. 

  881.         public static class Extension

    882. 

  882.         {

    883. 

  883.             public static bool CompareParamName(this ArgumentException ex, string expected)

    884. 

  884.             {

    885. 

  885. #if SILVERLIGHT

    886. 

  886. #if SLRESOURCES

    887. 

  887. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    888. 

  888. #else

    889. 

  889. 			        return true;

    890. 

  890. #endif

    891. 

  891. #else

    892. 

  892.                 return ex.ParamName == expected;

    893. 

  893. #endif

    894. 

  894.             }

    895. 

  895. 

    896. 

  896.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    897. 

  897.             {

    898. 

  898. #if SILVERLIGHT

    899. 

  899. #if SLRESOURCES

    900. 

  900. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    901. 

  901. #else

    902. 

  902. 			        return true;

    903. 

  903. #endif

    904. 

  904. #else

    905. 

  905.                 return ex.ParamName == expected;

    906. 

  906. #endif

    907. 

  907.             }

    908. 

  908.         }

    909. 

  909. 

    910. 

  910.         public static class Verification

    911. 

  911.         {

    912. 

  912.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    913. 

  913.             {

    914. 

  914.                 if (!(result.NodeType == et))

    915. 

  915.                 {

    916. 

  916.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    917. 

  917.                     return 1;

    918. 

  918.                 }

    919. 

  919.                 if (!(result.Type == type))

    920. 

  920.                 {

    921. 

  921.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    922. 

  922.                     return 1;

    923. 

  923.                 }

    924. 

  924.                 if (val == null)

    925. 

  925.                 {

    926. 

  926.                     if (result.Value != null) return 1;

    927. 

  927.                 }

    928. 

  928.                 else

    929. 

  929.                 {

    930. 

  930.                     if (!(result.Value.Equals(val))) return 1;

    931. 

  931.                 }

    932. 

  932.                 if (!(result.ToString() == str)) return 1;

    933. 

  933.                 return 0;

    934. 

  934.             }

    935. 

  935. 

    936. 

  936.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    937. 

  937.             {

    938. 

  938.                 if (!(result.NodeType == et))

    939. 

  939.                 {

    940. 

  940.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    941. 

  941.                     return 1;

    942. 

  942.                 }

    943. 

  943.                 if (!(result.Type == type))

    944. 

  944.                 {

    945. 

  945.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    946. 

  946.                     return 1;

    947. 

  947.                 }

    948. 

  948.                 if (operand == null)

    949. 

  949.                 {

    950. 

  950.                     if (result.Operand != null) return 1;

    951. 

  951.                 }

    952. 

  952.                 else

    953. 

  953.                 {

    954. 

  954.                     if (!(result.Operand.Equals(operand))) return 1;

    955. 

  955.                 }

    956. 

  956.                 if (!(result.ToString() == str))

    957. 

  957.                 {

    958. 

  958.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    959. 

  959.                     return 1;

    960. 

  960.                 }

    961. 

  961. 

    962. 

  962.                 if (result.Method != mi) return 1;

    963. 

  963.                 if (result.IsLifted != islifted) return 1;

    964. 

  964.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    965. 

  965. 

    966. 

  966.                 return 0;

    967. 

  967.             }

    968. 

  968. 

    969. 

  969.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    970. 

  970.             {

    971. 

  971.                 if (!(result.NodeType == et))

    972. 

  972.                 {

    973. 

  973.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    974. 

  974.                     return 1;

    975. 

  975.                 }

    976. 

  976.                 if (!(result.Type == type))

    977. 

  977.                 {

    978. 

  978.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    979. 

  979.                     return 1;

    980. 

  980.                 }

    981. 

  981. 

    982. 

  982.                 if (left == null)

    983. 

  983.                 {

    984. 

  984.                     if (result.Left != null)

    985. 

  985.                     {

    986. 

  986.                         Console.WriteLine("left was null");

    987. 

  987.                         return 1;

    988. 

  988.                     }

    989. 

  989.                 }

    990. 

  990.                 else

    991. 

  991.                 {

    992. 

  992.                     if (!(result.Left.Equals(left)))

    993. 

  993.                     {

    994. 

  994.                         Console.WriteLine("left was different");

    995. 

  995.                         return 1;

    996. 

  996.                     }

    997. 

  997.                 }

    998. 

  998. 

    999. 

  999.                 if (right == null)

    1000. 

  1000.                 {

    1001. 

  1001.                     if (result.Right != null) return 1;

    1002. 

  1002.                 }

    1003. 

  1003.                 else

    1004. 

  1004.                 {

    1005. 

  1005.                     if (!(result.Right.Equals(right))) return 1;

    1006. 

  1006.                 }

    1007. 

  1007. 

    1008. 

  1008.                 if (!(result.ToString() == str))

    1009. 

  1009.                 {

    1010. 

  1010.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1011. 

  1011.                     return 1;

    1012. 

  1012.                 }

    1013. 

  1013. 

    1014. 

  1014.                 if (result.Method != mi) return 1;

    1015. 

  1015.                 if (result.IsLifted != islifted) return 1;

    1016. 

  1016.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    1017. 

  1017. 

    1018. 

  1018.                 if (result.Conversion != null) return 1;

    1019. 

  1019. 

    1020. 

  1020.                 return 0;

    1021. 

  1021.             }

    1022. 

  1022. 

    1023. 

  1023.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    1024. 

  1024.             {

    1025. 

  1025.                 if (!(result.NodeType == et))

    1026. 

  1026.                 {

    1027. 

  1027.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1028. 

  1028.                     return 1;

    1029. 

  1029.                 }

    1030. 

  1030.                 if (!(result.Type == type))

    1031. 

  1031.                 {

    1032. 

  1032.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1033. 

  1033.                     return 1;

    1034. 

  1034.                 }

    1035. 

  1035. 

    1036. 

  1036.                 if (left == null)

    1037. 

  1037.                 {

    1038. 

  1038.                     if (result.Left != null) return 1;

    1039. 

  1039.                 }

    1040. 

  1040.                 else

    1041. 

  1041.                 {

    1042. 

  1042.                     if (!(result.Left.Equals(left))) return 1;

    1043. 

  1043.                 }

    1044. 

  1044. 

    1045. 

  1045.                 if (right == null)

    1046. 

  1046.                 {

    1047. 

  1047.                     if (result.Right != null) return 1;

    1048. 

  1048.                 }

    1049. 

  1049.                 else

    1050. 

  1050.                 {

    1051. 

  1051.                     if (!(result.Right.Equals(right))) return 1;

    1052. 

  1052.                 }

    1053. 

  1053. 

    1054. 

  1054.                 if (!(result.ToString() == str)) return 1;

    1055. 

  1055. 

    1056. 

  1056.                 if (result.Method != mi) return 1;

    1057. 

  1057.                 if (result.IsLifted != islifted) return 1;

    1058. 

  1058.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    1059. 

  1059. 

    1060. 

  1060.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    1061. 

  1061. 

    1062. 

  1062.                 return 0;

    1063. 

  1063.             }

    1064. 

  1064. 

    1065. 

  1065.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    1066. 

  1066.             {

    1067. 

  1067.                 if (!(result.NodeType == et))

    1068. 

  1068.                 {

    1069. 

  1069.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1070. 

  1070.                     return 1;

    1071. 

  1071.                 }

    1072. 

  1072.                 if (!(result.Type == type))

    1073. 

  1073.                 {

    1074. 

  1074.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1075. 

  1075.                     return 1;

    1076. 

  1076.                 }

    1077. 

  1077. 

    1078. 

  1078.                 if (!(result.Method == method)) return 1;

    1079. 

  1079. 

    1080. 

  1080.                 if (obj == null)

    1081. 

  1081.                 {

    1082. 

  1082.                     if (result.Object != null)

    1083. 

  1083.                     {

    1084. 

  1084.                         Console.WriteLine("Expected object to be null.");

    1085. 

  1085.                         return 1;

    1086. 

  1086.                     }

    1087. 

  1087.                 }

    1088. 

  1088.                 else

    1089. 

  1089.                 {

    1090. 

  1090.                     if (!(result.Object.Equals(obj)))

    1091. 

  1091.                     {

    1092. 

  1092.                         Console.WriteLine("Object on which call is made is different from the result.");

    1093. 

  1093.                         return 1;

    1094. 

  1094.                     }

    1095. 

  1095.                 }

    1096. 

  1096. 

    1097. 

  1097.                 if (!(result.ToString() == str))

    1098. 

  1098.                 {

    1099. 

  1099.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1100. 

  1100.                     return 1;

    1101. 

  1101.                 }

    1102. 

  1102. 

    1103. 

  1103.                 if (result.Arguments.Count != arguments.Length) return 1;

    1104. 

  1104. 

    1105. 

  1105.                 for (int i = 0; i < arguments.Length; i++)

    1106. 

  1106.                 {

    1107. 

  1107.                     if (result.Arguments[i] != arguments[i]) return 1;

    1108. 

  1108.                 }

    1109. 

  1109. 

    1110. 

  1110.                 return 0;

    1111. 

  1111.             }

    1112. 

  1112. 

    1113. 

  1113.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    1114. 

  1114.             {

    1115. 

  1115.                 if (!(result.NodeType == et))

    1116. 

  1116.                 {

    1117. 

  1117.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1118. 

  1118.                     return 1;

    1119. 

  1119.                 }

    1120. 

  1120.                 if (!(result.Type == type))

    1121. 

  1121.                 {

    1122. 

  1122.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1123. 

  1123.                     return 1;

    1124. 

  1124.                 }

    1125. 

  1125. 

    1126. 

  1126.                 if (expr == null)

    1127. 

  1127.                 {

    1128. 

  1128.                     Console.WriteLine("expr was null.");

    1129. 

  1129.                     if (result.Expression != null) return 1;

    1130. 

  1130.                 }

    1131. 

  1131.                 else

    1132. 

  1132.                 {

    1133. 

  1133.                     if (!(result.Expression.Equals(expr)))

    1134. 

  1134.                     {

    1135. 

  1135.                         return 1;

    1136. 

  1136.                     }

    1137. 

  1137.                 }

    1138. 

  1138. 

    1139. 

  1139.                 if (!(result.TypeOperand == typeop)) return 1;

    1140. 

  1140. 

    1141. 

  1141.                 if (!(result.ToString() == str))

    1142. 

  1142.                 {

    1143. 

  1143.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1144. 

  1144.                     return 1;

    1145. 

  1145.                 }

    1146. 

  1146. 

    1147. 

  1147.                 return 0;

    1148. 

  1148.             }

    1149. 

  1149. 

    1150. 

  1150.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    1151. 

  1151.             {

    1152. 

  1152.                 if (!(result.NodeType == et))

    1153. 

  1153.                 {

    1154. 

  1154.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1155. 

  1155.                     return 1;

    1156. 

  1156.                 }

    1157. 

  1157.                 if (!(result.Type == type))

    1158. 

  1158.                 {

    1159. 

  1159.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1160. 

  1160.                     return 1;

    1161. 

  1161.                 }

    1162. 

  1162. 

    1163. 

  1163.                 if (test == null)

    1164. 

  1164.                 {

    1165. 

  1165.                     if (result.Test != null) return 1;

    1166. 

  1166.                 }

    1167. 

  1167.                 else

    1168. 

  1168.                 {

    1169. 

  1169.                     if (!(result.Test.Equals(test))) return 1;

    1170. 

  1170.                 }

    1171. 

  1171. 

    1172. 

  1172.                 if (ifTrue == null)

    1173. 

  1173.                 {

    1174. 

  1174.                     if (result.IfTrue != null) return 1;

    1175. 

  1175.                 }

    1176. 

  1176.                 else

    1177. 

  1177.                 {

    1178. 

  1178.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    1179. 

  1179.                 }

    1180. 

  1180. 

    1181. 

  1181.                 if (ifFalse == null)

    1182. 

  1182.                 {

    1183. 

  1183.                     if (result.IfFalse != null) return 1;

    1184. 

  1184.                 }

    1185. 

  1185.                 else

    1186. 

  1186.                 {

    1187. 

  1187.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    1188. 

  1188.                 }

    1189. 

  1189. 

    1190. 

  1190.                 if (!(result.ToString() == str)) return 1;

    1191. 

  1191. 

    1192. 

  1192.                 return 0;

    1193. 

  1193.             }

    1194. 

  1194. 

    1195. 

  1195.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    1196. 

  1196.             {

    1197. 

  1197.                 if (!(result.NodeType == et))

    1198. 

  1198.                 {

    1199. 

  1199.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1200. 

  1200.                     return 1;

    1201. 

  1201.                 }

    1202. 

  1202.                 if (!(result.Type == type))

    1203. 

  1203.                 {

    1204. 

  1204.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1205. 

  1205.                     return 1;

    1206. 

  1206.                 }

    1207. 

  1207. 

    1208. 

  1208.                 if (exp_expr == null)

    1209. 

  1209.                 {

    1210. 

  1210.                     if (result.Expression != null)

    1211. 

  1211.                     {

    1212. 

  1212.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    1213. 

  1213.                         return 1;

    1214. 

  1214.                     }

    1215. 

  1215.                 }

    1216. 

  1216.                 else

    1217. 

  1217.                 {

    1218. 

  1218.                     if (!(result.Expression.Equals(exp_expr)))

    1219. 

  1219.                     {

    1220. 

  1220.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    1221. 

  1221.                         return 1;

    1222. 

  1222.                     }

    1223. 

  1223.                 }

    1224. 

  1224. 

    1225. 

  1225.                 if (!(result.Member == exp_member))

    1226. 

  1226.                 {

    1227. 

  1227.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    1228. 

  1228.                     return 1;

    1229. 

  1229.                 }

    1230. 

  1230. 

    1231. 

  1231.                 if (!(result.ToString() == str))

    1232. 

  1232.                 {

    1233. 

  1233.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1234. 

  1234.                     return 1;

    1235. 

  1235.                 }

    1236. 

  1236. 

    1237. 

  1237.                 return 0;

    1238. 

  1238.             }

    1239. 

  1239. 

    1240. 

  1240.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    1241. 

  1241.             {

    1242. 

  1242.                 if (!(result.NodeType == et))

    1243. 

  1243.                 {

    1244. 

  1244.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1245. 

  1245.                     return 1;

    1246. 

  1246.                 }

    1247. 

  1247.                 if (!(result.Type == type))

    1248. 

  1248.                 {

    1249. 

  1249.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1250. 

  1250.                     return 1;

    1251. 

  1251.                 }

    1252. 

  1252. 

    1253. 

  1253.                 if (!(result.Constructor == constructor))

    1254. 

  1254.                 {

    1255. 

  1255.                     Console.WriteLine("Unexpected constructor");

    1256. 

  1256.                     return 1;

    1257. 

  1257.                 }

    1258. 

  1258. 

    1259. 

  1259.                 if (!(result.ToString() == str))

    1260. 

  1260.                 {

    1261. 

  1261.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1262. 

  1262.                     return 1;

    1263. 

  1263.                 }

    1264. 

  1264. 

    1265. 

  1265.                 if (arguments == null)

    1266. 

  1266.                 {

    1267. 

  1267.                     if (result.Arguments.Count != 0)

    1268. 

  1268.                     {

    1269. 

  1269.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    1270. 

  1270.                         return 1;

    1271. 

  1271.                     }

    1272. 

  1272.                 }

    1273. 

  1273.                 else

    1274. 

  1274.                 {

    1275. 

  1275.                     if (result.Arguments.Count != arguments.Length)

    1276. 

  1276.                     {

    1277. 

  1277.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    1278. 

  1278.                         return 1;

    1279. 

  1279.                     }

    1280. 

  1280.                     for (int i = 0; i < arguments.Length; i++)

    1281. 

  1281.                     {

    1282. 

  1282.                         if (result.Arguments[i] != arguments[i])

    1283. 

  1283.                         {

    1284. 

  1284.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    1285. 

  1285.                             return 1;

    1286. 

  1286.                         }

    1287. 

  1287.                     }

    1288. 

  1288.                 }

    1289. 

  1289. 

    1290. 

  1290.                 if (result.Members == null)

    1291. 

  1291.                 {

    1292. 

  1292.                     Console.WriteLine("result.Members was null");

    1293. 

  1293.                     return 1;

    1294. 

  1294.                 }

    1295. 

  1295. 

    1296. 

  1296.                 if (members == null)

    1297. 

  1297.                 {

    1298. 

  1298.                     if (result.Members.Count != 0)

    1299. 

  1299.                     {

    1300. 

  1300.                         Console.WriteLine("Got more than zero members");

    1301. 

  1301.                         return 1;

    1302. 

  1302.                     }

    1303. 

  1303.                 }

    1304. 

  1304.                 else

    1305. 

  1305.                 {

    1306. 

  1306.                     if (result.Members.Count != members.Length)

    1307. 

  1307.                     {

    1308. 

  1308.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    1309. 

  1309.                         return 1;

    1310. 

  1310.                     }

    1311. 

  1311. 

    1312. 

  1312.                     for (int i = 0; i < members.Length; i++)

    1313. 

  1313.                     {

    1314. 

  1314.                         if (result.Members[i] != members[i])

    1315. 

  1315.                         {

    1316. 

  1316.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    1317. 

  1317.                             return 1;

    1318. 

  1318.                         }

    1319. 

  1319.                     }

    1320. 

  1320.                 }

    1321. 

  1321. 

    1322. 

  1322.                 return 0;

    1323. 

  1323.             }

    1324. 

  1324. 

    1325. 

  1325.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    1326. 

  1326.             {

    1327. 

  1327.                 if (!(result.NodeType == et))

    1328. 

  1328.                 {

    1329. 

  1329.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1330. 

  1330.                     return 1;

    1331. 

  1331.                 }

    1332. 

  1332.                 if (!(result.Type == type))

    1333. 

  1333.                 {

    1334. 

  1334.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1335. 

  1335.                     return 1;

    1336. 

  1336.                 }

    1337. 

  1337. 

    1338. 

  1338.                 if (!(result.Constructor == constructor))

    1339. 

  1339.                 {

    1340. 

  1340.                     Console.WriteLine("Constructor is different from expected.");

    1341. 

  1341.                     return 1;

    1342. 

  1342.                 }

    1343. 

  1343. 

    1344. 

  1344.                 if (!(result.ToString() == str))

    1345. 

  1345.                 {

    1346. 

  1346.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1347. 

  1347.                     return 1;

    1348. 

  1348.                 }

    1349. 

  1349. 

    1350. 

  1350.                 if (result.Arguments.Count != arguments.Length)

    1351. 

  1351.                 {

    1352. 

  1352.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    1353. 

  1353.                     return 1;

    1354. 

  1354.                 }

    1355. 

  1355. 

    1356. 

  1356.                 for (int i = 0; i < arguments.Length; i++)

    1357. 

  1357.                 {

    1358. 

  1358.                     if (result.Arguments[i] != arguments[i])

    1359. 

  1359.                     {

    1360. 

  1360.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    1361. 

  1361.                         return 1;

    1362. 

  1362.                     }

    1363. 

  1363.                 }

    1364. 

  1364. 

    1365. 

  1365.                 if (result.Members != null)

    1366. 

  1366.                 {

    1367. 

  1367.                     Console.WriteLine("result.Members isn't null");

    1368. 

  1368.                     return 1;

    1369. 

  1369.                 }

    1370. 

  1370. 

    1371. 

  1371.                 return 0;

    1372. 

  1372.             }

    1373. 

  1373. 

    1374. 

  1374.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    1375. 

  1375.             {

    1376. 

  1376.                 if (!(result.NodeType == et))

    1377. 

  1377.                 {

    1378. 

  1378.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1379. 

  1379.                     return 1;

    1380. 

  1380.                 }

    1381. 

  1381.                 if (!(result.Type == type))

    1382. 

  1382.                 {

    1383. 

  1383.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1384. 

  1384.                     return 1;

    1385. 

  1385.                 }

    1386. 

  1386. 

    1387. 

  1387.                 if (!(result.NewExpression == newExpression)) return 1;

    1388. 

  1388. 

    1389. 

  1389.                 if (!(result.ToString() == str))

    1390. 

  1390.                 {

    1391. 

  1391.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1392. 

  1392.                     return 1;

    1393. 

  1393.                 }

    1394. 

  1394. 

    1395. 

  1395.                 if (result.Initializers.Count != initializers.Length) return 1;

    1396. 

  1396. 

    1397. 

  1397.                 for (int i = 0; i < initializers.Length; i++)

    1398. 

  1398.                 {

    1399. 

  1399.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    1400. 

  1400. 

    1401. 

  1401.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    1402. 

  1402. 

    1403. 

  1403.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    1404. 

  1404.                     {

    1405. 

  1405.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    1406. 

  1406.                     }

    1407. 

  1407.                 }

    1408. 

  1408. 

    1409. 

  1409.                 return 0;

    1410. 

  1410.             }

    1411. 

  1411. 

    1412. 

  1412.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    1413. 

  1413.             {

    1414. 

  1414.                 if (result.AddMethod != exp_mi) return 1;

    1415. 

  1415.                 if (!(result.ToString() == str))

    1416. 

  1416.                 {

    1417. 

  1417.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1418. 

  1418.                     return 1;

    1419. 

  1419.                 }

    1420. 

  1420. 

    1421. 

  1421.                 if (result.Arguments.Count != args.Length) return 1;

    1422. 

  1422. 

    1423. 

  1423.                 for (int i = 0; i < args.Length; i++)

    1424. 

  1424.                 {

    1425. 

  1425.                     if (result.Arguments[i] != args[i]) return 1;

    1426. 

  1426.                 }

    1427. 

  1427. 

    1428. 

  1428.                 return 0;

    1429. 

  1429.             }

    1430. 

  1430. 

    1431. 

  1431.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    1432. 

  1432.             {

    1433. 

  1433.                 if (!(result.BindingType == bt)) return 1;

    1434. 

  1434.                 if (!(result.Expression == expr)) return 1;

    1435. 

  1435.                 if (!(result.Member.Equals(member))) return 1;

    1436. 

  1436.                 if (!(result.ToString() == str))

    1437. 

  1437.                 {

    1438. 

  1438.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1439. 

  1439.                     return 1;

    1440. 

  1440.                 }

    1441. 

  1441. 

    1442. 

  1442.                 return 0;

    1443. 

  1443.             }

    1444. 

  1444. 

    1445. 

  1445.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    1446. 

  1446.             {

    1447. 

  1447.                 if (!(result.BindingType == bt)) return 1;

    1448. 

  1448. 

    1449. 

  1449.                 if (!(result.Member.Equals(member))) return 1;

    1450. 

  1450.                 if (!(result.ToString() == str))

    1451. 

  1451.                 {

    1452. 

  1452.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1453. 

  1453.                     return 1;

    1454. 

  1454.                 }

    1455. 

  1455. 

    1456. 

  1456.                 if (result.Initializers.Count != initializers.Length) return 1;

    1457. 

  1457. 

    1458. 

  1458.                 for (int i = 0; i < initializers.Length; i++)

    1459. 

  1459.                 {

    1460. 

  1460.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    1461. 

  1461. 

    1462. 

  1462.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    1463. 

  1463. 

    1464. 

  1464.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    1465. 

  1465.                     {

    1466. 

  1466.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    1467. 

  1467.                     }

    1468. 

  1468.                 }

    1469. 

  1469. 

    1470. 

  1470. 

    1471. 

  1471.                 return 0;

    1472. 

  1472.             }

    1473. 

  1473. 

    1474. 

  1474.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    1475. 

  1475.             {

    1476. 

  1476.                 if (!(result.BindingType == bt)) return 1;

    1477. 

  1477. 

    1478. 

  1478.                 if (!(result.Member.Equals(member))) return 1;

    1479. 

  1479.                 if (!(result.ToString() == str))

    1480. 

  1480.                 {

    1481. 

  1481.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1482. 

  1482.                     return 1;

    1483. 

  1483.                 }

    1484. 

  1484. 

    1485. 

  1485.                 if (result.Bindings.Count != bindings.Length) return 1;

    1486. 

  1486. 

    1487. 

  1487.                 for (int i = 0; i < bindings.Length; i++)

    1488. 

  1488.                 {

    1489. 

  1489.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    1490. 

  1490.                 }

    1491. 

  1491. 

    1492. 

  1492.                 return 0;

    1493. 

  1493.             }

    1494. 

  1494. 

    1495. 

  1495.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    1496. 

  1496.             {

    1497. 

  1497.                 if (!(result.NodeType == et))

    1498. 

  1498.                 {

    1499. 

  1499.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1500. 

  1500.                     return 1;

    1501. 

  1501.                 }

    1502. 

  1502.                 if (!(result.Type == type))

    1503. 

  1503.                 {

    1504. 

  1504.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1505. 

  1505.                     return 1;

    1506. 

  1506.                 }

    1507. 

  1507.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    1508. 

  1508.                 if (!(result.ToString() == str)) return 1;

    1509. 

  1509. 

    1510. 

  1510.                 if (result.Bindings.Count != bindings.Length) return 1;

    1511. 

  1511. 

    1512. 

  1512.                 for (int i = 0; i < bindings.Length; i++)

    1513. 

  1513.                 {

    1514. 

  1514.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    1515. 

  1515.                 }

    1516. 

  1516. 

    1517. 

  1517.                 return 0;

    1518. 

  1518.             }

    1519. 

  1519. 

    1520. 

  1520.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    1521. 

  1521.             {

    1522. 

  1522.                 if (!(result.NodeType == et))

    1523. 

  1523.                 {

    1524. 

  1524.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1525. 

  1525.                     return 1;

    1526. 

  1526.                 }

    1527. 

  1527.                 if (!(result.Type == type))

    1528. 

  1528.                 {

    1529. 

  1529.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1530. 

  1530.                     return 1;

    1531. 

  1531.                 }

    1532. 

  1532. 

    1533. 

  1533.                 if (result.Expressions.Count != expr.Length) return 1;

    1534. 

  1534. 

    1535. 

  1535.                 for (int i = 0; i < expr.Length; i++)

    1536. 

  1536.                 {

    1537. 

  1537.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    1538. 

  1538.                 }

    1539. 

  1539.                 if (!(result.ToString() == str))

    1540. 

  1540.                 {

    1541. 

  1541.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1542. 

  1542.                     return 1;

    1543. 

  1543.                 }

    1544. 

  1544. 

    1545. 

  1545.                 return 0;

    1546. 

  1546.             }

    1547. 

  1547. 

    1548. 

  1548.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    1549. 

  1549.             {

    1550. 

  1550.                 if (!(result.NodeType == et))

    1551. 

  1551.                 {

    1552. 

  1552.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1553. 

  1553.                     return 1;

    1554. 

  1554.                 }

    1555. 

  1555.                 if (!(result.Type == type))

    1556. 

  1556.                 {

    1557. 

  1557.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1558. 

  1558.                     return 1;

    1559. 

  1559.                 }

    1560. 

  1560.                 if (!(result.Name == name)) return 1;

    1561. 

  1561. 

    1562. 

  1562.                 if (!(result.ToString() == str))

    1563. 

  1563.                 {

    1564. 

  1564.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1565. 

  1565.                     return 1;

    1566. 

  1566.                 }

    1567. 

  1567. 

    1568. 

  1568.                 return 0;

    1569. 

  1569.             }

    1570. 

  1570. 

    1571. 

  1571.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    1572. 

  1572.             {

    1573. 

  1573.                 if (!(result.NodeType == et))

    1574. 

  1574.                 {

    1575. 

  1575.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1576. 

  1576.                     return 1;

    1577. 

  1577.                 }

    1578. 

  1578.                 if (!(result.Type == type))

    1579. 

  1579.                 {

    1580. 

  1580.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1581. 

  1581.                     return 1;

    1582. 

  1582.                 }

    1583. 

  1583. 

    1584. 

  1584.                 if (expr == null)

    1585. 

  1585.                 {

    1586. 

  1586.                     if (result.Body != null) return 1;

    1587. 

  1587.                 }

    1588. 

  1588.                 else

    1589. 

  1589.                 {

    1590. 

  1590.                     if (!(result.Body.Equals(expr))) return 1;

    1591. 

  1591.                 }

    1592. 

  1592. 

    1593. 

  1593.                 if (result.Parameters.Count != parms.Length) return 1;

    1594. 

  1594. 

    1595. 

  1595.                 for (int i = 0; i < parms.Length; i++)

    1596. 

  1596.                 {

    1597. 

  1597.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    1598. 

  1598.                 }

    1599. 

  1599. 

    1600. 

  1600.                 if (!(result.ToString() == str))

    1601. 

  1601.                 {

    1602. 

  1602.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    1603. 

  1603.                     return 1;

    1604. 

  1604.                 }

    1605. 

  1605. 

    1606. 

  1606.                 return 0;

    1607. 

  1607.             }

    1608. 

  1608. 

    1609. 

  1609.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    1610. 

  1610.             {

    1611. 

  1611.                 if (!(result.NodeType == et))

    1612. 

  1612.                 {

    1613. 

  1613.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1614. 

  1614.                     return 1;

    1615. 

  1615.                 }

    1616. 

  1616.                 if (!(result.Type == type))

    1617. 

  1617.                 {

    1618. 

  1618.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1619. 

  1619.                     return 1;

    1620. 

  1620.                 }

    1621. 

  1621. 

    1622. 

  1622.                 if (expr == null)

    1623. 

  1623.                 {

    1624. 

  1624.                     if (result.Expression != null) return 1;

    1625. 

  1625.                 }

    1626. 

  1626.                 else

    1627. 

  1627.                 {

    1628. 

  1628.                     if (!(result.Expression.Equals(expr))) return 1;

    1629. 

  1629.                 }

    1630. 

  1630. 

    1631. 

  1631.                 if (result.Arguments.Count != args.Length) return 1;

    1632. 

  1632. 

    1633. 

  1633.                 for (int i = 0; i < args.Length; i++)

    1634. 

  1634.                 {

    1635. 

  1635.                     if (!(result.Arguments[i].Equals(args[i])))

    1636. 

  1636.                     {

    1637. 

  1637.                         return 1;

    1638. 

  1638.                     }

    1639. 

  1639.                 }

    1640. 

  1640. 

    1641. 

  1641.                 if (result.ToString() != str)

    1642. 

  1642.                 {

    1643. 

  1643.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1644. 

  1644.                     return 1;

    1645. 

  1645.                 }

    1646. 

  1646. 

    1647. 

  1647.                 return 0;

    1648. 

  1648.             }

    1649. 

  1649.         }

    1650. 

  1650. 

    1651. 

  1651. 

    1652. 

  1652.     }

    1653. 

  1653. 

    1654. 

  1654.     //-------- Scenario 784

    1655. 

  1655.     namespace Scenario784

    1656. 

  1656.     {

    1657. 

  1657. 

    1658. 

  1658.         namespace Not

    1659. 

  1659.         {

    1660. 

  1660.             public class Test

    1661. 

  1661.             {

    1662. 

  1662.                 // Test for functionality: Argument is of type bool

    1663. 

  1663.                 public static int Test3()

    1664. 

  1664.                 {

    1665. 

  1665.                     ConstantExpression ce = Expression.Constant(true);

    1666. 

  1666.                     Type exp_type = ce.Type;

    1667. 

  1667.                     ExpressionType exp_et = ExpressionType.Not;

    1668. 

  1668.                     string exp_str = "Not(" + ce.ToString() + ")";

    1669. 

  1669.                     Expression exp_operand = ce;

    1670. 

  1670. 

    1671. 

  1671.                     UnaryExpression result = Expression.Not(ce);

    1672. 

  1672. 

    1673. 

  1673.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, null, false, false);

    1674. 

  1674.                 }

    1675. 

  1675. 

    1676. 

  1676. 

    1677. 

  1677.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not3__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    1678. 

  1678.                 public static Expression Not3__()

    1679. 

  1679.                 {

    1680. 

  1680.                     if (Main() != 0)

    1681. 

  1681.                     {

    1682. 

  1682.                         throw new Exception();

    1683. 

  1683.                     }

    1684. 

  1684.                     else

    1685. 

  1685.                     {

    1686. 

  1686.                         return Expression.Constant(0);

    1687. 

  1687.                     }

    1688. 

  1688.                 }

    1689. 

  1689.                 public static int Main()

    1690. 

  1690.                 {

    1691. 

  1691.                     return Test3();

    1692. 

  1692.                 }

    1693. 

  1693.             }

    1694. 

  1694.         }

    1695. 

  1695. 

    1696. 

  1696. 

    1697. 

  1697.         public static class Extension

    1698. 

  1698.         {

    1699. 

  1699.             public static bool CompareParamName(this ArgumentException ex, string expected)

    1700. 

  1700.             {

    1701. 

  1701. #if SILVERLIGHT

    1702. 

  1702. #if SLRESOURCES

    1703. 

  1703. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    1704. 

  1704. #else

    1705. 

  1705. 			        return true;

    1706. 

  1706. #endif

    1707. 

  1707. #else

    1708. 

  1708.                 return ex.ParamName == expected;

    1709. 

  1709. #endif

    1710. 

  1710.             }

    1711. 

  1711. 

    1712. 

  1712.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    1713. 

  1713.             {

    1714. 

  1714. #if SILVERLIGHT

    1715. 

  1715. #if SLRESOURCES

    1716. 

  1716. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    1717. 

  1717. #else

    1718. 

  1718. 			        return true;

    1719. 

  1719. #endif

    1720. 

  1720. #else

    1721. 

  1721.                 return ex.ParamName == expected;

    1722. 

  1722. #endif

    1723. 

  1723.             }

    1724. 

  1724.         }

    1725. 

  1725. 

    1726. 

  1726.         public static class Verification

    1727. 

  1727.         {

    1728. 

  1728.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    1729. 

  1729.             {

    1730. 

  1730.                 if (!(result.NodeType == et))

    1731. 

  1731.                 {

    1732. 

  1732.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1733. 

  1733.                     return 1;

    1734. 

  1734.                 }

    1735. 

  1735.                 if (!(result.Type == type))

    1736. 

  1736.                 {

    1737. 

  1737.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1738. 

  1738.                     return 1;

    1739. 

  1739.                 }

    1740. 

  1740.                 if (val == null)

    1741. 

  1741.                 {

    1742. 

  1742.                     if (result.Value != null) return 1;

    1743. 

  1743.                 }

    1744. 

  1744.                 else

    1745. 

  1745.                 {

    1746. 

  1746.                     if (!(result.Value.Equals(val))) return 1;

    1747. 

  1747.                 }

    1748. 

  1748.                 if (!(result.ToString() == str)) return 1;

    1749. 

  1749.                 return 0;

    1750. 

  1750.             }

    1751. 

  1751. 

    1752. 

  1752.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    1753. 

  1753.             {

    1754. 

  1754.                 if (!(result.NodeType == et))

    1755. 

  1755.                 {

    1756. 

  1756.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1757. 

  1757.                     return 1;

    1758. 

  1758.                 }

    1759. 

  1759.                 if (!(result.Type == type))

    1760. 

  1760.                 {

    1761. 

  1761.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1762. 

  1762.                     return 1;

    1763. 

  1763.                 }

    1764. 

  1764.                 if (operand == null)

    1765. 

  1765.                 {

    1766. 

  1766.                     if (result.Operand != null) return 1;

    1767. 

  1767.                 }

    1768. 

  1768.                 else

    1769. 

  1769.                 {

    1770. 

  1770.                     if (!(result.Operand.Equals(operand))) return 1;

    1771. 

  1771.                 }

    1772. 

  1772.                 if (!(result.ToString() == str))

    1773. 

  1773.                 {

    1774. 

  1774.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1775. 

  1775.                     return 1;

    1776. 

  1776.                 }

    1777. 

  1777. 

    1778. 

  1778.                 if (result.Method != mi) return 1;

    1779. 

  1779.                 if (result.IsLifted != islifted) return 1;

    1780. 

  1780.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    1781. 

  1781. 

    1782. 

  1782.                 return 0;

    1783. 

  1783.             }

    1784. 

  1784. 

    1785. 

  1785.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    1786. 

  1786.             {

    1787. 

  1787.                 if (!(result.NodeType == et))

    1788. 

  1788.                 {

    1789. 

  1789.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1790. 

  1790.                     return 1;

    1791. 

  1791.                 }

    1792. 

  1792.                 if (!(result.Type == type))

    1793. 

  1793.                 {

    1794. 

  1794.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1795. 

  1795.                     return 1;

    1796. 

  1796.                 }

    1797. 

  1797. 

    1798. 

  1798.                 if (left == null)

    1799. 

  1799.                 {

    1800. 

  1800.                     if (result.Left != null)

    1801. 

  1801.                     {

    1802. 

  1802.                         Console.WriteLine("left was null");

    1803. 

  1803.                         return 1;

    1804. 

  1804.                     }

    1805. 

  1805.                 }

    1806. 

  1806.                 else

    1807. 

  1807.                 {

    1808. 

  1808.                     if (!(result.Left.Equals(left)))

    1809. 

  1809.                     {

    1810. 

  1810.                         Console.WriteLine("left was different");

    1811. 

  1811.                         return 1;

    1812. 

  1812.                     }

    1813. 

  1813.                 }

    1814. 

  1814. 

    1815. 

  1815.                 if (right == null)

    1816. 

  1816.                 {

    1817. 

  1817.                     if (result.Right != null) return 1;

    1818. 

  1818.                 }

    1819. 

  1819.                 else

    1820. 

  1820.                 {

    1821. 

  1821.                     if (!(result.Right.Equals(right))) return 1;

    1822. 

  1822.                 }

    1823. 

  1823. 

    1824. 

  1824.                 if (!(result.ToString() == str))

    1825. 

  1825.                 {

    1826. 

  1826.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1827. 

  1827.                     return 1;

    1828. 

  1828.                 }

    1829. 

  1829. 

    1830. 

  1830.                 if (result.Method != mi) return 1;

    1831. 

  1831.                 if (result.IsLifted != islifted) return 1;

    1832. 

  1832.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    1833. 

  1833. 

    1834. 

  1834.                 if (result.Conversion != null) return 1;

    1835. 

  1835. 

    1836. 

  1836.                 return 0;

    1837. 

  1837.             }

    1838. 

  1838. 

    1839. 

  1839.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    1840. 

  1840.             {

    1841. 

  1841.                 if (!(result.NodeType == et))

    1842. 

  1842.                 {

    1843. 

  1843.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1844. 

  1844.                     return 1;

    1845. 

  1845.                 }

    1846. 

  1846.                 if (!(result.Type == type))

    1847. 

  1847.                 {

    1848. 

  1848.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1849. 

  1849.                     return 1;

    1850. 

  1850.                 }

    1851. 

  1851. 

    1852. 

  1852.                 if (left == null)

    1853. 

  1853.                 {

    1854. 

  1854.                     if (result.Left != null) return 1;

    1855. 

  1855.                 }

    1856. 

  1856.                 else

    1857. 

  1857.                 {

    1858. 

  1858.                     if (!(result.Left.Equals(left))) return 1;

    1859. 

  1859.                 }

    1860. 

  1860. 

    1861. 

  1861.                 if (right == null)

    1862. 

  1862.                 {

    1863. 

  1863.                     if (result.Right != null) return 1;

    1864. 

  1864.                 }

    1865. 

  1865.                 else

    1866. 

  1866.                 {

    1867. 

  1867.                     if (!(result.Right.Equals(right))) return 1;

    1868. 

  1868.                 }

    1869. 

  1869. 

    1870. 

  1870.                 if (!(result.ToString() == str)) return 1;

    1871. 

  1871. 

    1872. 

  1872.                 if (result.Method != mi) return 1;

    1873. 

  1873.                 if (result.IsLifted != islifted) return 1;

    1874. 

  1874.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    1875. 

  1875. 

    1876. 

  1876.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    1877. 

  1877. 

    1878. 

  1878.                 return 0;

    1879. 

  1879.             }

    1880. 

  1880. 

    1881. 

  1881.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    1882. 

  1882.             {

    1883. 

  1883.                 if (!(result.NodeType == et))

    1884. 

  1884.                 {

    1885. 

  1885.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1886. 

  1886.                     return 1;

    1887. 

  1887.                 }

    1888. 

  1888.                 if (!(result.Type == type))

    1889. 

  1889.                 {

    1890. 

  1890.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1891. 

  1891.                     return 1;

    1892. 

  1892.                 }

    1893. 

  1893. 

    1894. 

  1894.                 if (!(result.Method == method)) return 1;

    1895. 

  1895. 

    1896. 

  1896.                 if (obj == null)

    1897. 

  1897.                 {

    1898. 

  1898.                     if (result.Object != null)

    1899. 

  1899.                     {

    1900. 

  1900.                         Console.WriteLine("Expected object to be null.");

    1901. 

  1901.                         return 1;

    1902. 

  1902.                     }

    1903. 

  1903.                 }

    1904. 

  1904.                 else

    1905. 

  1905.                 {

    1906. 

  1906.                     if (!(result.Object.Equals(obj)))

    1907. 

  1907.                     {

    1908. 

  1908.                         Console.WriteLine("Object on which call is made is different from the result.");

    1909. 

  1909.                         return 1;

    1910. 

  1910.                     }

    1911. 

  1911.                 }

    1912. 

  1912. 

    1913. 

  1913.                 if (!(result.ToString() == str))

    1914. 

  1914.                 {

    1915. 

  1915.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1916. 

  1916.                     return 1;

    1917. 

  1917.                 }

    1918. 

  1918. 

    1919. 

  1919.                 if (result.Arguments.Count != arguments.Length) return 1;

    1920. 

  1920. 

    1921. 

  1921.                 for (int i = 0; i < arguments.Length; i++)

    1922. 

  1922.                 {

    1923. 

  1923.                     if (result.Arguments[i] != arguments[i]) return 1;

    1924. 

  1924.                 }

    1925. 

  1925. 

    1926. 

  1926.                 return 0;

    1927. 

  1927.             }

    1928. 

  1928. 

    1929. 

  1929.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    1930. 

  1930.             {

    1931. 

  1931.                 if (!(result.NodeType == et))

    1932. 

  1932.                 {

    1933. 

  1933.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1934. 

  1934.                     return 1;

    1935. 

  1935.                 }

    1936. 

  1936.                 if (!(result.Type == type))

    1937. 

  1937.                 {

    1938. 

  1938.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1939. 

  1939.                     return 1;

    1940. 

  1940.                 }

    1941. 

  1941. 

    1942. 

  1942.                 if (expr == null)

    1943. 

  1943.                 {

    1944. 

  1944.                     Console.WriteLine("expr was null.");

    1945. 

  1945.                     if (result.Expression != null) return 1;

    1946. 

  1946.                 }

    1947. 

  1947.                 else

    1948. 

  1948.                 {

    1949. 

  1949.                     if (!(result.Expression.Equals(expr)))

    1950. 

  1950.                     {

    1951. 

  1951.                         return 1;

    1952. 

  1952.                     }

    1953. 

  1953.                 }

    1954. 

  1954. 

    1955. 

  1955.                 if (!(result.TypeOperand == typeop)) return 1;

    1956. 

  1956. 

    1957. 

  1957.                 if (!(result.ToString() == str))

    1958. 

  1958.                 {

    1959. 

  1959.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    1960. 

  1960.                     return 1;

    1961. 

  1961.                 }

    1962. 

  1962. 

    1963. 

  1963.                 return 0;

    1964. 

  1964.             }

    1965. 

  1965. 

    1966. 

  1966.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    1967. 

  1967.             {

    1968. 

  1968.                 if (!(result.NodeType == et))

    1969. 

  1969.                 {

    1970. 

  1970.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    1971. 

  1971.                     return 1;

    1972. 

  1972.                 }

    1973. 

  1973.                 if (!(result.Type == type))

    1974. 

  1974.                 {

    1975. 

  1975.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    1976. 

  1976.                     return 1;

    1977. 

  1977.                 }

    1978. 

  1978. 

    1979. 

  1979.                 if (test == null)

    1980. 

  1980.                 {

    1981. 

  1981.                     if (result.Test != null) return 1;

    1982. 

  1982.                 }

    1983. 

  1983.                 else

    1984. 

  1984.                 {

    1985. 

  1985.                     if (!(result.Test.Equals(test))) return 1;

    1986. 

  1986.                 }

    1987. 

  1987. 

    1988. 

  1988.                 if (ifTrue == null)

    1989. 

  1989.                 {

    1990. 

  1990.                     if (result.IfTrue != null) return 1;

    1991. 

  1991.                 }

    1992. 

  1992.                 else

    1993. 

  1993.                 {

    1994. 

  1994.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    1995. 

  1995.                 }

    1996. 

  1996. 

    1997. 

  1997.                 if (ifFalse == null)

    1998. 

  1998.                 {

    1999. 

  1999.                     if (result.IfFalse != null) return 1;

    2000. 

  2000.                 }

    2001. 

  2001.                 else

    2002. 

  2002.                 {

    2003. 

  2003.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    2004. 

  2004.                 }

    2005. 

  2005. 

    2006. 

  2006.                 if (!(result.ToString() == str)) return 1;

    2007. 

  2007. 

    2008. 

  2008.                 return 0;

    2009. 

  2009.             }

    2010. 

  2010. 

    2011. 

  2011.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    2012. 

  2012.             {

    2013. 

  2013.                 if (!(result.NodeType == et))

    2014. 

  2014.                 {

    2015. 

  2015.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2016. 

  2016.                     return 1;

    2017. 

  2017.                 }

    2018. 

  2018.                 if (!(result.Type == type))

    2019. 

  2019.                 {

    2020. 

  2020.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2021. 

  2021.                     return 1;

    2022. 

  2022.                 }

    2023. 

  2023. 

    2024. 

  2024.                 if (exp_expr == null)

    2025. 

  2025.                 {

    2026. 

  2026.                     if (result.Expression != null)

    2027. 

  2027.                     {

    2028. 

  2028.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    2029. 

  2029.                         return 1;

    2030. 

  2030.                     }

    2031. 

  2031.                 }

    2032. 

  2032.                 else

    2033. 

  2033.                 {

    2034. 

  2034.                     if (!(result.Expression.Equals(exp_expr)))

    2035. 

  2035.                     {

    2036. 

  2036.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    2037. 

  2037.                         return 1;

    2038. 

  2038.                     }

    2039. 

  2039.                 }

    2040. 

  2040. 

    2041. 

  2041.                 if (!(result.Member == exp_member))

    2042. 

  2042.                 {

    2043. 

  2043.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    2044. 

  2044.                     return 1;

    2045. 

  2045.                 }

    2046. 

  2046. 

    2047. 

  2047.                 if (!(result.ToString() == str))

    2048. 

  2048.                 {

    2049. 

  2049.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2050. 

  2050.                     return 1;

    2051. 

  2051.                 }

    2052. 

  2052. 

    2053. 

  2053.                 return 0;

    2054. 

  2054.             }

    2055. 

  2055. 

    2056. 

  2056.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    2057. 

  2057.             {

    2058. 

  2058.                 if (!(result.NodeType == et))

    2059. 

  2059.                 {

    2060. 

  2060.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2061. 

  2061.                     return 1;

    2062. 

  2062.                 }

    2063. 

  2063.                 if (!(result.Type == type))

    2064. 

  2064.                 {

    2065. 

  2065.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2066. 

  2066.                     return 1;

    2067. 

  2067.                 }

    2068. 

  2068. 

    2069. 

  2069.                 if (!(result.Constructor == constructor))

    2070. 

  2070.                 {

    2071. 

  2071.                     Console.WriteLine("Unexpected constructor");

    2072. 

  2072.                     return 1;

    2073. 

  2073.                 }

    2074. 

  2074. 

    2075. 

  2075.                 if (!(result.ToString() == str))

    2076. 

  2076.                 {

    2077. 

  2077.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2078. 

  2078.                     return 1;

    2079. 

  2079.                 }

    2080. 

  2080. 

    2081. 

  2081.                 if (arguments == null)

    2082. 

  2082.                 {

    2083. 

  2083.                     if (result.Arguments.Count != 0)

    2084. 

  2084.                     {

    2085. 

  2085.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    2086. 

  2086.                         return 1;

    2087. 

  2087.                     }

    2088. 

  2088.                 }

    2089. 

  2089.                 else

    2090. 

  2090.                 {

    2091. 

  2091.                     if (result.Arguments.Count != arguments.Length)

    2092. 

  2092.                     {

    2093. 

  2093.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    2094. 

  2094.                         return 1;

    2095. 

  2095.                     }

    2096. 

  2096.                     for (int i = 0; i < arguments.Length; i++)

    2097. 

  2097.                     {

    2098. 

  2098.                         if (result.Arguments[i] != arguments[i])

    2099. 

  2099.                         {

    2100. 

  2100.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    2101. 

  2101.                             return 1;

    2102. 

  2102.                         }

    2103. 

  2103.                     }

    2104. 

  2104.                 }

    2105. 

  2105. 

    2106. 

  2106.                 if (result.Members == null)

    2107. 

  2107.                 {

    2108. 

  2108.                     Console.WriteLine("result.Members was null");

    2109. 

  2109.                     return 1;

    2110. 

  2110.                 }

    2111. 

  2111. 

    2112. 

  2112.                 if (members == null)

    2113. 

  2113.                 {

    2114. 

  2114.                     if (result.Members.Count != 0)

    2115. 

  2115.                     {

    2116. 

  2116.                         Console.WriteLine("Got more than zero members");

    2117. 

  2117.                         return 1;

    2118. 

  2118.                     }

    2119. 

  2119.                 }

    2120. 

  2120.                 else

    2121. 

  2121.                 {

    2122. 

  2122.                     if (result.Members.Count != members.Length)

    2123. 

  2123.                     {

    2124. 

  2124.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    2125. 

  2125.                         return 1;

    2126. 

  2126.                     }

    2127. 

  2127. 

    2128. 

  2128.                     for (int i = 0; i < members.Length; i++)

    2129. 

  2129.                     {

    2130. 

  2130.                         if (result.Members[i] != members[i])

    2131. 

  2131.                         {

    2132. 

  2132.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    2133. 

  2133.                             return 1;

    2134. 

  2134.                         }

    2135. 

  2135.                     }

    2136. 

  2136.                 }

    2137. 

  2137. 

    2138. 

  2138.                 return 0;

    2139. 

  2139.             }

    2140. 

  2140. 

    2141. 

  2141.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    2142. 

  2142.             {

    2143. 

  2143.                 if (!(result.NodeType == et))

    2144. 

  2144.                 {

    2145. 

  2145.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2146. 

  2146.                     return 1;

    2147. 

  2147.                 }

    2148. 

  2148.                 if (!(result.Type == type))

    2149. 

  2149.                 {

    2150. 

  2150.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2151. 

  2151.                     return 1;

    2152. 

  2152.                 }

    2153. 

  2153. 

    2154. 

  2154.                 if (!(result.Constructor == constructor))

    2155. 

  2155.                 {

    2156. 

  2156.                     Console.WriteLine("Constructor is different from expected.");

    2157. 

  2157.                     return 1;

    2158. 

  2158.                 }

    2159. 

  2159. 

    2160. 

  2160.                 if (!(result.ToString() == str))

    2161. 

  2161.                 {

    2162. 

  2162.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2163. 

  2163.                     return 1;

    2164. 

  2164.                 }

    2165. 

  2165. 

    2166. 

  2166.                 if (result.Arguments.Count != arguments.Length)

    2167. 

  2167.                 {

    2168. 

  2168.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    2169. 

  2169.                     return 1;

    2170. 

  2170.                 }

    2171. 

  2171. 

    2172. 

  2172.                 for (int i = 0; i < arguments.Length; i++)

    2173. 

  2173.                 {

    2174. 

  2174.                     if (result.Arguments[i] != arguments[i])

    2175. 

  2175.                     {

    2176. 

  2176.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    2177. 

  2177.                         return 1;

    2178. 

  2178.                     }

    2179. 

  2179.                 }

    2180. 

  2180. 

    2181. 

  2181.                 if (result.Members != null)

    2182. 

  2182.                 {

    2183. 

  2183.                     Console.WriteLine("result.Members isn't null");

    2184. 

  2184.                     return 1;

    2185. 

  2185.                 }

    2186. 

  2186. 

    2187. 

  2187.                 return 0;

    2188. 

  2188.             }

    2189. 

  2189. 

    2190. 

  2190.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    2191. 

  2191.             {

    2192. 

  2192.                 if (!(result.NodeType == et))

    2193. 

  2193.                 {

    2194. 

  2194.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2195. 

  2195.                     return 1;

    2196. 

  2196.                 }

    2197. 

  2197.                 if (!(result.Type == type))

    2198. 

  2198.                 {

    2199. 

  2199.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2200. 

  2200.                     return 1;

    2201. 

  2201.                 }

    2202. 

  2202. 

    2203. 

  2203.                 if (!(result.NewExpression == newExpression)) return 1;

    2204. 

  2204. 

    2205. 

  2205.                 if (!(result.ToString() == str))

    2206. 

  2206.                 {

    2207. 

  2207.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2208. 

  2208.                     return 1;

    2209. 

  2209.                 }

    2210. 

  2210. 

    2211. 

  2211.                 if (result.Initializers.Count != initializers.Length) return 1;

    2212. 

  2212. 

    2213. 

  2213.                 for (int i = 0; i < initializers.Length; i++)

    2214. 

  2214.                 {

    2215. 

  2215.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    2216. 

  2216. 

    2217. 

  2217.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    2218. 

  2218. 

    2219. 

  2219.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    2220. 

  2220.                     {

    2221. 

  2221.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    2222. 

  2222.                     }

    2223. 

  2223.                 }

    2224. 

  2224. 

    2225. 

  2225.                 return 0;

    2226. 

  2226.             }

    2227. 

  2227. 

    2228. 

  2228.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    2229. 

  2229.             {

    2230. 

  2230.                 if (result.AddMethod != exp_mi) return 1;

    2231. 

  2231.                 if (!(result.ToString() == str))

    2232. 

  2232.                 {

    2233. 

  2233.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2234. 

  2234.                     return 1;

    2235. 

  2235.                 }

    2236. 

  2236. 

    2237. 

  2237.                 if (result.Arguments.Count != args.Length) return 1;

    2238. 

  2238. 

    2239. 

  2239.                 for (int i = 0; i < args.Length; i++)

    2240. 

  2240.                 {

    2241. 

  2241.                     if (result.Arguments[i] != args[i]) return 1;

    2242. 

  2242.                 }

    2243. 

  2243. 

    2244. 

  2244.                 return 0;

    2245. 

  2245.             }

    2246. 

  2246. 

    2247. 

  2247.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    2248. 

  2248.             {

    2249. 

  2249.                 if (!(result.BindingType == bt)) return 1;

    2250. 

  2250.                 if (!(result.Expression == expr)) return 1;

    2251. 

  2251.                 if (!(result.Member.Equals(member))) return 1;

    2252. 

  2252.                 if (!(result.ToString() == str))

    2253. 

  2253.                 {

    2254. 

  2254.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2255. 

  2255.                     return 1;

    2256. 

  2256.                 }

    2257. 

  2257. 

    2258. 

  2258.                 return 0;

    2259. 

  2259.             }

    2260. 

  2260. 

    2261. 

  2261.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    2262. 

  2262.             {

    2263. 

  2263.                 if (!(result.BindingType == bt)) return 1;

    2264. 

  2264. 

    2265. 

  2265.                 if (!(result.Member.Equals(member))) return 1;

    2266. 

  2266.                 if (!(result.ToString() == str))

    2267. 

  2267.                 {

    2268. 

  2268.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2269. 

  2269.                     return 1;

    2270. 

  2270.                 }

    2271. 

  2271. 

    2272. 

  2272.                 if (result.Initializers.Count != initializers.Length) return 1;

    2273. 

  2273. 

    2274. 

  2274.                 for (int i = 0; i < initializers.Length; i++)

    2275. 

  2275.                 {

    2276. 

  2276.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    2277. 

  2277. 

    2278. 

  2278.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    2279. 

  2279. 

    2280. 

  2280.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    2281. 

  2281.                     {

    2282. 

  2282.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    2283. 

  2283.                     }

    2284. 

  2284.                 }

    2285. 

  2285. 

    2286. 

  2286. 

    2287. 

  2287.                 return 0;

    2288. 

  2288.             }

    2289. 

  2289. 

    2290. 

  2290.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    2291. 

  2291.             {

    2292. 

  2292.                 if (!(result.BindingType == bt)) return 1;

    2293. 

  2293. 

    2294. 

  2294.                 if (!(result.Member.Equals(member))) return 1;

    2295. 

  2295.                 if (!(result.ToString() == str))

    2296. 

  2296.                 {

    2297. 

  2297.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2298. 

  2298.                     return 1;

    2299. 

  2299.                 }

    2300. 

  2300. 

    2301. 

  2301.                 if (result.Bindings.Count != bindings.Length) return 1;

    2302. 

  2302. 

    2303. 

  2303.                 for (int i = 0; i < bindings.Length; i++)

    2304. 

  2304.                 {

    2305. 

  2305.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    2306. 

  2306.                 }

    2307. 

  2307. 

    2308. 

  2308.                 return 0;

    2309. 

  2309.             }

    2310. 

  2310. 

    2311. 

  2311.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    2312. 

  2312.             {

    2313. 

  2313.                 if (!(result.NodeType == et))

    2314. 

  2314.                 {

    2315. 

  2315.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2316. 

  2316.                     return 1;

    2317. 

  2317.                 }

    2318. 

  2318.                 if (!(result.Type == type))

    2319. 

  2319.                 {

    2320. 

  2320.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2321. 

  2321.                     return 1;

    2322. 

  2322.                 }

    2323. 

  2323.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    2324. 

  2324.                 if (!(result.ToString() == str)) return 1;

    2325. 

  2325. 

    2326. 

  2326.                 if (result.Bindings.Count != bindings.Length) return 1;

    2327. 

  2327. 

    2328. 

  2328.                 for (int i = 0; i < bindings.Length; i++)

    2329. 

  2329.                 {

    2330. 

  2330.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    2331. 

  2331.                 }

    2332. 

  2332. 

    2333. 

  2333.                 return 0;

    2334. 

  2334.             }

    2335. 

  2335. 

    2336. 

  2336.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    2337. 

  2337.             {

    2338. 

  2338.                 if (!(result.NodeType == et))

    2339. 

  2339.                 {

    2340. 

  2340.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2341. 

  2341.                     return 1;

    2342. 

  2342.                 }

    2343. 

  2343.                 if (!(result.Type == type))

    2344. 

  2344.                 {

    2345. 

  2345.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2346. 

  2346.                     return 1;

    2347. 

  2347.                 }

    2348. 

  2348. 

    2349. 

  2349.                 if (result.Expressions.Count != expr.Length) return 1;

    2350. 

  2350. 

    2351. 

  2351.                 for (int i = 0; i < expr.Length; i++)

    2352. 

  2352.                 {

    2353. 

  2353.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    2354. 

  2354.                 }

    2355. 

  2355.                 if (!(result.ToString() == str))

    2356. 

  2356.                 {

    2357. 

  2357.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2358. 

  2358.                     return 1;

    2359. 

  2359.                 }

    2360. 

  2360. 

    2361. 

  2361.                 return 0;

    2362. 

  2362.             }

    2363. 

  2363. 

    2364. 

  2364.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    2365. 

  2365.             {

    2366. 

  2366.                 if (!(result.NodeType == et))

    2367. 

  2367.                 {

    2368. 

  2368.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2369. 

  2369.                     return 1;

    2370. 

  2370.                 }

    2371. 

  2371.                 if (!(result.Type == type))

    2372. 

  2372.                 {

    2373. 

  2373.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2374. 

  2374.                     return 1;

    2375. 

  2375.                 }

    2376. 

  2376.                 if (!(result.Name == name)) return 1;

    2377. 

  2377. 

    2378. 

  2378.                 if (!(result.ToString() == str))

    2379. 

  2379.                 {

    2380. 

  2380.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2381. 

  2381.                     return 1;

    2382. 

  2382.                 }

    2383. 

  2383. 

    2384. 

  2384.                 return 0;

    2385. 

  2385.             }

    2386. 

  2386. 

    2387. 

  2387.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    2388. 

  2388.             {

    2389. 

  2389.                 if (!(result.NodeType == et))

    2390. 

  2390.                 {

    2391. 

  2391.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2392. 

  2392.                     return 1;

    2393. 

  2393.                 }

    2394. 

  2394.                 if (!(result.Type == type))

    2395. 

  2395.                 {

    2396. 

  2396.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2397. 

  2397.                     return 1;

    2398. 

  2398.                 }

    2399. 

  2399. 

    2400. 

  2400.                 if (expr == null)

    2401. 

  2401.                 {

    2402. 

  2402.                     if (result.Body != null) return 1;

    2403. 

  2403.                 }

    2404. 

  2404.                 else

    2405. 

  2405.                 {

    2406. 

  2406.                     if (!(result.Body.Equals(expr))) return 1;

    2407. 

  2407.                 }

    2408. 

  2408. 

    2409. 

  2409.                 if (result.Parameters.Count != parms.Length) return 1;

    2410. 

  2410. 

    2411. 

  2411.                 for (int i = 0; i < parms.Length; i++)

    2412. 

  2412.                 {

    2413. 

  2413.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    2414. 

  2414.                 }

    2415. 

  2415. 

    2416. 

  2416.                 if (!(result.ToString() == str))

    2417. 

  2417.                 {

    2418. 

  2418.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2419. 

  2419.                     return 1;

    2420. 

  2420.                 }

    2421. 

  2421. 

    2422. 

  2422.                 return 0;

    2423. 

  2423.             }

    2424. 

  2424. 

    2425. 

  2425.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    2426. 

  2426.             {

    2427. 

  2427.                 if (!(result.NodeType == et))

    2428. 

  2428.                 {

    2429. 

  2429.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2430. 

  2430.                     return 1;

    2431. 

  2431.                 }

    2432. 

  2432.                 if (!(result.Type == type))

    2433. 

  2433.                 {

    2434. 

  2434.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2435. 

  2435.                     return 1;

    2436. 

  2436.                 }

    2437. 

  2437. 

    2438. 

  2438.                 if (expr == null)

    2439. 

  2439.                 {

    2440. 

  2440.                     if (result.Expression != null) return 1;

    2441. 

  2441.                 }

    2442. 

  2442.                 else

    2443. 

  2443.                 {

    2444. 

  2444.                     if (!(result.Expression.Equals(expr))) return 1;

    2445. 

  2445.                 }

    2446. 

  2446. 

    2447. 

  2447.                 if (result.Arguments.Count != args.Length) return 1;

    2448. 

  2448. 

    2449. 

  2449.                 for (int i = 0; i < args.Length; i++)

    2450. 

  2450.                 {

    2451. 

  2451.                     if (!(result.Arguments[i].Equals(args[i])))

    2452. 

  2452.                     {

    2453. 

  2453.                         return 1;

    2454. 

  2454.                     }

    2455. 

  2455.                 }

    2456. 

  2456. 

    2457. 

  2457.                 if (result.ToString() != str)

    2458. 

  2458.                 {

    2459. 

  2459.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    2460. 

  2460.                     return 1;

    2461. 

  2461.                 }

    2462. 

  2462. 

    2463. 

  2463.                 return 0;

    2464. 

  2464.             }

    2465. 

  2465.         }

    2466. 

  2466. 

    2467. 

  2467. 

    2468. 

  2468.     }

    2469. 

  2469. 

    2470. 

  2470.     //-------- Scenario 785

    2471. 

  2471.     namespace Scenario785

    2472. 

  2472.     {

    2473. 

  2473. 

    2474. 

  2474.         namespace Not

    2475. 

  2475.         {

    2476. 

  2476.             public class Test

    2477. 

  2477.             {

    2478. 

  2478.                 // Test for functionality: Argument is of type bool?

    2479. 

  2479.                 public static int Test4()

    2480. 

  2480.                 {

    2481. 

  2481.                     ConstantExpression ce = Expression.Constant(null, typeof(bool?));

    2482. 

  2482.                     Type exp_type = typeof(bool?);

    2483. 

  2483.                     ExpressionType exp_et = ExpressionType.Not;

    2484. 

  2484.                     string exp_str = "Not(" + ce.ToString() + ")";

    2485. 

  2485.                     Expression exp_operand = ce;

    2486. 

  2486. 

    2487. 

  2487.                     UnaryExpression result = Expression.Not(ce);

    2488. 

  2488. 

    2489. 

  2489.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, null, true, true);

    2490. 

  2490.                 }

    2491. 

  2491. 

    2492. 

  2492. 

    2493. 

  2493.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not4__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    2494. 

  2494.                 public static Expression Not4__()

    2495. 

  2495.                 {

    2496. 

  2496.                     if (Main() != 0)

    2497. 

  2497.                     {

    2498. 

  2498.                         throw new Exception();

    2499. 

  2499.                     }

    2500. 

  2500.                     else

    2501. 

  2501.                     {

    2502. 

  2502.                         return Expression.Constant(0);

    2503. 

  2503.                     }

    2504. 

  2504.                 }

    2505. 

  2505.                 public static int Main()

    2506. 

  2506.                 {

    2507. 

  2507.                     return Test4();

    2508. 

  2508.                 }

    2509. 

  2509.             }

    2510. 

  2510.         }

    2511. 

  2511. 

    2512. 

  2512. 

    2513. 

  2513.         public static class Extension

    2514. 

  2514.         {

    2515. 

  2515.             public static bool CompareParamName(this ArgumentException ex, string expected)

    2516. 

  2516.             {

    2517. 

  2517. #if SILVERLIGHT

    2518. 

  2518. #if SLRESOURCES

    2519. 

  2519. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    2520. 

  2520. #else

    2521. 

  2521. 			        return true;

    2522. 

  2522. #endif

    2523. 

  2523. #else

    2524. 

  2524.                 return ex.ParamName == expected;

    2525. 

  2525. #endif

    2526. 

  2526.             }

    2527. 

  2527. 

    2528. 

  2528.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    2529. 

  2529.             {

    2530. 

  2530. #if SILVERLIGHT

    2531. 

  2531. #if SLRESOURCES

    2532. 

  2532. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    2533. 

  2533. #else

    2534. 

  2534. 			        return true;

    2535. 

  2535. #endif

    2536. 

  2536. #else

    2537. 

  2537.                 return ex.ParamName == expected;

    2538. 

  2538. #endif

    2539. 

  2539.             }

    2540. 

  2540.         }

    2541. 

  2541. 

    2542. 

  2542.         public static class Verification

    2543. 

  2543.         {

    2544. 

  2544.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    2545. 

  2545.             {

    2546. 

  2546.                 if (!(result.NodeType == et))

    2547. 

  2547.                 {

    2548. 

  2548.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2549. 

  2549.                     return 1;

    2550. 

  2550.                 }

    2551. 

  2551.                 if (!(result.Type == type))

    2552. 

  2552.                 {

    2553. 

  2553.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2554. 

  2554.                     return 1;

    2555. 

  2555.                 }

    2556. 

  2556.                 if (val == null)

    2557. 

  2557.                 {

    2558. 

  2558.                     if (result.Value != null) return 1;

    2559. 

  2559.                 }

    2560. 

  2560.                 else

    2561. 

  2561.                 {

    2562. 

  2562.                     if (!(result.Value.Equals(val))) return 1;

    2563. 

  2563.                 }

    2564. 

  2564.                 if (!(result.ToString() == str)) return 1;

    2565. 

  2565.                 return 0;

    2566. 

  2566.             }

    2567. 

  2567. 

    2568. 

  2568.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    2569. 

  2569.             {

    2570. 

  2570.                 if (!(result.NodeType == et))

    2571. 

  2571.                 {

    2572. 

  2572.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2573. 

  2573.                     return 1;

    2574. 

  2574.                 }

    2575. 

  2575.                 if (!(result.Type == type))

    2576. 

  2576.                 {

    2577. 

  2577.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2578. 

  2578.                     return 1;

    2579. 

  2579.                 }

    2580. 

  2580.                 if (operand == null)

    2581. 

  2581.                 {

    2582. 

  2582.                     if (result.Operand != null) return 1;

    2583. 

  2583.                 }

    2584. 

  2584.                 else

    2585. 

  2585.                 {

    2586. 

  2586.                     if (!(result.Operand.Equals(operand))) return 1;

    2587. 

  2587.                 }

    2588. 

  2588.                 if (!(result.ToString() == str))

    2589. 

  2589.                 {

    2590. 

  2590.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    2591. 

  2591.                     return 1;

    2592. 

  2592.                 }

    2593. 

  2593. 

    2594. 

  2594.                 if (result.Method != mi) return 1;

    2595. 

  2595.                 if (result.IsLifted != islifted) return 1;

    2596. 

  2596.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    2597. 

  2597. 

    2598. 

  2598.                 return 0;

    2599. 

  2599.             }

    2600. 

  2600. 

    2601. 

  2601.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    2602. 

  2602.             {

    2603. 

  2603.                 if (!(result.NodeType == et))

    2604. 

  2604.                 {

    2605. 

  2605.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2606. 

  2606.                     return 1;

    2607. 

  2607.                 }

    2608. 

  2608.                 if (!(result.Type == type))

    2609. 

  2609.                 {

    2610. 

  2610.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2611. 

  2611.                     return 1;

    2612. 

  2612.                 }

    2613. 

  2613. 

    2614. 

  2614.                 if (left == null)

    2615. 

  2615.                 {

    2616. 

  2616.                     if (result.Left != null)

    2617. 

  2617.                     {

    2618. 

  2618.                         Console.WriteLine("left was null");

    2619. 

  2619.                         return 1;

    2620. 

  2620.                     }

    2621. 

  2621.                 }

    2622. 

  2622.                 else

    2623. 

  2623.                 {

    2624. 

  2624.                     if (!(result.Left.Equals(left)))

    2625. 

  2625.                     {

    2626. 

  2626.                         Console.WriteLine("left was different");

    2627. 

  2627.                         return 1;

    2628. 

  2628.                     }

    2629. 

  2629.                 }

    2630. 

  2630. 

    2631. 

  2631.                 if (right == null)

    2632. 

  2632.                 {

    2633. 

  2633.                     if (result.Right != null) return 1;

    2634. 

  2634.                 }

    2635. 

  2635.                 else

    2636. 

  2636.                 {

    2637. 

  2637.                     if (!(result.Right.Equals(right))) return 1;

    2638. 

  2638.                 }

    2639. 

  2639. 

    2640. 

  2640.                 if (!(result.ToString() == str))

    2641. 

  2641.                 {

    2642. 

  2642.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    2643. 

  2643.                     return 1;

    2644. 

  2644.                 }

    2645. 

  2645. 

    2646. 

  2646.                 if (result.Method != mi) return 1;

    2647. 

  2647.                 if (result.IsLifted != islifted) return 1;

    2648. 

  2648.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    2649. 

  2649. 

    2650. 

  2650.                 if (result.Conversion != null) return 1;

    2651. 

  2651. 

    2652. 

  2652.                 return 0;

    2653. 

  2653.             }

    2654. 

  2654. 

    2655. 

  2655.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    2656. 

  2656.             {

    2657. 

  2657.                 if (!(result.NodeType == et))

    2658. 

  2658.                 {

    2659. 

  2659.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2660. 

  2660.                     return 1;

    2661. 

  2661.                 }

    2662. 

  2662.                 if (!(result.Type == type))

    2663. 

  2663.                 {

    2664. 

  2664.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2665. 

  2665.                     return 1;

    2666. 

  2666.                 }

    2667. 

  2667. 

    2668. 

  2668.                 if (left == null)

    2669. 

  2669.                 {

    2670. 

  2670.                     if (result.Left != null) return 1;

    2671. 

  2671.                 }

    2672. 

  2672.                 else

    2673. 

  2673.                 {

    2674. 

  2674.                     if (!(result.Left.Equals(left))) return 1;

    2675. 

  2675.                 }

    2676. 

  2676. 

    2677. 

  2677.                 if (right == null)

    2678. 

  2678.                 {

    2679. 

  2679.                     if (result.Right != null) return 1;

    2680. 

  2680.                 }

    2681. 

  2681.                 else

    2682. 

  2682.                 {

    2683. 

  2683.                     if (!(result.Right.Equals(right))) return 1;

    2684. 

  2684.                 }

    2685. 

  2685. 

    2686. 

  2686.                 if (!(result.ToString() == str)) return 1;

    2687. 

  2687. 

    2688. 

  2688.                 if (result.Method != mi) return 1;

    2689. 

  2689.                 if (result.IsLifted != islifted) return 1;

    2690. 

  2690.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    2691. 

  2691. 

    2692. 

  2692.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    2693. 

  2693. 

    2694. 

  2694.                 return 0;

    2695. 

  2695.             }

    2696. 

  2696. 

    2697. 

  2697.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    2698. 

  2698.             {

    2699. 

  2699.                 if (!(result.NodeType == et))

    2700. 

  2700.                 {

    2701. 

  2701.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2702. 

  2702.                     return 1;

    2703. 

  2703.                 }

    2704. 

  2704.                 if (!(result.Type == type))

    2705. 

  2705.                 {

    2706. 

  2706.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2707. 

  2707.                     return 1;

    2708. 

  2708.                 }

    2709. 

  2709. 

    2710. 

  2710.                 if (!(result.Method == method)) return 1;

    2711. 

  2711. 

    2712. 

  2712.                 if (obj == null)

    2713. 

  2713.                 {

    2714. 

  2714.                     if (result.Object != null)

    2715. 

  2715.                     {

    2716. 

  2716.                         Console.WriteLine("Expected object to be null.");

    2717. 

  2717.                         return 1;

    2718. 

  2718.                     }

    2719. 

  2719.                 }

    2720. 

  2720.                 else

    2721. 

  2721.                 {

    2722. 

  2722.                     if (!(result.Object.Equals(obj)))

    2723. 

  2723.                     {

    2724. 

  2724.                         Console.WriteLine("Object on which call is made is different from the result.");

    2725. 

  2725.                         return 1;

    2726. 

  2726.                     }

    2727. 

  2727.                 }

    2728. 

  2728. 

    2729. 

  2729.                 if (!(result.ToString() == str))

    2730. 

  2730.                 {

    2731. 

  2731.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    2732. 

  2732.                     return 1;

    2733. 

  2733.                 }

    2734. 

  2734. 

    2735. 

  2735.                 if (result.Arguments.Count != arguments.Length) return 1;

    2736. 

  2736. 

    2737. 

  2737.                 for (int i = 0; i < arguments.Length; i++)

    2738. 

  2738.                 {

    2739. 

  2739.                     if (result.Arguments[i] != arguments[i]) return 1;

    2740. 

  2740.                 }

    2741. 

  2741. 

    2742. 

  2742.                 return 0;

    2743. 

  2743.             }

    2744. 

  2744. 

    2745. 

  2745.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    2746. 

  2746.             {

    2747. 

  2747.                 if (!(result.NodeType == et))

    2748. 

  2748.                 {

    2749. 

  2749.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2750. 

  2750.                     return 1;

    2751. 

  2751.                 }

    2752. 

  2752.                 if (!(result.Type == type))

    2753. 

  2753.                 {

    2754. 

  2754.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2755. 

  2755.                     return 1;

    2756. 

  2756.                 }

    2757. 

  2757. 

    2758. 

  2758.                 if (expr == null)

    2759. 

  2759.                 {

    2760. 

  2760.                     Console.WriteLine("expr was null.");

    2761. 

  2761.                     if (result.Expression != null) return 1;

    2762. 

  2762.                 }

    2763. 

  2763.                 else

    2764. 

  2764.                 {

    2765. 

  2765.                     if (!(result.Expression.Equals(expr)))

    2766. 

  2766.                     {

    2767. 

  2767.                         return 1;

    2768. 

  2768.                     }

    2769. 

  2769.                 }

    2770. 

  2770. 

    2771. 

  2771.                 if (!(result.TypeOperand == typeop)) return 1;

    2772. 

  2772. 

    2773. 

  2773.                 if (!(result.ToString() == str))

    2774. 

  2774.                 {

    2775. 

  2775.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    2776. 

  2776.                     return 1;

    2777. 

  2777.                 }

    2778. 

  2778. 

    2779. 

  2779.                 return 0;

    2780. 

  2780.             }

    2781. 

  2781. 

    2782. 

  2782.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    2783. 

  2783.             {

    2784. 

  2784.                 if (!(result.NodeType == et))

    2785. 

  2785.                 {

    2786. 

  2786.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2787. 

  2787.                     return 1;

    2788. 

  2788.                 }

    2789. 

  2789.                 if (!(result.Type == type))

    2790. 

  2790.                 {

    2791. 

  2791.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2792. 

  2792.                     return 1;

    2793. 

  2793.                 }

    2794. 

  2794. 

    2795. 

  2795.                 if (test == null)

    2796. 

  2796.                 {

    2797. 

  2797.                     if (result.Test != null) return 1;

    2798. 

  2798.                 }

    2799. 

  2799.                 else

    2800. 

  2800.                 {

    2801. 

  2801.                     if (!(result.Test.Equals(test))) return 1;

    2802. 

  2802.                 }

    2803. 

  2803. 

    2804. 

  2804.                 if (ifTrue == null)

    2805. 

  2805.                 {

    2806. 

  2806.                     if (result.IfTrue != null) return 1;

    2807. 

  2807.                 }

    2808. 

  2808.                 else

    2809. 

  2809.                 {

    2810. 

  2810.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    2811. 

  2811.                 }

    2812. 

  2812. 

    2813. 

  2813.                 if (ifFalse == null)

    2814. 

  2814.                 {

    2815. 

  2815.                     if (result.IfFalse != null) return 1;

    2816. 

  2816.                 }

    2817. 

  2817.                 else

    2818. 

  2818.                 {

    2819. 

  2819.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    2820. 

  2820.                 }

    2821. 

  2821. 

    2822. 

  2822.                 if (!(result.ToString() == str)) return 1;

    2823. 

  2823. 

    2824. 

  2824.                 return 0;

    2825. 

  2825.             }

    2826. 

  2826. 

    2827. 

  2827.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    2828. 

  2828.             {

    2829. 

  2829.                 if (!(result.NodeType == et))

    2830. 

  2830.                 {

    2831. 

  2831.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2832. 

  2832.                     return 1;

    2833. 

  2833.                 }

    2834. 

  2834.                 if (!(result.Type == type))

    2835. 

  2835.                 {

    2836. 

  2836.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2837. 

  2837.                     return 1;

    2838. 

  2838.                 }

    2839. 

  2839. 

    2840. 

  2840.                 if (exp_expr == null)

    2841. 

  2841.                 {

    2842. 

  2842.                     if (result.Expression != null)

    2843. 

  2843.                     {

    2844. 

  2844.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    2845. 

  2845.                         return 1;

    2846. 

  2846.                     }

    2847. 

  2847.                 }

    2848. 

  2848.                 else

    2849. 

  2849.                 {

    2850. 

  2850.                     if (!(result.Expression.Equals(exp_expr)))

    2851. 

  2851.                     {

    2852. 

  2852.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    2853. 

  2853.                         return 1;

    2854. 

  2854.                     }

    2855. 

  2855.                 }

    2856. 

  2856. 

    2857. 

  2857.                 if (!(result.Member == exp_member))

    2858. 

  2858.                 {

    2859. 

  2859.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    2860. 

  2860.                     return 1;

    2861. 

  2861.                 }

    2862. 

  2862. 

    2863. 

  2863.                 if (!(result.ToString() == str))

    2864. 

  2864.                 {

    2865. 

  2865.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2866. 

  2866.                     return 1;

    2867. 

  2867.                 }

    2868. 

  2868. 

    2869. 

  2869.                 return 0;

    2870. 

  2870.             }

    2871. 

  2871. 

    2872. 

  2872.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    2873. 

  2873.             {

    2874. 

  2874.                 if (!(result.NodeType == et))

    2875. 

  2875.                 {

    2876. 

  2876.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2877. 

  2877.                     return 1;

    2878. 

  2878.                 }

    2879. 

  2879.                 if (!(result.Type == type))

    2880. 

  2880.                 {

    2881. 

  2881.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2882. 

  2882.                     return 1;

    2883. 

  2883.                 }

    2884. 

  2884. 

    2885. 

  2885.                 if (!(result.Constructor == constructor))

    2886. 

  2886.                 {

    2887. 

  2887.                     Console.WriteLine("Unexpected constructor");

    2888. 

  2888.                     return 1;

    2889. 

  2889.                 }

    2890. 

  2890. 

    2891. 

  2891.                 if (!(result.ToString() == str))

    2892. 

  2892.                 {

    2893. 

  2893.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2894. 

  2894.                     return 1;

    2895. 

  2895.                 }

    2896. 

  2896. 

    2897. 

  2897.                 if (arguments == null)

    2898. 

  2898.                 {

    2899. 

  2899.                     if (result.Arguments.Count != 0)

    2900. 

  2900.                     {

    2901. 

  2901.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    2902. 

  2902.                         return 1;

    2903. 

  2903.                     }

    2904. 

  2904.                 }

    2905. 

  2905.                 else

    2906. 

  2906.                 {

    2907. 

  2907.                     if (result.Arguments.Count != arguments.Length)

    2908. 

  2908.                     {

    2909. 

  2909.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    2910. 

  2910.                         return 1;

    2911. 

  2911.                     }

    2912. 

  2912.                     for (int i = 0; i < arguments.Length; i++)

    2913. 

  2913.                     {

    2914. 

  2914.                         if (result.Arguments[i] != arguments[i])

    2915. 

  2915.                         {

    2916. 

  2916.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    2917. 

  2917.                             return 1;

    2918. 

  2918.                         }

    2919. 

  2919.                     }

    2920. 

  2920.                 }

    2921. 

  2921. 

    2922. 

  2922.                 if (result.Members == null)

    2923. 

  2923.                 {

    2924. 

  2924.                     Console.WriteLine("result.Members was null");

    2925. 

  2925.                     return 1;

    2926. 

  2926.                 }

    2927. 

  2927. 

    2928. 

  2928.                 if (members == null)

    2929. 

  2929.                 {

    2930. 

  2930.                     if (result.Members.Count != 0)

    2931. 

  2931.                     {

    2932. 

  2932.                         Console.WriteLine("Got more than zero members");

    2933. 

  2933.                         return 1;

    2934. 

  2934.                     }

    2935. 

  2935.                 }

    2936. 

  2936.                 else

    2937. 

  2937.                 {

    2938. 

  2938.                     if (result.Members.Count != members.Length)

    2939. 

  2939.                     {

    2940. 

  2940.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    2941. 

  2941.                         return 1;

    2942. 

  2942.                     }

    2943. 

  2943. 

    2944. 

  2944.                     for (int i = 0; i < members.Length; i++)

    2945. 

  2945.                     {

    2946. 

  2946.                         if (result.Members[i] != members[i])

    2947. 

  2947.                         {

    2948. 

  2948.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    2949. 

  2949.                             return 1;

    2950. 

  2950.                         }

    2951. 

  2951.                     }

    2952. 

  2952.                 }

    2953. 

  2953. 

    2954. 

  2954.                 return 0;

    2955. 

  2955.             }

    2956. 

  2956. 

    2957. 

  2957.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    2958. 

  2958.             {

    2959. 

  2959.                 if (!(result.NodeType == et))

    2960. 

  2960.                 {

    2961. 

  2961.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    2962. 

  2962.                     return 1;

    2963. 

  2963.                 }

    2964. 

  2964.                 if (!(result.Type == type))

    2965. 

  2965.                 {

    2966. 

  2966.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    2967. 

  2967.                     return 1;

    2968. 

  2968.                 }

    2969. 

  2969. 

    2970. 

  2970.                 if (!(result.Constructor == constructor))

    2971. 

  2971.                 {

    2972. 

  2972.                     Console.WriteLine("Constructor is different from expected.");

    2973. 

  2973.                     return 1;

    2974. 

  2974.                 }

    2975. 

  2975. 

    2976. 

  2976.                 if (!(result.ToString() == str))

    2977. 

  2977.                 {

    2978. 

  2978.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    2979. 

  2979.                     return 1;

    2980. 

  2980.                 }

    2981. 

  2981. 

    2982. 

  2982.                 if (result.Arguments.Count != arguments.Length)

    2983. 

  2983.                 {

    2984. 

  2984.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    2985. 

  2985.                     return 1;

    2986. 

  2986.                 }

    2987. 

  2987. 

    2988. 

  2988.                 for (int i = 0; i < arguments.Length; i++)

    2989. 

  2989.                 {

    2990. 

  2990.                     if (result.Arguments[i] != arguments[i])

    2991. 

  2991.                     {

    2992. 

  2992.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    2993. 

  2993.                         return 1;

    2994. 

  2994.                     }

    2995. 

  2995.                 }

    2996. 

  2996. 

    2997. 

  2997.                 if (result.Members != null)

    2998. 

  2998.                 {

    2999. 

  2999.                     Console.WriteLine("result.Members isn't null");

    3000. 

  3000.                     return 1;

    3001. 

  3001.                 }

    3002. 

  3002. 

    3003. 

  3003.                 return 0;

    3004. 

  3004.             }

    3005. 

  3005. 

    3006. 

  3006.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    3007. 

  3007.             {

    3008. 

  3008.                 if (!(result.NodeType == et))

    3009. 

  3009.                 {

    3010. 

  3010.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3011. 

  3011.                     return 1;

    3012. 

  3012.                 }

    3013. 

  3013.                 if (!(result.Type == type))

    3014. 

  3014.                 {

    3015. 

  3015.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3016. 

  3016.                     return 1;

    3017. 

  3017.                 }

    3018. 

  3018. 

    3019. 

  3019.                 if (!(result.NewExpression == newExpression)) return 1;

    3020. 

  3020. 

    3021. 

  3021.                 if (!(result.ToString() == str))

    3022. 

  3022.                 {

    3023. 

  3023.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3024. 

  3024.                     return 1;

    3025. 

  3025.                 }

    3026. 

  3026. 

    3027. 

  3027.                 if (result.Initializers.Count != initializers.Length) return 1;

    3028. 

  3028. 

    3029. 

  3029.                 for (int i = 0; i < initializers.Length; i++)

    3030. 

  3030.                 {

    3031. 

  3031.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    3032. 

  3032. 

    3033. 

  3033.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    3034. 

  3034. 

    3035. 

  3035.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    3036. 

  3036.                     {

    3037. 

  3037.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    3038. 

  3038.                     }

    3039. 

  3039.                 }

    3040. 

  3040. 

    3041. 

  3041.                 return 0;

    3042. 

  3042.             }

    3043. 

  3043. 

    3044. 

  3044.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    3045. 

  3045.             {

    3046. 

  3046.                 if (result.AddMethod != exp_mi) return 1;

    3047. 

  3047.                 if (!(result.ToString() == str))

    3048. 

  3048.                 {

    3049. 

  3049.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3050. 

  3050.                     return 1;

    3051. 

  3051.                 }

    3052. 

  3052. 

    3053. 

  3053.                 if (result.Arguments.Count != args.Length) return 1;

    3054. 

  3054. 

    3055. 

  3055.                 for (int i = 0; i < args.Length; i++)

    3056. 

  3056.                 {

    3057. 

  3057.                     if (result.Arguments[i] != args[i]) return 1;

    3058. 

  3058.                 }

    3059. 

  3059. 

    3060. 

  3060.                 return 0;

    3061. 

  3061.             }

    3062. 

  3062. 

    3063. 

  3063.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    3064. 

  3064.             {

    3065. 

  3065.                 if (!(result.BindingType == bt)) return 1;

    3066. 

  3066.                 if (!(result.Expression == expr)) return 1;

    3067. 

  3067.                 if (!(result.Member.Equals(member))) return 1;

    3068. 

  3068.                 if (!(result.ToString() == str))

    3069. 

  3069.                 {

    3070. 

  3070.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3071. 

  3071.                     return 1;

    3072. 

  3072.                 }

    3073. 

  3073. 

    3074. 

  3074.                 return 0;

    3075. 

  3075.             }

    3076. 

  3076. 

    3077. 

  3077.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    3078. 

  3078.             {

    3079. 

  3079.                 if (!(result.BindingType == bt)) return 1;

    3080. 

  3080. 

    3081. 

  3081.                 if (!(result.Member.Equals(member))) return 1;

    3082. 

  3082.                 if (!(result.ToString() == str))

    3083. 

  3083.                 {

    3084. 

  3084.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3085. 

  3085.                     return 1;

    3086. 

  3086.                 }

    3087. 

  3087. 

    3088. 

  3088.                 if (result.Initializers.Count != initializers.Length) return 1;

    3089. 

  3089. 

    3090. 

  3090.                 for (int i = 0; i < initializers.Length; i++)

    3091. 

  3091.                 {

    3092. 

  3092.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    3093. 

  3093. 

    3094. 

  3094.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    3095. 

  3095. 

    3096. 

  3096.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    3097. 

  3097.                     {

    3098. 

  3098.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    3099. 

  3099.                     }

    3100. 

  3100.                 }

    3101. 

  3101. 

    3102. 

  3102. 

    3103. 

  3103.                 return 0;

    3104. 

  3104.             }

    3105. 

  3105. 

    3106. 

  3106.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    3107. 

  3107.             {

    3108. 

  3108.                 if (!(result.BindingType == bt)) return 1;

    3109. 

  3109. 

    3110. 

  3110.                 if (!(result.Member.Equals(member))) return 1;

    3111. 

  3111.                 if (!(result.ToString() == str))

    3112. 

  3112.                 {

    3113. 

  3113.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3114. 

  3114.                     return 1;

    3115. 

  3115.                 }

    3116. 

  3116. 

    3117. 

  3117.                 if (result.Bindings.Count != bindings.Length) return 1;

    3118. 

  3118. 

    3119. 

  3119.                 for (int i = 0; i < bindings.Length; i++)

    3120. 

  3120.                 {

    3121. 

  3121.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    3122. 

  3122.                 }

    3123. 

  3123. 

    3124. 

  3124.                 return 0;

    3125. 

  3125.             }

    3126. 

  3126. 

    3127. 

  3127.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    3128. 

  3128.             {

    3129. 

  3129.                 if (!(result.NodeType == et))

    3130. 

  3130.                 {

    3131. 

  3131.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3132. 

  3132.                     return 1;

    3133. 

  3133.                 }

    3134. 

  3134.                 if (!(result.Type == type))

    3135. 

  3135.                 {

    3136. 

  3136.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3137. 

  3137.                     return 1;

    3138. 

  3138.                 }

    3139. 

  3139.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    3140. 

  3140.                 if (!(result.ToString() == str)) return 1;

    3141. 

  3141. 

    3142. 

  3142.                 if (result.Bindings.Count != bindings.Length) return 1;

    3143. 

  3143. 

    3144. 

  3144.                 for (int i = 0; i < bindings.Length; i++)

    3145. 

  3145.                 {

    3146. 

  3146.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    3147. 

  3147.                 }

    3148. 

  3148. 

    3149. 

  3149.                 return 0;

    3150. 

  3150.             }

    3151. 

  3151. 

    3152. 

  3152.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    3153. 

  3153.             {

    3154. 

  3154.                 if (!(result.NodeType == et))

    3155. 

  3155.                 {

    3156. 

  3156.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3157. 

  3157.                     return 1;

    3158. 

  3158.                 }

    3159. 

  3159.                 if (!(result.Type == type))

    3160. 

  3160.                 {

    3161. 

  3161.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3162. 

  3162.                     return 1;

    3163. 

  3163.                 }

    3164. 

  3164. 

    3165. 

  3165.                 if (result.Expressions.Count != expr.Length) return 1;

    3166. 

  3166. 

    3167. 

  3167.                 for (int i = 0; i < expr.Length; i++)

    3168. 

  3168.                 {

    3169. 

  3169.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    3170. 

  3170.                 }

    3171. 

  3171.                 if (!(result.ToString() == str))

    3172. 

  3172.                 {

    3173. 

  3173.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3174. 

  3174.                     return 1;

    3175. 

  3175.                 }

    3176. 

  3176. 

    3177. 

  3177.                 return 0;

    3178. 

  3178.             }

    3179. 

  3179. 

    3180. 

  3180.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    3181. 

  3181.             {

    3182. 

  3182.                 if (!(result.NodeType == et))

    3183. 

  3183.                 {

    3184. 

  3184.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3185. 

  3185.                     return 1;

    3186. 

  3186.                 }

    3187. 

  3187.                 if (!(result.Type == type))

    3188. 

  3188.                 {

    3189. 

  3189.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3190. 

  3190.                     return 1;

    3191. 

  3191.                 }

    3192. 

  3192.                 if (!(result.Name == name)) return 1;

    3193. 

  3193. 

    3194. 

  3194.                 if (!(result.ToString() == str))

    3195. 

  3195.                 {

    3196. 

  3196.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3197. 

  3197.                     return 1;

    3198. 

  3198.                 }

    3199. 

  3199. 

    3200. 

  3200.                 return 0;

    3201. 

  3201.             }

    3202. 

  3202. 

    3203. 

  3203.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    3204. 

  3204.             {

    3205. 

  3205.                 if (!(result.NodeType == et))

    3206. 

  3206.                 {

    3207. 

  3207.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3208. 

  3208.                     return 1;

    3209. 

  3209.                 }

    3210. 

  3210.                 if (!(result.Type == type))

    3211. 

  3211.                 {

    3212. 

  3212.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3213. 

  3213.                     return 1;

    3214. 

  3214.                 }

    3215. 

  3215. 

    3216. 

  3216.                 if (expr == null)

    3217. 

  3217.                 {

    3218. 

  3218.                     if (result.Body != null) return 1;

    3219. 

  3219.                 }

    3220. 

  3220.                 else

    3221. 

  3221.                 {

    3222. 

  3222.                     if (!(result.Body.Equals(expr))) return 1;

    3223. 

  3223.                 }

    3224. 

  3224. 

    3225. 

  3225.                 if (result.Parameters.Count != parms.Length) return 1;

    3226. 

  3226. 

    3227. 

  3227.                 for (int i = 0; i < parms.Length; i++)

    3228. 

  3228.                 {

    3229. 

  3229.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    3230. 

  3230.                 }

    3231. 

  3231. 

    3232. 

  3232.                 if (!(result.ToString() == str))

    3233. 

  3233.                 {

    3234. 

  3234.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3235. 

  3235.                     return 1;

    3236. 

  3236.                 }

    3237. 

  3237. 

    3238. 

  3238.                 return 0;

    3239. 

  3239.             }

    3240. 

  3240. 

    3241. 

  3241.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    3242. 

  3242.             {

    3243. 

  3243.                 if (!(result.NodeType == et))

    3244. 

  3244.                 {

    3245. 

  3245.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3246. 

  3246.                     return 1;

    3247. 

  3247.                 }

    3248. 

  3248.                 if (!(result.Type == type))

    3249. 

  3249.                 {

    3250. 

  3250.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3251. 

  3251.                     return 1;

    3252. 

  3252.                 }

    3253. 

  3253. 

    3254. 

  3254.                 if (expr == null)

    3255. 

  3255.                 {

    3256. 

  3256.                     if (result.Expression != null) return 1;

    3257. 

  3257.                 }

    3258. 

  3258.                 else

    3259. 

  3259.                 {

    3260. 

  3260.                     if (!(result.Expression.Equals(expr))) return 1;

    3261. 

  3261.                 }

    3262. 

  3262. 

    3263. 

  3263.                 if (result.Arguments.Count != args.Length) return 1;

    3264. 

  3264. 

    3265. 

  3265.                 for (int i = 0; i < args.Length; i++)

    3266. 

  3266.                 {

    3267. 

  3267.                     if (!(result.Arguments[i].Equals(args[i])))

    3268. 

  3268.                     {

    3269. 

  3269.                         return 1;

    3270. 

  3270.                     }

    3271. 

  3271.                 }

    3272. 

  3272. 

    3273. 

  3273.                 if (result.ToString() != str)

    3274. 

  3274.                 {

    3275. 

  3275.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    3276. 

  3276.                     return 1;

    3277. 

  3277.                 }

    3278. 

  3278. 

    3279. 

  3279.                 return 0;

    3280. 

  3280.             }

    3281. 

  3281.         }

    3282. 

  3282. 

    3283. 

  3283. 

    3284. 

  3284.     }

    3285. 

  3285. 

    3286. 

  3286.     //-------- Scenario 786

    3287. 

  3287.     namespace Scenario786

    3288. 

  3288.     {

    3289. 

  3289. 

    3290. 

  3290.         namespace Not

    3291. 

  3291.         {

    3292. 

  3292.             public class Test

    3293. 

  3293.             {

    3294. 

  3294.                 // Test for functionality: Argument is of type long?

    3295. 

  3295.                 public static int Test5()

    3296. 

  3296.                 {

    3297. 

  3297.                     ConstantExpression ce = Expression.Constant(null, typeof(long?));

    3298. 

  3298.                     Type exp_type = ce.Type;

    3299. 

  3299.                     ExpressionType exp_et = ExpressionType.Not;

    3300. 

  3300.                     string exp_str = "Not(" + ce.ToString() + ")";

    3301. 

  3301.                     Expression exp_operand = ce;

    3302. 

  3302. 

    3303. 

  3303.                     UnaryExpression result = Expression.Not(ce);

    3304. 

  3304. 

    3305. 

  3305.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, null, true, true);

    3306. 

  3306.                 }

    3307. 

  3307. 

    3308. 

  3308. 

    3309. 

  3309.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not5__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    3310. 

  3310.                 public static Expression Not5__()

    3311. 

  3311.                 {

    3312. 

  3312.                     if (Main() != 0)

    3313. 

  3313.                     {

    3314. 

  3314.                         throw new Exception();

    3315. 

  3315.                     }

    3316. 

  3316.                     else

    3317. 

  3317.                     {

    3318. 

  3318.                         return Expression.Constant(0);

    3319. 

  3319.                     }

    3320. 

  3320.                 }

    3321. 

  3321.                 public static int Main()

    3322. 

  3322.                 {

    3323. 

  3323.                     return Test5();

    3324. 

  3324.                 }

    3325. 

  3325.             }

    3326. 

  3326.         }

    3327. 

  3327. 

    3328. 

  3328. 

    3329. 

  3329.         public static class Extension

    3330. 

  3330.         {

    3331. 

  3331.             public static bool CompareParamName(this ArgumentException ex, string expected)

    3332. 

  3332.             {

    3333. 

  3333. #if SILVERLIGHT

    3334. 

  3334. #if SLRESOURCES

    3335. 

  3335. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    3336. 

  3336. #else

    3337. 

  3337. 			        return true;

    3338. 

  3338. #endif

    3339. 

  3339. #else

    3340. 

  3340.                 return ex.ParamName == expected;

    3341. 

  3341. #endif

    3342. 

  3342.             }

    3343. 

  3343. 

    3344. 

  3344.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    3345. 

  3345.             {

    3346. 

  3346. #if SILVERLIGHT

    3347. 

  3347. #if SLRESOURCES

    3348. 

  3348. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    3349. 

  3349. #else

    3350. 

  3350. 			        return true;

    3351. 

  3351. #endif

    3352. 

  3352. #else

    3353. 

  3353.                 return ex.ParamName == expected;

    3354. 

  3354. #endif

    3355. 

  3355.             }

    3356. 

  3356.         }

    3357. 

  3357. 

    3358. 

  3358.         public static class Verification

    3359. 

  3359.         {

    3360. 

  3360.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    3361. 

  3361.             {

    3362. 

  3362.                 if (!(result.NodeType == et))

    3363. 

  3363.                 {

    3364. 

  3364.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3365. 

  3365.                     return 1;

    3366. 

  3366.                 }

    3367. 

  3367.                 if (!(result.Type == type))

    3368. 

  3368.                 {

    3369. 

  3369.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3370. 

  3370.                     return 1;

    3371. 

  3371.                 }

    3372. 

  3372.                 if (val == null)

    3373. 

  3373.                 {

    3374. 

  3374.                     if (result.Value != null) return 1;

    3375. 

  3375.                 }

    3376. 

  3376.                 else

    3377. 

  3377.                 {

    3378. 

  3378.                     if (!(result.Value.Equals(val))) return 1;

    3379. 

  3379.                 }

    3380. 

  3380.                 if (!(result.ToString() == str)) return 1;

    3381. 

  3381.                 return 0;

    3382. 

  3382.             }

    3383. 

  3383. 

    3384. 

  3384.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    3385. 

  3385.             {

    3386. 

  3386.                 if (!(result.NodeType == et))

    3387. 

  3387.                 {

    3388. 

  3388.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3389. 

  3389.                     return 1;

    3390. 

  3390.                 }

    3391. 

  3391.                 if (!(result.Type == type))

    3392. 

  3392.                 {

    3393. 

  3393.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3394. 

  3394.                     return 1;

    3395. 

  3395.                 }

    3396. 

  3396.                 if (operand == null)

    3397. 

  3397.                 {

    3398. 

  3398.                     if (result.Operand != null) return 1;

    3399. 

  3399.                 }

    3400. 

  3400.                 else

    3401. 

  3401.                 {

    3402. 

  3402.                     if (!(result.Operand.Equals(operand))) return 1;

    3403. 

  3403.                 }

    3404. 

  3404.                 if (!(result.ToString() == str))

    3405. 

  3405.                 {

    3406. 

  3406.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    3407. 

  3407.                     return 1;

    3408. 

  3408.                 }

    3409. 

  3409. 

    3410. 

  3410.                 if (result.Method != mi) return 1;

    3411. 

  3411.                 if (result.IsLifted != islifted) return 1;

    3412. 

  3412.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    3413. 

  3413. 

    3414. 

  3414.                 return 0;

    3415. 

  3415.             }

    3416. 

  3416. 

    3417. 

  3417.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    3418. 

  3418.             {

    3419. 

  3419.                 if (!(result.NodeType == et))

    3420. 

  3420.                 {

    3421. 

  3421.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3422. 

  3422.                     return 1;

    3423. 

  3423.                 }

    3424. 

  3424.                 if (!(result.Type == type))

    3425. 

  3425.                 {

    3426. 

  3426.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3427. 

  3427.                     return 1;

    3428. 

  3428.                 }

    3429. 

  3429. 

    3430. 

  3430.                 if (left == null)

    3431. 

  3431.                 {

    3432. 

  3432.                     if (result.Left != null)

    3433. 

  3433.                     {

    3434. 

  3434.                         Console.WriteLine("left was null");

    3435. 

  3435.                         return 1;

    3436. 

  3436.                     }

    3437. 

  3437.                 }

    3438. 

  3438.                 else

    3439. 

  3439.                 {

    3440. 

  3440.                     if (!(result.Left.Equals(left)))

    3441. 

  3441.                     {

    3442. 

  3442.                         Console.WriteLine("left was different");

    3443. 

  3443.                         return 1;

    3444. 

  3444.                     }

    3445. 

  3445.                 }

    3446. 

  3446. 

    3447. 

  3447.                 if (right == null)

    3448. 

  3448.                 {

    3449. 

  3449.                     if (result.Right != null) return 1;

    3450. 

  3450.                 }

    3451. 

  3451.                 else

    3452. 

  3452.                 {

    3453. 

  3453.                     if (!(result.Right.Equals(right))) return 1;

    3454. 

  3454.                 }

    3455. 

  3455. 

    3456. 

  3456.                 if (!(result.ToString() == str))

    3457. 

  3457.                 {

    3458. 

  3458.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    3459. 

  3459.                     return 1;

    3460. 

  3460.                 }

    3461. 

  3461. 

    3462. 

  3462.                 if (result.Method != mi) return 1;

    3463. 

  3463.                 if (result.IsLifted != islifted) return 1;

    3464. 

  3464.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    3465. 

  3465. 

    3466. 

  3466.                 if (result.Conversion != null) return 1;

    3467. 

  3467. 

    3468. 

  3468.                 return 0;

    3469. 

  3469.             }

    3470. 

  3470. 

    3471. 

  3471.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    3472. 

  3472.             {

    3473. 

  3473.                 if (!(result.NodeType == et))

    3474. 

  3474.                 {

    3475. 

  3475.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3476. 

  3476.                     return 1;

    3477. 

  3477.                 }

    3478. 

  3478.                 if (!(result.Type == type))

    3479. 

  3479.                 {

    3480. 

  3480.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3481. 

  3481.                     return 1;

    3482. 

  3482.                 }

    3483. 

  3483. 

    3484. 

  3484.                 if (left == null)

    3485. 

  3485.                 {

    3486. 

  3486.                     if (result.Left != null) return 1;

    3487. 

  3487.                 }

    3488. 

  3488.                 else

    3489. 

  3489.                 {

    3490. 

  3490.                     if (!(result.Left.Equals(left))) return 1;

    3491. 

  3491.                 }

    3492. 

  3492. 

    3493. 

  3493.                 if (right == null)

    3494. 

  3494.                 {

    3495. 

  3495.                     if (result.Right != null) return 1;

    3496. 

  3496.                 }

    3497. 

  3497.                 else

    3498. 

  3498.                 {

    3499. 

  3499.                     if (!(result.Right.Equals(right))) return 1;

    3500. 

  3500.                 }

    3501. 

  3501. 

    3502. 

  3502.                 if (!(result.ToString() == str)) return 1;

    3503. 

  3503. 

    3504. 

  3504.                 if (result.Method != mi) return 1;

    3505. 

  3505.                 if (result.IsLifted != islifted) return 1;

    3506. 

  3506.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    3507. 

  3507. 

    3508. 

  3508.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    3509. 

  3509. 

    3510. 

  3510.                 return 0;

    3511. 

  3511.             }

    3512. 

  3512. 

    3513. 

  3513.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    3514. 

  3514.             {

    3515. 

  3515.                 if (!(result.NodeType == et))

    3516. 

  3516.                 {

    3517. 

  3517.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3518. 

  3518.                     return 1;

    3519. 

  3519.                 }

    3520. 

  3520.                 if (!(result.Type == type))

    3521. 

  3521.                 {

    3522. 

  3522.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3523. 

  3523.                     return 1;

    3524. 

  3524.                 }

    3525. 

  3525. 

    3526. 

  3526.                 if (!(result.Method == method)) return 1;

    3527. 

  3527. 

    3528. 

  3528.                 if (obj == null)

    3529. 

  3529.                 {

    3530. 

  3530.                     if (result.Object != null)

    3531. 

  3531.                     {

    3532. 

  3532.                         Console.WriteLine("Expected object to be null.");

    3533. 

  3533.                         return 1;

    3534. 

  3534.                     }

    3535. 

  3535.                 }

    3536. 

  3536.                 else

    3537. 

  3537.                 {

    3538. 

  3538.                     if (!(result.Object.Equals(obj)))

    3539. 

  3539.                     {

    3540. 

  3540.                         Console.WriteLine("Object on which call is made is different from the result.");

    3541. 

  3541.                         return 1;

    3542. 

  3542.                     }

    3543. 

  3543.                 }

    3544. 

  3544. 

    3545. 

  3545.                 if (!(result.ToString() == str))

    3546. 

  3546.                 {

    3547. 

  3547.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    3548. 

  3548.                     return 1;

    3549. 

  3549.                 }

    3550. 

  3550. 

    3551. 

  3551.                 if (result.Arguments.Count != arguments.Length) return 1;

    3552. 

  3552. 

    3553. 

  3553.                 for (int i = 0; i < arguments.Length; i++)

    3554. 

  3554.                 {

    3555. 

  3555.                     if (result.Arguments[i] != arguments[i]) return 1;

    3556. 

  3556.                 }

    3557. 

  3557. 

    3558. 

  3558.                 return 0;

    3559. 

  3559.             }

    3560. 

  3560. 

    3561. 

  3561.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    3562. 

  3562.             {

    3563. 

  3563.                 if (!(result.NodeType == et))

    3564. 

  3564.                 {

    3565. 

  3565.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3566. 

  3566.                     return 1;

    3567. 

  3567.                 }

    3568. 

  3568.                 if (!(result.Type == type))

    3569. 

  3569.                 {

    3570. 

  3570.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3571. 

  3571.                     return 1;

    3572. 

  3572.                 }

    3573. 

  3573. 

    3574. 

  3574.                 if (expr == null)

    3575. 

  3575.                 {

    3576. 

  3576.                     Console.WriteLine("expr was null.");

    3577. 

  3577.                     if (result.Expression != null) return 1;

    3578. 

  3578.                 }

    3579. 

  3579.                 else

    3580. 

  3580.                 {

    3581. 

  3581.                     if (!(result.Expression.Equals(expr)))

    3582. 

  3582.                     {

    3583. 

  3583.                         return 1;

    3584. 

  3584.                     }

    3585. 

  3585.                 }

    3586. 

  3586. 

    3587. 

  3587.                 if (!(result.TypeOperand == typeop)) return 1;

    3588. 

  3588. 

    3589. 

  3589.                 if (!(result.ToString() == str))

    3590. 

  3590.                 {

    3591. 

  3591.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    3592. 

  3592.                     return 1;

    3593. 

  3593.                 }

    3594. 

  3594. 

    3595. 

  3595.                 return 0;

    3596. 

  3596.             }

    3597. 

  3597. 

    3598. 

  3598.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    3599. 

  3599.             {

    3600. 

  3600.                 if (!(result.NodeType == et))

    3601. 

  3601.                 {

    3602. 

  3602.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3603. 

  3603.                     return 1;

    3604. 

  3604.                 }

    3605. 

  3605.                 if (!(result.Type == type))

    3606. 

  3606.                 {

    3607. 

  3607.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3608. 

  3608.                     return 1;

    3609. 

  3609.                 }

    3610. 

  3610. 

    3611. 

  3611.                 if (test == null)

    3612. 

  3612.                 {

    3613. 

  3613.                     if (result.Test != null) return 1;

    3614. 

  3614.                 }

    3615. 

  3615.                 else

    3616. 

  3616.                 {

    3617. 

  3617.                     if (!(result.Test.Equals(test))) return 1;

    3618. 

  3618.                 }

    3619. 

  3619. 

    3620. 

  3620.                 if (ifTrue == null)

    3621. 

  3621.                 {

    3622. 

  3622.                     if (result.IfTrue != null) return 1;

    3623. 

  3623.                 }

    3624. 

  3624.                 else

    3625. 

  3625.                 {

    3626. 

  3626.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    3627. 

  3627.                 }

    3628. 

  3628. 

    3629. 

  3629.                 if (ifFalse == null)

    3630. 

  3630.                 {

    3631. 

  3631.                     if (result.IfFalse != null) return 1;

    3632. 

  3632.                 }

    3633. 

  3633.                 else

    3634. 

  3634.                 {

    3635. 

  3635.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    3636. 

  3636.                 }

    3637. 

  3637. 

    3638. 

  3638.                 if (!(result.ToString() == str)) return 1;

    3639. 

  3639. 

    3640. 

  3640.                 return 0;

    3641. 

  3641.             }

    3642. 

  3642. 

    3643. 

  3643.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    3644. 

  3644.             {

    3645. 

  3645.                 if (!(result.NodeType == et))

    3646. 

  3646.                 {

    3647. 

  3647.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3648. 

  3648.                     return 1;

    3649. 

  3649.                 }

    3650. 

  3650.                 if (!(result.Type == type))

    3651. 

  3651.                 {

    3652. 

  3652.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3653. 

  3653.                     return 1;

    3654. 

  3654.                 }

    3655. 

  3655. 

    3656. 

  3656.                 if (exp_expr == null)

    3657. 

  3657.                 {

    3658. 

  3658.                     if (result.Expression != null)

    3659. 

  3659.                     {

    3660. 

  3660.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    3661. 

  3661.                         return 1;

    3662. 

  3662.                     }

    3663. 

  3663.                 }

    3664. 

  3664.                 else

    3665. 

  3665.                 {

    3666. 

  3666.                     if (!(result.Expression.Equals(exp_expr)))

    3667. 

  3667.                     {

    3668. 

  3668.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    3669. 

  3669.                         return 1;

    3670. 

  3670.                     }

    3671. 

  3671.                 }

    3672. 

  3672. 

    3673. 

  3673.                 if (!(result.Member == exp_member))

    3674. 

  3674.                 {

    3675. 

  3675.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    3676. 

  3676.                     return 1;

    3677. 

  3677.                 }

    3678. 

  3678. 

    3679. 

  3679.                 if (!(result.ToString() == str))

    3680. 

  3680.                 {

    3681. 

  3681.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3682. 

  3682.                     return 1;

    3683. 

  3683.                 }

    3684. 

  3684. 

    3685. 

  3685.                 return 0;

    3686. 

  3686.             }

    3687. 

  3687. 

    3688. 

  3688.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    3689. 

  3689.             {

    3690. 

  3690.                 if (!(result.NodeType == et))

    3691. 

  3691.                 {

    3692. 

  3692.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3693. 

  3693.                     return 1;

    3694. 

  3694.                 }

    3695. 

  3695.                 if (!(result.Type == type))

    3696. 

  3696.                 {

    3697. 

  3697.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3698. 

  3698.                     return 1;

    3699. 

  3699.                 }

    3700. 

  3700. 

    3701. 

  3701.                 if (!(result.Constructor == constructor))

    3702. 

  3702.                 {

    3703. 

  3703.                     Console.WriteLine("Unexpected constructor");

    3704. 

  3704.                     return 1;

    3705. 

  3705.                 }

    3706. 

  3706. 

    3707. 

  3707.                 if (!(result.ToString() == str))

    3708. 

  3708.                 {

    3709. 

  3709.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3710. 

  3710.                     return 1;

    3711. 

  3711.                 }

    3712. 

  3712. 

    3713. 

  3713.                 if (arguments == null)

    3714. 

  3714.                 {

    3715. 

  3715.                     if (result.Arguments.Count != 0)

    3716. 

  3716.                     {

    3717. 

  3717.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    3718. 

  3718.                         return 1;

    3719. 

  3719.                     }

    3720. 

  3720.                 }

    3721. 

  3721.                 else

    3722. 

  3722.                 {

    3723. 

  3723.                     if (result.Arguments.Count != arguments.Length)

    3724. 

  3724.                     {

    3725. 

  3725.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    3726. 

  3726.                         return 1;

    3727. 

  3727.                     }

    3728. 

  3728.                     for (int i = 0; i < arguments.Length; i++)

    3729. 

  3729.                     {

    3730. 

  3730.                         if (result.Arguments[i] != arguments[i])

    3731. 

  3731.                         {

    3732. 

  3732.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    3733. 

  3733.                             return 1;

    3734. 

  3734.                         }

    3735. 

  3735.                     }

    3736. 

  3736.                 }

    3737. 

  3737. 

    3738. 

  3738.                 if (result.Members == null)

    3739. 

  3739.                 {

    3740. 

  3740.                     Console.WriteLine("result.Members was null");

    3741. 

  3741.                     return 1;

    3742. 

  3742.                 }

    3743. 

  3743. 

    3744. 

  3744.                 if (members == null)

    3745. 

  3745.                 {

    3746. 

  3746.                     if (result.Members.Count != 0)

    3747. 

  3747.                     {

    3748. 

  3748.                         Console.WriteLine("Got more than zero members");

    3749. 

  3749.                         return 1;

    3750. 

  3750.                     }

    3751. 

  3751.                 }

    3752. 

  3752.                 else

    3753. 

  3753.                 {

    3754. 

  3754.                     if (result.Members.Count != members.Length)

    3755. 

  3755.                     {

    3756. 

  3756.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    3757. 

  3757.                         return 1;

    3758. 

  3758.                     }

    3759. 

  3759. 

    3760. 

  3760.                     for (int i = 0; i < members.Length; i++)

    3761. 

  3761.                     {

    3762. 

  3762.                         if (result.Members[i] != members[i])

    3763. 

  3763.                         {

    3764. 

  3764.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    3765. 

  3765.                             return 1;

    3766. 

  3766.                         }

    3767. 

  3767.                     }

    3768. 

  3768.                 }

    3769. 

  3769. 

    3770. 

  3770.                 return 0;

    3771. 

  3771.             }

    3772. 

  3772. 

    3773. 

  3773.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    3774. 

  3774.             {

    3775. 

  3775.                 if (!(result.NodeType == et))

    3776. 

  3776.                 {

    3777. 

  3777.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3778. 

  3778.                     return 1;

    3779. 

  3779.                 }

    3780. 

  3780.                 if (!(result.Type == type))

    3781. 

  3781.                 {

    3782. 

  3782.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3783. 

  3783.                     return 1;

    3784. 

  3784.                 }

    3785. 

  3785. 

    3786. 

  3786.                 if (!(result.Constructor == constructor))

    3787. 

  3787.                 {

    3788. 

  3788.                     Console.WriteLine("Constructor is different from expected.");

    3789. 

  3789.                     return 1;

    3790. 

  3790.                 }

    3791. 

  3791. 

    3792. 

  3792.                 if (!(result.ToString() == str))

    3793. 

  3793.                 {

    3794. 

  3794.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3795. 

  3795.                     return 1;

    3796. 

  3796.                 }

    3797. 

  3797. 

    3798. 

  3798.                 if (result.Arguments.Count != arguments.Length)

    3799. 

  3799.                 {

    3800. 

  3800.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    3801. 

  3801.                     return 1;

    3802. 

  3802.                 }

    3803. 

  3803. 

    3804. 

  3804.                 for (int i = 0; i < arguments.Length; i++)

    3805. 

  3805.                 {

    3806. 

  3806.                     if (result.Arguments[i] != arguments[i])

    3807. 

  3807.                     {

    3808. 

  3808.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    3809. 

  3809.                         return 1;

    3810. 

  3810.                     }

    3811. 

  3811.                 }

    3812. 

  3812. 

    3813. 

  3813.                 if (result.Members != null)

    3814. 

  3814.                 {

    3815. 

  3815.                     Console.WriteLine("result.Members isn't null");

    3816. 

  3816.                     return 1;

    3817. 

  3817.                 }

    3818. 

  3818. 

    3819. 

  3819.                 return 0;

    3820. 

  3820.             }

    3821. 

  3821. 

    3822. 

  3822.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    3823. 

  3823.             {

    3824. 

  3824.                 if (!(result.NodeType == et))

    3825. 

  3825.                 {

    3826. 

  3826.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3827. 

  3827.                     return 1;

    3828. 

  3828.                 }

    3829. 

  3829.                 if (!(result.Type == type))

    3830. 

  3830.                 {

    3831. 

  3831.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3832. 

  3832.                     return 1;

    3833. 

  3833.                 }

    3834. 

  3834. 

    3835. 

  3835.                 if (!(result.NewExpression == newExpression)) return 1;

    3836. 

  3836. 

    3837. 

  3837.                 if (!(result.ToString() == str))

    3838. 

  3838.                 {

    3839. 

  3839.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3840. 

  3840.                     return 1;

    3841. 

  3841.                 }

    3842. 

  3842. 

    3843. 

  3843.                 if (result.Initializers.Count != initializers.Length) return 1;

    3844. 

  3844. 

    3845. 

  3845.                 for (int i = 0; i < initializers.Length; i++)

    3846. 

  3846.                 {

    3847. 

  3847.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    3848. 

  3848. 

    3849. 

  3849.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    3850. 

  3850. 

    3851. 

  3851.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    3852. 

  3852.                     {

    3853. 

  3853.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    3854. 

  3854.                     }

    3855. 

  3855.                 }

    3856. 

  3856. 

    3857. 

  3857.                 return 0;

    3858. 

  3858.             }

    3859. 

  3859. 

    3860. 

  3860.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    3861. 

  3861.             {

    3862. 

  3862.                 if (result.AddMethod != exp_mi) return 1;

    3863. 

  3863.                 if (!(result.ToString() == str))

    3864. 

  3864.                 {

    3865. 

  3865.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3866. 

  3866.                     return 1;

    3867. 

  3867.                 }

    3868. 

  3868. 

    3869. 

  3869.                 if (result.Arguments.Count != args.Length) return 1;

    3870. 

  3870. 

    3871. 

  3871.                 for (int i = 0; i < args.Length; i++)

    3872. 

  3872.                 {

    3873. 

  3873.                     if (result.Arguments[i] != args[i]) return 1;

    3874. 

  3874.                 }

    3875. 

  3875. 

    3876. 

  3876.                 return 0;

    3877. 

  3877.             }

    3878. 

  3878. 

    3879. 

  3879.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    3880. 

  3880.             {

    3881. 

  3881.                 if (!(result.BindingType == bt)) return 1;

    3882. 

  3882.                 if (!(result.Expression == expr)) return 1;

    3883. 

  3883.                 if (!(result.Member.Equals(member))) return 1;

    3884. 

  3884.                 if (!(result.ToString() == str))

    3885. 

  3885.                 {

    3886. 

  3886.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3887. 

  3887.                     return 1;

    3888. 

  3888.                 }

    3889. 

  3889. 

    3890. 

  3890.                 return 0;

    3891. 

  3891.             }

    3892. 

  3892. 

    3893. 

  3893.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    3894. 

  3894.             {

    3895. 

  3895.                 if (!(result.BindingType == bt)) return 1;

    3896. 

  3896. 

    3897. 

  3897.                 if (!(result.Member.Equals(member))) return 1;

    3898. 

  3898.                 if (!(result.ToString() == str))

    3899. 

  3899.                 {

    3900. 

  3900.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3901. 

  3901.                     return 1;

    3902. 

  3902.                 }

    3903. 

  3903. 

    3904. 

  3904.                 if (result.Initializers.Count != initializers.Length) return 1;

    3905. 

  3905. 

    3906. 

  3906.                 for (int i = 0; i < initializers.Length; i++)

    3907. 

  3907.                 {

    3908. 

  3908.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    3909. 

  3909. 

    3910. 

  3910.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    3911. 

  3911. 

    3912. 

  3912.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    3913. 

  3913.                     {

    3914. 

  3914.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    3915. 

  3915.                     }

    3916. 

  3916.                 }

    3917. 

  3917. 

    3918. 

  3918. 

    3919. 

  3919.                 return 0;

    3920. 

  3920.             }

    3921. 

  3921. 

    3922. 

  3922.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    3923. 

  3923.             {

    3924. 

  3924.                 if (!(result.BindingType == bt)) return 1;

    3925. 

  3925. 

    3926. 

  3926.                 if (!(result.Member.Equals(member))) return 1;

    3927. 

  3927.                 if (!(result.ToString() == str))

    3928. 

  3928.                 {

    3929. 

  3929.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3930. 

  3930.                     return 1;

    3931. 

  3931.                 }

    3932. 

  3932. 

    3933. 

  3933.                 if (result.Bindings.Count != bindings.Length) return 1;

    3934. 

  3934. 

    3935. 

  3935.                 for (int i = 0; i < bindings.Length; i++)

    3936. 

  3936.                 {

    3937. 

  3937.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    3938. 

  3938.                 }

    3939. 

  3939. 

    3940. 

  3940.                 return 0;

    3941. 

  3941.             }

    3942. 

  3942. 

    3943. 

  3943.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    3944. 

  3944.             {

    3945. 

  3945.                 if (!(result.NodeType == et))

    3946. 

  3946.                 {

    3947. 

  3947.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3948. 

  3948.                     return 1;

    3949. 

  3949.                 }

    3950. 

  3950.                 if (!(result.Type == type))

    3951. 

  3951.                 {

    3952. 

  3952.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3953. 

  3953.                     return 1;

    3954. 

  3954.                 }

    3955. 

  3955.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    3956. 

  3956.                 if (!(result.ToString() == str)) return 1;

    3957. 

  3957. 

    3958. 

  3958.                 if (result.Bindings.Count != bindings.Length) return 1;

    3959. 

  3959. 

    3960. 

  3960.                 for (int i = 0; i < bindings.Length; i++)

    3961. 

  3961.                 {

    3962. 

  3962.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    3963. 

  3963.                 }

    3964. 

  3964. 

    3965. 

  3965.                 return 0;

    3966. 

  3966.             }

    3967. 

  3967. 

    3968. 

  3968.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    3969. 

  3969.             {

    3970. 

  3970.                 if (!(result.NodeType == et))

    3971. 

  3971.                 {

    3972. 

  3972.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    3973. 

  3973.                     return 1;

    3974. 

  3974.                 }

    3975. 

  3975.                 if (!(result.Type == type))

    3976. 

  3976.                 {

    3977. 

  3977.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    3978. 

  3978.                     return 1;

    3979. 

  3979.                 }

    3980. 

  3980. 

    3981. 

  3981.                 if (result.Expressions.Count != expr.Length) return 1;

    3982. 

  3982. 

    3983. 

  3983.                 for (int i = 0; i < expr.Length; i++)

    3984. 

  3984.                 {

    3985. 

  3985.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    3986. 

  3986.                 }

    3987. 

  3987.                 if (!(result.ToString() == str))

    3988. 

  3988.                 {

    3989. 

  3989.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    3990. 

  3990.                     return 1;

    3991. 

  3991.                 }

    3992. 

  3992. 

    3993. 

  3993.                 return 0;

    3994. 

  3994.             }

    3995. 

  3995. 

    3996. 

  3996.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    3997. 

  3997.             {

    3998. 

  3998.                 if (!(result.NodeType == et))

    3999. 

  3999.                 {

    4000. 

  4000.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4001. 

  4001.                     return 1;

    4002. 

  4002.                 }

    4003. 

  4003.                 if (!(result.Type == type))

    4004. 

  4004.                 {

    4005. 

  4005.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4006. 

  4006.                     return 1;

    4007. 

  4007.                 }

    4008. 

  4008.                 if (!(result.Name == name)) return 1;

    4009. 

  4009. 

    4010. 

  4010.                 if (!(result.ToString() == str))

    4011. 

  4011.                 {

    4012. 

  4012.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4013. 

  4013.                     return 1;

    4014. 

  4014.                 }

    4015. 

  4015. 

    4016. 

  4016.                 return 0;

    4017. 

  4017.             }

    4018. 

  4018. 

    4019. 

  4019.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    4020. 

  4020.             {

    4021. 

  4021.                 if (!(result.NodeType == et))

    4022. 

  4022.                 {

    4023. 

  4023.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4024. 

  4024.                     return 1;

    4025. 

  4025.                 }

    4026. 

  4026.                 if (!(result.Type == type))

    4027. 

  4027.                 {

    4028. 

  4028.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4029. 

  4029.                     return 1;

    4030. 

  4030.                 }

    4031. 

  4031. 

    4032. 

  4032.                 if (expr == null)

    4033. 

  4033.                 {

    4034. 

  4034.                     if (result.Body != null) return 1;

    4035. 

  4035.                 }

    4036. 

  4036.                 else

    4037. 

  4037.                 {

    4038. 

  4038.                     if (!(result.Body.Equals(expr))) return 1;

    4039. 

  4039.                 }

    4040. 

  4040. 

    4041. 

  4041.                 if (result.Parameters.Count != parms.Length) return 1;

    4042. 

  4042. 

    4043. 

  4043.                 for (int i = 0; i < parms.Length; i++)

    4044. 

  4044.                 {

    4045. 

  4045.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    4046. 

  4046.                 }

    4047. 

  4047. 

    4048. 

  4048.                 if (!(result.ToString() == str))

    4049. 

  4049.                 {

    4050. 

  4050.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4051. 

  4051.                     return 1;

    4052. 

  4052.                 }

    4053. 

  4053. 

    4054. 

  4054.                 return 0;

    4055. 

  4055.             }

    4056. 

  4056. 

    4057. 

  4057.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    4058. 

  4058.             {

    4059. 

  4059.                 if (!(result.NodeType == et))

    4060. 

  4060.                 {

    4061. 

  4061.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4062. 

  4062.                     return 1;

    4063. 

  4063.                 }

    4064. 

  4064.                 if (!(result.Type == type))

    4065. 

  4065.                 {

    4066. 

  4066.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4067. 

  4067.                     return 1;

    4068. 

  4068.                 }

    4069. 

  4069. 

    4070. 

  4070.                 if (expr == null)

    4071. 

  4071.                 {

    4072. 

  4072.                     if (result.Expression != null) return 1;

    4073. 

  4073.                 }

    4074. 

  4074.                 else

    4075. 

  4075.                 {

    4076. 

  4076.                     if (!(result.Expression.Equals(expr))) return 1;

    4077. 

  4077.                 }

    4078. 

  4078. 

    4079. 

  4079.                 if (result.Arguments.Count != args.Length) return 1;

    4080. 

  4080. 

    4081. 

  4081.                 for (int i = 0; i < args.Length; i++)

    4082. 

  4082.                 {

    4083. 

  4083.                     if (!(result.Arguments[i].Equals(args[i])))

    4084. 

  4084.                     {

    4085. 

  4085.                         return 1;

    4086. 

  4086.                     }

    4087. 

  4087.                 }

    4088. 

  4088. 

    4089. 

  4089.                 if (result.ToString() != str)

    4090. 

  4090.                 {

    4091. 

  4091.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4092. 

  4092.                     return 1;

    4093. 

  4093.                 }

    4094. 

  4094. 

    4095. 

  4095.                 return 0;

    4096. 

  4096.             }

    4097. 

  4097.         }

    4098. 

  4098. 

    4099. 

  4099. 

    4100. 

  4100.     }

    4101. 

  4101. 

    4102. 

  4102.     //-------- Scenario 787

    4103. 

  4103.     namespace Scenario787

    4104. 

  4104.     {

    4105. 

  4105. 

    4106. 

  4106.         namespace Not

    4107. 

  4107.         {

    4108. 

  4108.             public class Test

    4109. 

  4109.             {

    4110. 

  4110.                 // Test for functionality: Argument is of type string

    4111. 

  4111.                 public static int Test6()

    4112. 

  4112.                 {

    4113. 

  4113.                     ConstantExpression ce = Expression.Constant("Test");

    4114. 

  4114. 

    4115. 

  4115.                     try

    4116. 

  4116.                     {

    4117. 

  4117.                         UnaryExpression result = Expression.Not(ce);

    4118. 

  4118.                         return 1;

    4119. 

  4119.                     }

    4120. 

  4120.                     catch (InvalidOperationException)

    4121. 

  4121.                     {

    4122. 

  4122.                         return 0;

    4123. 

  4123.                     }

    4124. 

  4124.                 }

    4125. 

  4125. 

    4126. 

  4126. 

    4127. 

  4127.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not6__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    4128. 

  4128.                 public static Expression Not6__()

    4129. 

  4129.                 {

    4130. 

  4130.                     if (Main() != 0)

    4131. 

  4131.                     {

    4132. 

  4132.                         throw new Exception();

    4133. 

  4133.                     }

    4134. 

  4134.                     else

    4135. 

  4135.                     {

    4136. 

  4136.                         return Expression.Constant(0);

    4137. 

  4137.                     }

    4138. 

  4138.                 }

    4139. 

  4139.                 public static int Main()

    4140. 

  4140.                 {

    4141. 

  4141.                     return Test6();

    4142. 

  4142.                 }

    4143. 

  4143.             }

    4144. 

  4144.         }

    4145. 

  4145. 

    4146. 

  4146. 

    4147. 

  4147.         public static class Extension

    4148. 

  4148.         {

    4149. 

  4149.             public static bool CompareParamName(this ArgumentException ex, string expected)

    4150. 

  4150.             {

    4151. 

  4151. #if SILVERLIGHT

    4152. 

  4152. #if SLRESOURCES

    4153. 

  4153. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    4154. 

  4154. #else

    4155. 

  4155. 			        return true;

    4156. 

  4156. #endif

    4157. 

  4157. #else

    4158. 

  4158.                 return ex.ParamName == expected;

    4159. 

  4159. #endif

    4160. 

  4160.             }

    4161. 

  4161. 

    4162. 

  4162.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    4163. 

  4163.             {

    4164. 

  4164. #if SILVERLIGHT

    4165. 

  4165. #if SLRESOURCES

    4166. 

  4166. 			        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    4167. 

  4167. #else

    4168. 

  4168. 			        return true;

    4169. 

  4169. #endif

    4170. 

  4170. #else

    4171. 

  4171.                 return ex.ParamName == expected;

    4172. 

  4172. #endif

    4173. 

  4173.             }

    4174. 

  4174.         }

    4175. 

  4175. 

    4176. 

  4176.         public static class Verification

    4177. 

  4177.         {

    4178. 

  4178.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    4179. 

  4179.             {

    4180. 

  4180.                 if (!(result.NodeType == et))

    4181. 

  4181.                 {

    4182. 

  4182.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4183. 

  4183.                     return 1;

    4184. 

  4184.                 }

    4185. 

  4185.                 if (!(result.Type == type))

    4186. 

  4186.                 {

    4187. 

  4187.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4188. 

  4188.                     return 1;

    4189. 

  4189.                 }

    4190. 

  4190.                 if (val == null)

    4191. 

  4191.                 {

    4192. 

  4192.                     if (result.Value != null) return 1;

    4193. 

  4193.                 }

    4194. 

  4194.                 else

    4195. 

  4195.                 {

    4196. 

  4196.                     if (!(result.Value.Equals(val))) return 1;

    4197. 

  4197.                 }

    4198. 

  4198.                 if (!(result.ToString() == str)) return 1;

    4199. 

  4199.                 return 0;

    4200. 

  4200.             }

    4201. 

  4201. 

    4202. 

  4202.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    4203. 

  4203.             {

    4204. 

  4204.                 if (!(result.NodeType == et))

    4205. 

  4205.                 {

    4206. 

  4206.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4207. 

  4207.                     return 1;

    4208. 

  4208.                 }

    4209. 

  4209.                 if (!(result.Type == type))

    4210. 

  4210.                 {

    4211. 

  4211.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4212. 

  4212.                     return 1;

    4213. 

  4213.                 }

    4214. 

  4214.                 if (operand == null)

    4215. 

  4215.                 {

    4216. 

  4216.                     if (result.Operand != null) return 1;

    4217. 

  4217.                 }

    4218. 

  4218.                 else

    4219. 

  4219.                 {

    4220. 

  4220.                     if (!(result.Operand.Equals(operand))) return 1;

    4221. 

  4221.                 }

    4222. 

  4222.                 if (!(result.ToString() == str))

    4223. 

  4223.                 {

    4224. 

  4224.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4225. 

  4225.                     return 1;

    4226. 

  4226.                 }

    4227. 

  4227. 

    4228. 

  4228.                 if (result.Method != mi) return 1;

    4229. 

  4229.                 if (result.IsLifted != islifted) return 1;

    4230. 

  4230.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    4231. 

  4231. 

    4232. 

  4232.                 return 0;

    4233. 

  4233.             }

    4234. 

  4234. 

    4235. 

  4235.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    4236. 

  4236.             {

    4237. 

  4237.                 if (!(result.NodeType == et))

    4238. 

  4238.                 {

    4239. 

  4239.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4240. 

  4240.                     return 1;

    4241. 

  4241.                 }

    4242. 

  4242.                 if (!(result.Type == type))

    4243. 

  4243.                 {

    4244. 

  4244.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4245. 

  4245.                     return 1;

    4246. 

  4246.                 }

    4247. 

  4247. 

    4248. 

  4248.                 if (left == null)

    4249. 

  4249.                 {

    4250. 

  4250.                     if (result.Left != null)

    4251. 

  4251.                     {

    4252. 

  4252.                         Console.WriteLine("left was null");

    4253. 

  4253.                         return 1;

    4254. 

  4254.                     }

    4255. 

  4255.                 }

    4256. 

  4256.                 else

    4257. 

  4257.                 {

    4258. 

  4258.                     if (!(result.Left.Equals(left)))

    4259. 

  4259.                     {

    4260. 

  4260.                         Console.WriteLine("left was different");

    4261. 

  4261.                         return 1;

    4262. 

  4262.                     }

    4263. 

  4263.                 }

    4264. 

  4264. 

    4265. 

  4265.                 if (right == null)

    4266. 

  4266.                 {

    4267. 

  4267.                     if (result.Right != null) return 1;

    4268. 

  4268.                 }

    4269. 

  4269.                 else

    4270. 

  4270.                 {

    4271. 

  4271.                     if (!(result.Right.Equals(right))) return 1;

    4272. 

  4272.                 }

    4273. 

  4273. 

    4274. 

  4274.                 if (!(result.ToString() == str))

    4275. 

  4275.                 {

    4276. 

  4276.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4277. 

  4277.                     return 1;

    4278. 

  4278.                 }

    4279. 

  4279. 

    4280. 

  4280.                 if (result.Method != mi) return 1;

    4281. 

  4281.                 if (result.IsLifted != islifted) return 1;

    4282. 

  4282.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    4283. 

  4283. 

    4284. 

  4284.                 if (result.Conversion != null) return 1;

    4285. 

  4285. 

    4286. 

  4286.                 return 0;

    4287. 

  4287.             }

    4288. 

  4288. 

    4289. 

  4289.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    4290. 

  4290.             {

    4291. 

  4291.                 if (!(result.NodeType == et))

    4292. 

  4292.                 {

    4293. 

  4293.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4294. 

  4294.                     return 1;

    4295. 

  4295.                 }

    4296. 

  4296.                 if (!(result.Type == type))

    4297. 

  4297.                 {

    4298. 

  4298.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4299. 

  4299.                     return 1;

    4300. 

  4300.                 }

    4301. 

  4301. 

    4302. 

  4302.                 if (left == null)

    4303. 

  4303.                 {

    4304. 

  4304.                     if (result.Left != null) return 1;

    4305. 

  4305.                 }

    4306. 

  4306.                 else

    4307. 

  4307.                 {

    4308. 

  4308.                     if (!(result.Left.Equals(left))) return 1;

    4309. 

  4309.                 }

    4310. 

  4310. 

    4311. 

  4311.                 if (right == null)

    4312. 

  4312.                 {

    4313. 

  4313.                     if (result.Right != null) return 1;

    4314. 

  4314.                 }

    4315. 

  4315.                 else

    4316. 

  4316.                 {

    4317. 

  4317.                     if (!(result.Right.Equals(right))) return 1;

    4318. 

  4318.                 }

    4319. 

  4319. 

    4320. 

  4320.                 if (!(result.ToString() == str)) return 1;

    4321. 

  4321. 

    4322. 

  4322.                 if (result.Method != mi) return 1;

    4323. 

  4323.                 if (result.IsLifted != islifted) return 1;

    4324. 

  4324.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    4325. 

  4325. 

    4326. 

  4326.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    4327. 

  4327. 

    4328. 

  4328.                 return 0;

    4329. 

  4329.             }

    4330. 

  4330. 

    4331. 

  4331.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    4332. 

  4332.             {

    4333. 

  4333.                 if (!(result.NodeType == et))

    4334. 

  4334.                 {

    4335. 

  4335.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4336. 

  4336.                     return 1;

    4337. 

  4337.                 }

    4338. 

  4338.                 if (!(result.Type == type))

    4339. 

  4339.                 {

    4340. 

  4340.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4341. 

  4341.                     return 1;

    4342. 

  4342.                 }

    4343. 

  4343. 

    4344. 

  4344.                 if (!(result.Method == method)) return 1;

    4345. 

  4345. 

    4346. 

  4346.                 if (obj == null)

    4347. 

  4347.                 {

    4348. 

  4348.                     if (result.Object != null)

    4349. 

  4349.                     {

    4350. 

  4350.                         Console.WriteLine("Expected object to be null.");

    4351. 

  4351.                         return 1;

    4352. 

  4352.                     }

    4353. 

  4353.                 }

    4354. 

  4354.                 else

    4355. 

  4355.                 {

    4356. 

  4356.                     if (!(result.Object.Equals(obj)))

    4357. 

  4357.                     {

    4358. 

  4358.                         Console.WriteLine("Object on which call is made is different from the result.");

    4359. 

  4359.                         return 1;

    4360. 

  4360.                     }

    4361. 

  4361.                 }

    4362. 

  4362. 

    4363. 

  4363.                 if (!(result.ToString() == str))

    4364. 

  4364.                 {

    4365. 

  4365.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4366. 

  4366.                     return 1;

    4367. 

  4367.                 }

    4368. 

  4368. 

    4369. 

  4369.                 if (result.Arguments.Count != arguments.Length) return 1;

    4370. 

  4370. 

    4371. 

  4371.                 for (int i = 0; i < arguments.Length; i++)

    4372. 

  4372.                 {

    4373. 

  4373.                     if (result.Arguments[i] != arguments[i]) return 1;

    4374. 

  4374.                 }

    4375. 

  4375. 

    4376. 

  4376.                 return 0;

    4377. 

  4377.             }

    4378. 

  4378. 

    4379. 

  4379.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    4380. 

  4380.             {

    4381. 

  4381.                 if (!(result.NodeType == et))

    4382. 

  4382.                 {

    4383. 

  4383.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4384. 

  4384.                     return 1;

    4385. 

  4385.                 }

    4386. 

  4386.                 if (!(result.Type == type))

    4387. 

  4387.                 {

    4388. 

  4388.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4389. 

  4389.                     return 1;

    4390. 

  4390.                 }

    4391. 

  4391. 

    4392. 

  4392.                 if (expr == null)

    4393. 

  4393.                 {

    4394. 

  4394.                     Console.WriteLine("expr was null.");

    4395. 

  4395.                     if (result.Expression != null) return 1;

    4396. 

  4396.                 }

    4397. 

  4397.                 else

    4398. 

  4398.                 {

    4399. 

  4399.                     if (!(result.Expression.Equals(expr)))

    4400. 

  4400.                     {

    4401. 

  4401.                         return 1;

    4402. 

  4402.                     }

    4403. 

  4403.                 }

    4404. 

  4404. 

    4405. 

  4405.                 if (!(result.TypeOperand == typeop)) return 1;

    4406. 

  4406. 

    4407. 

  4407.                 if (!(result.ToString() == str))

    4408. 

  4408.                 {

    4409. 

  4409.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4410. 

  4410.                     return 1;

    4411. 

  4411.                 }

    4412. 

  4412. 

    4413. 

  4413.                 return 0;

    4414. 

  4414.             }

    4415. 

  4415. 

    4416. 

  4416.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    4417. 

  4417.             {

    4418. 

  4418.                 if (!(result.NodeType == et))

    4419. 

  4419.                 {

    4420. 

  4420.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4421. 

  4421.                     return 1;

    4422. 

  4422.                 }

    4423. 

  4423.                 if (!(result.Type == type))

    4424. 

  4424.                 {

    4425. 

  4425.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4426. 

  4426.                     return 1;

    4427. 

  4427.                 }

    4428. 

  4428. 

    4429. 

  4429.                 if (test == null)

    4430. 

  4430.                 {

    4431. 

  4431.                     if (result.Test != null) return 1;

    4432. 

  4432.                 }

    4433. 

  4433.                 else

    4434. 

  4434.                 {

    4435. 

  4435.                     if (!(result.Test.Equals(test))) return 1;

    4436. 

  4436.                 }

    4437. 

  4437. 

    4438. 

  4438.                 if (ifTrue == null)

    4439. 

  4439.                 {

    4440. 

  4440.                     if (result.IfTrue != null) return 1;

    4441. 

  4441.                 }

    4442. 

  4442.                 else

    4443. 

  4443.                 {

    4444. 

  4444.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    4445. 

  4445.                 }

    4446. 

  4446. 

    4447. 

  4447.                 if (ifFalse == null)

    4448. 

  4448.                 {

    4449. 

  4449.                     if (result.IfFalse != null) return 1;

    4450. 

  4450.                 }

    4451. 

  4451.                 else

    4452. 

  4452.                 {

    4453. 

  4453.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    4454. 

  4454.                 }

    4455. 

  4455. 

    4456. 

  4456.                 if (!(result.ToString() == str)) return 1;

    4457. 

  4457. 

    4458. 

  4458.                 return 0;

    4459. 

  4459.             }

    4460. 

  4460. 

    4461. 

  4461.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    4462. 

  4462.             {

    4463. 

  4463.                 if (!(result.NodeType == et))

    4464. 

  4464.                 {

    4465. 

  4465.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4466. 

  4466.                     return 1;

    4467. 

  4467.                 }

    4468. 

  4468.                 if (!(result.Type == type))

    4469. 

  4469.                 {

    4470. 

  4470.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4471. 

  4471.                     return 1;

    4472. 

  4472.                 }

    4473. 

  4473. 

    4474. 

  4474.                 if (exp_expr == null)

    4475. 

  4475.                 {

    4476. 

  4476.                     if (result.Expression != null)

    4477. 

  4477.                     {

    4478. 

  4478.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    4479. 

  4479.                         return 1;

    4480. 

  4480.                     }

    4481. 

  4481.                 }

    4482. 

  4482.                 else

    4483. 

  4483.                 {

    4484. 

  4484.                     if (!(result.Expression.Equals(exp_expr)))

    4485. 

  4485.                     {

    4486. 

  4486.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    4487. 

  4487.                         return 1;

    4488. 

  4488.                     }

    4489. 

  4489.                 }

    4490. 

  4490. 

    4491. 

  4491.                 if (!(result.Member == exp_member))

    4492. 

  4492.                 {

    4493. 

  4493.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    4494. 

  4494.                     return 1;

    4495. 

  4495.                 }

    4496. 

  4496. 

    4497. 

  4497.                 if (!(result.ToString() == str))

    4498. 

  4498.                 {

    4499. 

  4499.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4500. 

  4500.                     return 1;

    4501. 

  4501.                 }

    4502. 

  4502. 

    4503. 

  4503.                 return 0;

    4504. 

  4504.             }

    4505. 

  4505. 

    4506. 

  4506.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    4507. 

  4507.             {

    4508. 

  4508.                 if (!(result.NodeType == et))

    4509. 

  4509.                 {

    4510. 

  4510.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4511. 

  4511.                     return 1;

    4512. 

  4512.                 }

    4513. 

  4513.                 if (!(result.Type == type))

    4514. 

  4514.                 {

    4515. 

  4515.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4516. 

  4516.                     return 1;

    4517. 

  4517.                 }

    4518. 

  4518. 

    4519. 

  4519.                 if (!(result.Constructor == constructor))

    4520. 

  4520.                 {

    4521. 

  4521.                     Console.WriteLine("Unexpected constructor");

    4522. 

  4522.                     return 1;

    4523. 

  4523.                 }

    4524. 

  4524. 

    4525. 

  4525.                 if (!(result.ToString() == str))

    4526. 

  4526.                 {

    4527. 

  4527.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4528. 

  4528.                     return 1;

    4529. 

  4529.                 }

    4530. 

  4530. 

    4531. 

  4531.                 if (arguments == null)

    4532. 

  4532.                 {

    4533. 

  4533.                     if (result.Arguments.Count != 0)

    4534. 

  4534.                     {

    4535. 

  4535.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    4536. 

  4536.                         return 1;

    4537. 

  4537.                     }

    4538. 

  4538.                 }

    4539. 

  4539.                 else

    4540. 

  4540.                 {

    4541. 

  4541.                     if (result.Arguments.Count != arguments.Length)

    4542. 

  4542.                     {

    4543. 

  4543.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    4544. 

  4544.                         return 1;

    4545. 

  4545.                     }

    4546. 

  4546.                     for (int i = 0; i < arguments.Length; i++)

    4547. 

  4547.                     {

    4548. 

  4548.                         if (result.Arguments[i] != arguments[i])

    4549. 

  4549.                         {

    4550. 

  4550.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    4551. 

  4551.                             return 1;

    4552. 

  4552.                         }

    4553. 

  4553.                     }

    4554. 

  4554.                 }

    4555. 

  4555. 

    4556. 

  4556.                 if (result.Members == null)

    4557. 

  4557.                 {

    4558. 

  4558.                     Console.WriteLine("result.Members was null");

    4559. 

  4559.                     return 1;

    4560. 

  4560.                 }

    4561. 

  4561. 

    4562. 

  4562.                 if (members == null)

    4563. 

  4563.                 {

    4564. 

  4564.                     if (result.Members.Count != 0)

    4565. 

  4565.                     {

    4566. 

  4566.                         Console.WriteLine("Got more than zero members");

    4567. 

  4567.                         return 1;

    4568. 

  4568.                     }

    4569. 

  4569.                 }

    4570. 

  4570.                 else

    4571. 

  4571.                 {

    4572. 

  4572.                     if (result.Members.Count != members.Length)

    4573. 

  4573.                     {

    4574. 

  4574.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    4575. 

  4575.                         return 1;

    4576. 

  4576.                     }

    4577. 

  4577. 

    4578. 

  4578.                     for (int i = 0; i < members.Length; i++)

    4579. 

  4579.                     {

    4580. 

  4580.                         if (result.Members[i] != members[i])

    4581. 

  4581.                         {

    4582. 

  4582.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    4583. 

  4583.                             return 1;

    4584. 

  4584.                         }

    4585. 

  4585.                     }

    4586. 

  4586.                 }

    4587. 

  4587. 

    4588. 

  4588.                 return 0;

    4589. 

  4589.             }

    4590. 

  4590. 

    4591. 

  4591.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    4592. 

  4592.             {

    4593. 

  4593.                 if (!(result.NodeType == et))

    4594. 

  4594.                 {

    4595. 

  4595.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4596. 

  4596.                     return 1;

    4597. 

  4597.                 }

    4598. 

  4598.                 if (!(result.Type == type))

    4599. 

  4599.                 {

    4600. 

  4600.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4601. 

  4601.                     return 1;

    4602. 

  4602.                 }

    4603. 

  4603. 

    4604. 

  4604.                 if (!(result.Constructor == constructor))

    4605. 

  4605.                 {

    4606. 

  4606.                     Console.WriteLine("Constructor is different from expected.");

    4607. 

  4607.                     return 1;

    4608. 

  4608.                 }

    4609. 

  4609. 

    4610. 

  4610.                 if (!(result.ToString() == str))

    4611. 

  4611.                 {

    4612. 

  4612.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4613. 

  4613.                     return 1;

    4614. 

  4614.                 }

    4615. 

  4615. 

    4616. 

  4616.                 if (result.Arguments.Count != arguments.Length)

    4617. 

  4617.                 {

    4618. 

  4618.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    4619. 

  4619.                     return 1;

    4620. 

  4620.                 }

    4621. 

  4621. 

    4622. 

  4622.                 for (int i = 0; i < arguments.Length; i++)

    4623. 

  4623.                 {

    4624. 

  4624.                     if (result.Arguments[i] != arguments[i])

    4625. 

  4625.                     {

    4626. 

  4626.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    4627. 

  4627.                         return 1;

    4628. 

  4628.                     }

    4629. 

  4629.                 }

    4630. 

  4630. 

    4631. 

  4631.                 if (result.Members != null)

    4632. 

  4632.                 {

    4633. 

  4633.                     Console.WriteLine("result.Members isn't null");

    4634. 

  4634.                     return 1;

    4635. 

  4635.                 }

    4636. 

  4636. 

    4637. 

  4637.                 return 0;

    4638. 

  4638.             }

    4639. 

  4639. 

    4640. 

  4640.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    4641. 

  4641.             {

    4642. 

  4642.                 if (!(result.NodeType == et))

    4643. 

  4643.                 {

    4644. 

  4644.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4645. 

  4645.                     return 1;

    4646. 

  4646.                 }

    4647. 

  4647.                 if (!(result.Type == type))

    4648. 

  4648.                 {

    4649. 

  4649.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4650. 

  4650.                     return 1;

    4651. 

  4651.                 }

    4652. 

  4652. 

    4653. 

  4653.                 if (!(result.NewExpression == newExpression)) return 1;

    4654. 

  4654. 

    4655. 

  4655.                 if (!(result.ToString() == str))

    4656. 

  4656.                 {

    4657. 

  4657.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4658. 

  4658.                     return 1;

    4659. 

  4659.                 }

    4660. 

  4660. 

    4661. 

  4661.                 if (result.Initializers.Count != initializers.Length) return 1;

    4662. 

  4662. 

    4663. 

  4663.                 for (int i = 0; i < initializers.Length; i++)

    4664. 

  4664.                 {

    4665. 

  4665.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    4666. 

  4666. 

    4667. 

  4667.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    4668. 

  4668. 

    4669. 

  4669.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    4670. 

  4670.                     {

    4671. 

  4671.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    4672. 

  4672.                     }

    4673. 

  4673.                 }

    4674. 

  4674. 

    4675. 

  4675.                 return 0;

    4676. 

  4676.             }

    4677. 

  4677. 

    4678. 

  4678.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    4679. 

  4679.             {

    4680. 

  4680.                 if (result.AddMethod != exp_mi) return 1;

    4681. 

  4681.                 if (!(result.ToString() == str))

    4682. 

  4682.                 {

    4683. 

  4683.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4684. 

  4684.                     return 1;

    4685. 

  4685.                 }

    4686. 

  4686. 

    4687. 

  4687.                 if (result.Arguments.Count != args.Length) return 1;

    4688. 

  4688. 

    4689. 

  4689.                 for (int i = 0; i < args.Length; i++)

    4690. 

  4690.                 {

    4691. 

  4691.                     if (result.Arguments[i] != args[i]) return 1;

    4692. 

  4692.                 }

    4693. 

  4693. 

    4694. 

  4694.                 return 0;

    4695. 

  4695.             }

    4696. 

  4696. 

    4697. 

  4697.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    4698. 

  4698.             {

    4699. 

  4699.                 if (!(result.BindingType == bt)) return 1;

    4700. 

  4700.                 if (!(result.Expression == expr)) return 1;

    4701. 

  4701.                 if (!(result.Member.Equals(member))) return 1;

    4702. 

  4702.                 if (!(result.ToString() == str))

    4703. 

  4703.                 {

    4704. 

  4704.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4705. 

  4705.                     return 1;

    4706. 

  4706.                 }

    4707. 

  4707. 

    4708. 

  4708.                 return 0;

    4709. 

  4709.             }

    4710. 

  4710. 

    4711. 

  4711.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    4712. 

  4712.             {

    4713. 

  4713.                 if (!(result.BindingType == bt)) return 1;

    4714. 

  4714. 

    4715. 

  4715.                 if (!(result.Member.Equals(member))) return 1;

    4716. 

  4716.                 if (!(result.ToString() == str))

    4717. 

  4717.                 {

    4718. 

  4718.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4719. 

  4719.                     return 1;

    4720. 

  4720.                 }

    4721. 

  4721. 

    4722. 

  4722.                 if (result.Initializers.Count != initializers.Length) return 1;

    4723. 

  4723. 

    4724. 

  4724.                 for (int i = 0; i < initializers.Length; i++)

    4725. 

  4725.                 {

    4726. 

  4726.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    4727. 

  4727. 

    4728. 

  4728.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    4729. 

  4729. 

    4730. 

  4730.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    4731. 

  4731.                     {

    4732. 

  4732.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    4733. 

  4733.                     }

    4734. 

  4734.                 }

    4735. 

  4735. 

    4736. 

  4736. 

    4737. 

  4737.                 return 0;

    4738. 

  4738.             }

    4739. 

  4739. 

    4740. 

  4740.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    4741. 

  4741.             {

    4742. 

  4742.                 if (!(result.BindingType == bt)) return 1;

    4743. 

  4743. 

    4744. 

  4744.                 if (!(result.Member.Equals(member))) return 1;

    4745. 

  4745.                 if (!(result.ToString() == str))

    4746. 

  4746.                 {

    4747. 

  4747.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4748. 

  4748.                     return 1;

    4749. 

  4749.                 }

    4750. 

  4750. 

    4751. 

  4751.                 if (result.Bindings.Count != bindings.Length) return 1;

    4752. 

  4752. 

    4753. 

  4753.                 for (int i = 0; i < bindings.Length; i++)

    4754. 

  4754.                 {

    4755. 

  4755.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    4756. 

  4756.                 }

    4757. 

  4757. 

    4758. 

  4758.                 return 0;

    4759. 

  4759.             }

    4760. 

  4760. 

    4761. 

  4761.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    4762. 

  4762.             {

    4763. 

  4763.                 if (!(result.NodeType == et))

    4764. 

  4764.                 {

    4765. 

  4765.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4766. 

  4766.                     return 1;

    4767. 

  4767.                 }

    4768. 

  4768.                 if (!(result.Type == type))

    4769. 

  4769.                 {

    4770. 

  4770.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4771. 

  4771.                     return 1;

    4772. 

  4772.                 }

    4773. 

  4773.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    4774. 

  4774.                 if (!(result.ToString() == str)) return 1;

    4775. 

  4775. 

    4776. 

  4776.                 if (result.Bindings.Count != bindings.Length) return 1;

    4777. 

  4777. 

    4778. 

  4778.                 for (int i = 0; i < bindings.Length; i++)

    4779. 

  4779.                 {

    4780. 

  4780.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    4781. 

  4781.                 }

    4782. 

  4782. 

    4783. 

  4783.                 return 0;

    4784. 

  4784.             }

    4785. 

  4785. 

    4786. 

  4786.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    4787. 

  4787.             {

    4788. 

  4788.                 if (!(result.NodeType == et))

    4789. 

  4789.                 {

    4790. 

  4790.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4791. 

  4791.                     return 1;

    4792. 

  4792.                 }

    4793. 

  4793.                 if (!(result.Type == type))

    4794. 

  4794.                 {

    4795. 

  4795.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4796. 

  4796.                     return 1;

    4797. 

  4797.                 }

    4798. 

  4798. 

    4799. 

  4799.                 if (result.Expressions.Count != expr.Length) return 1;

    4800. 

  4800. 

    4801. 

  4801.                 for (int i = 0; i < expr.Length; i++)

    4802. 

  4802.                 {

    4803. 

  4803.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    4804. 

  4804.                 }

    4805. 

  4805.                 if (!(result.ToString() == str))

    4806. 

  4806.                 {

    4807. 

  4807.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4808. 

  4808.                     return 1;

    4809. 

  4809.                 }

    4810. 

  4810. 

    4811. 

  4811.                 return 0;

    4812. 

  4812.             }

    4813. 

  4813. 

    4814. 

  4814.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    4815. 

  4815.             {

    4816. 

  4816.                 if (!(result.NodeType == et))

    4817. 

  4817.                 {

    4818. 

  4818.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4819. 

  4819.                     return 1;

    4820. 

  4820.                 }

    4821. 

  4821.                 if (!(result.Type == type))

    4822. 

  4822.                 {

    4823. 

  4823.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4824. 

  4824.                     return 1;

    4825. 

  4825.                 }

    4826. 

  4826.                 if (!(result.Name == name)) return 1;

    4827. 

  4827. 

    4828. 

  4828.                 if (!(result.ToString() == str))

    4829. 

  4829.                 {

    4830. 

  4830.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4831. 

  4831.                     return 1;

    4832. 

  4832.                 }

    4833. 

  4833. 

    4834. 

  4834.                 return 0;

    4835. 

  4835.             }

    4836. 

  4836. 

    4837. 

  4837.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    4838. 

  4838.             {

    4839. 

  4839.                 if (!(result.NodeType == et))

    4840. 

  4840.                 {

    4841. 

  4841.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4842. 

  4842.                     return 1;

    4843. 

  4843.                 }

    4844. 

  4844.                 if (!(result.Type == type))

    4845. 

  4845.                 {

    4846. 

  4846.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4847. 

  4847.                     return 1;

    4848. 

  4848.                 }

    4849. 

  4849. 

    4850. 

  4850.                 if (expr == null)

    4851. 

  4851.                 {

    4852. 

  4852.                     if (result.Body != null) return 1;

    4853. 

  4853.                 }

    4854. 

  4854.                 else

    4855. 

  4855.                 {

    4856. 

  4856.                     if (!(result.Body.Equals(expr))) return 1;

    4857. 

  4857.                 }

    4858. 

  4858. 

    4859. 

  4859.                 if (result.Parameters.Count != parms.Length) return 1;

    4860. 

  4860. 

    4861. 

  4861.                 for (int i = 0; i < parms.Length; i++)

    4862. 

  4862.                 {

    4863. 

  4863.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    4864. 

  4864.                 }

    4865. 

  4865. 

    4866. 

  4866.                 if (!(result.ToString() == str))

    4867. 

  4867.                 {

    4868. 

  4868.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    4869. 

  4869.                     return 1;

    4870. 

  4870.                 }

    4871. 

  4871. 

    4872. 

  4872.                 return 0;

    4873. 

  4873.             }

    4874. 

  4874. 

    4875. 

  4875.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    4876. 

  4876.             {

    4877. 

  4877.                 if (!(result.NodeType == et))

    4878. 

  4878.                 {

    4879. 

  4879.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    4880. 

  4880.                     return 1;

    4881. 

  4881.                 }

    4882. 

  4882.                 if (!(result.Type == type))

    4883. 

  4883.                 {

    4884. 

  4884.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    4885. 

  4885.                     return 1;

    4886. 

  4886.                 }

    4887. 

  4887. 

    4888. 

  4888.                 if (expr == null)

    4889. 

  4889.                 {

    4890. 

  4890.                     if (result.Expression != null) return 1;

    4891. 

  4891.                 }

    4892. 

  4892.                 else

    4893. 

  4893.                 {

    4894. 

  4894.                     if (!(result.Expression.Equals(expr))) return 1;

    4895. 

  4895.                 }

    4896. 

  4896. 

    4897. 

  4897.                 if (result.Arguments.Count != args.Length) return 1;

    4898. 

  4898. 

    4899. 

  4899.                 for (int i = 0; i < args.Length; i++)

    4900. 

  4900.                 {

    4901. 

  4901.                     if (!(result.Arguments[i].Equals(args[i])))

    4902. 

  4902.                     {

    4903. 

  4903.                         return 1;

    4904. 

  4904.                     }

    4905. 

  4905.                 }

    4906. 

  4906. 

    4907. 

  4907.                 if (result.ToString() != str)

    4908. 

  4908.                 {

    4909. 

  4909.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    4910. 

  4910.                     return 1;

    4911. 

  4911.                 }

    4912. 

  4912. 

    4913. 

  4913.                 return 0;

    4914. 

  4914.             }

    4915. 

  4915.         }

    4916. 

  4916. 

    4917. 

  4917. 

    4918. 

  4918.     }

    4919. 

  4919. 

    4920. 

  4920.     //-------- Scenario 788

    4921. 

  4921.     namespace Scenario788

    4922. 

  4922.     {

    4923. 

  4923. 

    4924. 

  4924.         namespace Not

    4925. 

  4925.         {

    4926. 

  4926.             public class Test

    4927. 

  4927.             {

    4928. 

  4928.                 // Overload-1: Test for functionality: Argument is of type user-defined type (Logical Not)

    4929. 

  4929.                 public static int Test7()

    4930. 

  4930.                 {

    4931. 

  4931.                     TC1 ctest = new TC1();

    4932. 

  4932.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC1));

    4933. 

  4933.                     Type exp_type = typeof(TC1);

    4934. 

  4934.                     ExpressionType exp_et = ExpressionType.Not;

    4935. 

  4935.                     string exp_str = "Not(" + ce.ToString() + ")";

    4936. 

  4936.                     Expression exp_operand = ce;

    4937. 

  4937.                     MethodInfo exp_mi = typeof(TC1).GetMethod("op_LogicalNot");

    4938. 

  4938. 

    4939. 

  4939.                     UnaryExpression result = Expression.Not(ce);

    4940. 

  4940. 

    4941. 

  4941.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, false, false);

    4942. 

  4942.                 }

    4943. 

  4943. 

    4944. 

  4944. 

    4945. 

  4945.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not7__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    4946. 

  4946.                 public static Expression Not7__()

    4947. 

  4947.                 {

    4948. 

  4948.                     if (Main() != 0)

    4949. 

  4949.                     {

    4950. 

  4950.                         throw new Exception();

    4951. 

  4951.                     }

    4952. 

  4952.                     else

    4953. 

  4953.                     {

    4954. 

  4954.                         return Expression.Constant(0);

    4955. 

  4955.                     }

    4956. 

  4956.                 }

    4957. 

  4957.                 public static int Main()

    4958. 

  4958.                 {

    4959. 

  4959.                     return Test7();

    4960. 

  4960.                 }

    4961. 

  4961.             }

    4962. 

  4962.         }

    4963. 

  4963. 

    4964. 

  4964. 

    4965. 

  4965.         public static class Extension

    4966. 

  4966.         {

    4967. 

  4967.             public static bool CompareParamName(this ArgumentException ex, string expected)

    4968. 

  4968.             {

    4969. 

  4969. #if SILVERLIGHT

    4970. 

  4970. #if SLRESOURCES

    4971. 

  4971. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    4972. 

  4972. #else

    4973. 

  4973. 				        return true;

    4974. 

  4974. #endif

    4975. 

  4975. #else

    4976. 

  4976.                 return ex.ParamName == expected;

    4977. 

  4977. #endif

    4978. 

  4978.             }

    4979. 

  4979. 

    4980. 

  4980.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    4981. 

  4981.             {

    4982. 

  4982. #if SILVERLIGHT

    4983. 

  4983. #if SLRESOURCES

    4984. 

  4984. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    4985. 

  4985. #else

    4986. 

  4986. 				        return true;

    4987. 

  4987. #endif

    4988. 

  4988. #else

    4989. 

  4989.                 return ex.ParamName == expected;

    4990. 

  4990. #endif

    4991. 

  4991.             }

    4992. 

  4992.         }

    4993. 

  4993. 

    4994. 

  4994.         public static class Verification

    4995. 

  4995.         {

    4996. 

  4996.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    4997. 

  4997.             {

    4998. 

  4998.                 if (!(result.NodeType == et))

    4999. 

  4999.                 {

    5000. 

  5000.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5001. 

  5001.                     return 1;

    5002. 

  5002.                 }

    5003. 

  5003.                 if (!(result.Type == type))

    5004. 

  5004.                 {

    5005. 

  5005.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5006. 

  5006.                     return 1;

    5007. 

  5007.                 }

    5008. 

  5008.                 if (val == null)

    5009. 

  5009.                 {

    5010. 

  5010.                     if (result.Value != null) return 1;

    5011. 

  5011.                 }

    5012. 

  5012.                 else

    5013. 

  5013.                 {

    5014. 

  5014.                     if (!(result.Value.Equals(val))) return 1;

    5015. 

  5015.                 }

    5016. 

  5016.                 if (!(result.ToString() == str)) return 1;

    5017. 

  5017.                 return 0;

    5018. 

  5018.             }

    5019. 

  5019. 

    5020. 

  5020.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    5021. 

  5021.             {

    5022. 

  5022.                 if (!(result.NodeType == et))

    5023. 

  5023.                 {

    5024. 

  5024.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5025. 

  5025.                     return 1;

    5026. 

  5026.                 }

    5027. 

  5027.                 if (!(result.Type == type))

    5028. 

  5028.                 {

    5029. 

  5029.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5030. 

  5030.                     return 1;

    5031. 

  5031.                 }

    5032. 

  5032.                 if (operand == null)

    5033. 

  5033.                 {

    5034. 

  5034.                     if (result.Operand != null) return 1;

    5035. 

  5035.                 }

    5036. 

  5036.                 else

    5037. 

  5037.                 {

    5038. 

  5038.                     if (!(result.Operand.Equals(operand))) return 1;

    5039. 

  5039.                 }

    5040. 

  5040.                 if (!(result.ToString() == str))

    5041. 

  5041.                 {

    5042. 

  5042.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5043. 

  5043.                     return 1;

    5044. 

  5044.                 }

    5045. 

  5045. 

    5046. 

  5046.                 if (result.Method != mi) return 1;

    5047. 

  5047.                 if (result.IsLifted != islifted) return 1;

    5048. 

  5048.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5049. 

  5049. 

    5050. 

  5050.                 return 0;

    5051. 

  5051.             }

    5052. 

  5052. 

    5053. 

  5053.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    5054. 

  5054.             {

    5055. 

  5055.                 if (!(result.NodeType == et))

    5056. 

  5056.                 {

    5057. 

  5057.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5058. 

  5058.                     return 1;

    5059. 

  5059.                 }

    5060. 

  5060.                 if (!(result.Type == type))

    5061. 

  5061.                 {

    5062. 

  5062.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5063. 

  5063.                     return 1;

    5064. 

  5064.                 }

    5065. 

  5065. 

    5066. 

  5066.                 if (left == null)

    5067. 

  5067.                 {

    5068. 

  5068.                     if (result.Left != null)

    5069. 

  5069.                     {

    5070. 

  5070.                         Console.WriteLine("left was null");

    5071. 

  5071.                         return 1;

    5072. 

  5072.                     }

    5073. 

  5073.                 }

    5074. 

  5074.                 else

    5075. 

  5075.                 {

    5076. 

  5076.                     if (!(result.Left.Equals(left)))

    5077. 

  5077.                     {

    5078. 

  5078.                         Console.WriteLine("left was different");

    5079. 

  5079.                         return 1;

    5080. 

  5080.                     }

    5081. 

  5081.                 }

    5082. 

  5082. 

    5083. 

  5083.                 if (right == null)

    5084. 

  5084.                 {

    5085. 

  5085.                     if (result.Right != null) return 1;

    5086. 

  5086.                 }

    5087. 

  5087.                 else

    5088. 

  5088.                 {

    5089. 

  5089.                     if (!(result.Right.Equals(right))) return 1;

    5090. 

  5090.                 }

    5091. 

  5091. 

    5092. 

  5092.                 if (!(result.ToString() == str))

    5093. 

  5093.                 {

    5094. 

  5094.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5095. 

  5095.                     return 1;

    5096. 

  5096.                 }

    5097. 

  5097. 

    5098. 

  5098.                 if (result.Method != mi) return 1;

    5099. 

  5099.                 if (result.IsLifted != islifted) return 1;

    5100. 

  5100.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5101. 

  5101. 

    5102. 

  5102.                 if (result.Conversion != null) return 1;

    5103. 

  5103. 

    5104. 

  5104.                 return 0;

    5105. 

  5105.             }

    5106. 

  5106. 

    5107. 

  5107.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    5108. 

  5108.             {

    5109. 

  5109.                 if (!(result.NodeType == et))

    5110. 

  5110.                 {

    5111. 

  5111.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5112. 

  5112.                     return 1;

    5113. 

  5113.                 }

    5114. 

  5114.                 if (!(result.Type == type))

    5115. 

  5115.                 {

    5116. 

  5116.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5117. 

  5117.                     return 1;

    5118. 

  5118.                 }

    5119. 

  5119. 

    5120. 

  5120.                 if (left == null)

    5121. 

  5121.                 {

    5122. 

  5122.                     if (result.Left != null) return 1;

    5123. 

  5123.                 }

    5124. 

  5124.                 else

    5125. 

  5125.                 {

    5126. 

  5126.                     if (!(result.Left.Equals(left))) return 1;

    5127. 

  5127.                 }

    5128. 

  5128. 

    5129. 

  5129.                 if (right == null)

    5130. 

  5130.                 {

    5131. 

  5131.                     if (result.Right != null) return 1;

    5132. 

  5132.                 }

    5133. 

  5133.                 else

    5134. 

  5134.                 {

    5135. 

  5135.                     if (!(result.Right.Equals(right))) return 1;

    5136. 

  5136.                 }

    5137. 

  5137. 

    5138. 

  5138.                 if (!(result.ToString() == str)) return 1;

    5139. 

  5139. 

    5140. 

  5140.                 if (result.Method != mi) return 1;

    5141. 

  5141.                 if (result.IsLifted != islifted) return 1;

    5142. 

  5142.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5143. 

  5143. 

    5144. 

  5144.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    5145. 

  5145. 

    5146. 

  5146.                 return 0;

    5147. 

  5147.             }

    5148. 

  5148. 

    5149. 

  5149.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    5150. 

  5150.             {

    5151. 

  5151.                 if (!(result.NodeType == et))

    5152. 

  5152.                 {

    5153. 

  5153.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5154. 

  5154.                     return 1;

    5155. 

  5155.                 }

    5156. 

  5156.                 if (!(result.Type == type))

    5157. 

  5157.                 {

    5158. 

  5158.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5159. 

  5159.                     return 1;

    5160. 

  5160.                 }

    5161. 

  5161. 

    5162. 

  5162.                 if (!(result.Method == method)) return 1;

    5163. 

  5163. 

    5164. 

  5164.                 if (obj == null)

    5165. 

  5165.                 {

    5166. 

  5166.                     if (result.Object != null)

    5167. 

  5167.                     {

    5168. 

  5168.                         Console.WriteLine("Expected object to be null.");

    5169. 

  5169.                         return 1;

    5170. 

  5170.                     }

    5171. 

  5171.                 }

    5172. 

  5172.                 else

    5173. 

  5173.                 {

    5174. 

  5174.                     if (!(result.Object.Equals(obj)))

    5175. 

  5175.                     {

    5176. 

  5176.                         Console.WriteLine("Object on which call is made is different from the result.");

    5177. 

  5177.                         return 1;

    5178. 

  5178.                     }

    5179. 

  5179.                 }

    5180. 

  5180. 

    5181. 

  5181.                 if (!(result.ToString() == str))

    5182. 

  5182.                 {

    5183. 

  5183.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5184. 

  5184.                     return 1;

    5185. 

  5185.                 }

    5186. 

  5186. 

    5187. 

  5187.                 if (result.Arguments.Count != arguments.Length) return 1;

    5188. 

  5188. 

    5189. 

  5189.                 for (int i = 0; i < arguments.Length; i++)

    5190. 

  5190.                 {

    5191. 

  5191.                     if (result.Arguments[i] != arguments[i]) return 1;

    5192. 

  5192.                 }

    5193. 

  5193. 

    5194. 

  5194.                 return 0;

    5195. 

  5195.             }

    5196. 

  5196. 

    5197. 

  5197.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    5198. 

  5198.             {

    5199. 

  5199.                 if (!(result.NodeType == et))

    5200. 

  5200.                 {

    5201. 

  5201.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5202. 

  5202.                     return 1;

    5203. 

  5203.                 }

    5204. 

  5204.                 if (!(result.Type == type))

    5205. 

  5205.                 {

    5206. 

  5206.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5207. 

  5207.                     return 1;

    5208. 

  5208.                 }

    5209. 

  5209. 

    5210. 

  5210.                 if (expr == null)

    5211. 

  5211.                 {

    5212. 

  5212.                     Console.WriteLine("expr was null.");

    5213. 

  5213.                     if (result.Expression != null) return 1;

    5214. 

  5214.                 }

    5215. 

  5215.                 else

    5216. 

  5216.                 {

    5217. 

  5217.                     if (!(result.Expression.Equals(expr)))

    5218. 

  5218.                     {

    5219. 

  5219.                         return 1;

    5220. 

  5220.                     }

    5221. 

  5221.                 }

    5222. 

  5222. 

    5223. 

  5223.                 if (!(result.TypeOperand == typeop)) return 1;

    5224. 

  5224. 

    5225. 

  5225.                 if (!(result.ToString() == str))

    5226. 

  5226.                 {

    5227. 

  5227.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5228. 

  5228.                     return 1;

    5229. 

  5229.                 }

    5230. 

  5230. 

    5231. 

  5231.                 return 0;

    5232. 

  5232.             }

    5233. 

  5233. 

    5234. 

  5234.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    5235. 

  5235.             {

    5236. 

  5236.                 if (!(result.NodeType == et))

    5237. 

  5237.                 {

    5238. 

  5238.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5239. 

  5239.                     return 1;

    5240. 

  5240.                 }

    5241. 

  5241.                 if (!(result.Type == type))

    5242. 

  5242.                 {

    5243. 

  5243.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5244. 

  5244.                     return 1;

    5245. 

  5245.                 }

    5246. 

  5246. 

    5247. 

  5247.                 if (test == null)

    5248. 

  5248.                 {

    5249. 

  5249.                     if (result.Test != null) return 1;

    5250. 

  5250.                 }

    5251. 

  5251.                 else

    5252. 

  5252.                 {

    5253. 

  5253.                     if (!(result.Test.Equals(test))) return 1;

    5254. 

  5254.                 }

    5255. 

  5255. 

    5256. 

  5256.                 if (ifTrue == null)

    5257. 

  5257.                 {

    5258. 

  5258.                     if (result.IfTrue != null) return 1;

    5259. 

  5259.                 }

    5260. 

  5260.                 else

    5261. 

  5261.                 {

    5262. 

  5262.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    5263. 

  5263.                 }

    5264. 

  5264. 

    5265. 

  5265.                 if (ifFalse == null)

    5266. 

  5266.                 {

    5267. 

  5267.                     if (result.IfFalse != null) return 1;

    5268. 

  5268.                 }

    5269. 

  5269.                 else

    5270. 

  5270.                 {

    5271. 

  5271.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    5272. 

  5272.                 }

    5273. 

  5273. 

    5274. 

  5274.                 if (!(result.ToString() == str)) return 1;

    5275. 

  5275. 

    5276. 

  5276.                 return 0;

    5277. 

  5277.             }

    5278. 

  5278. 

    5279. 

  5279.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    5280. 

  5280.             {

    5281. 

  5281.                 if (!(result.NodeType == et))

    5282. 

  5282.                 {

    5283. 

  5283.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5284. 

  5284.                     return 1;

    5285. 

  5285.                 }

    5286. 

  5286.                 if (!(result.Type == type))

    5287. 

  5287.                 {

    5288. 

  5288.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5289. 

  5289.                     return 1;

    5290. 

  5290.                 }

    5291. 

  5291. 

    5292. 

  5292.                 if (exp_expr == null)

    5293. 

  5293.                 {

    5294. 

  5294.                     if (result.Expression != null)

    5295. 

  5295.                     {

    5296. 

  5296.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    5297. 

  5297.                         return 1;

    5298. 

  5298.                     }

    5299. 

  5299.                 }

    5300. 

  5300.                 else

    5301. 

  5301.                 {

    5302. 

  5302.                     if (!(result.Expression.Equals(exp_expr)))

    5303. 

  5303.                     {

    5304. 

  5304.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    5305. 

  5305.                         return 1;

    5306. 

  5306.                     }

    5307. 

  5307.                 }

    5308. 

  5308. 

    5309. 

  5309.                 if (!(result.Member == exp_member))

    5310. 

  5310.                 {

    5311. 

  5311.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    5312. 

  5312.                     return 1;

    5313. 

  5313.                 }

    5314. 

  5314. 

    5315. 

  5315.                 if (!(result.ToString() == str))

    5316. 

  5316.                 {

    5317. 

  5317.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5318. 

  5318.                     return 1;

    5319. 

  5319.                 }

    5320. 

  5320. 

    5321. 

  5321.                 return 0;

    5322. 

  5322.             }

    5323. 

  5323. 

    5324. 

  5324.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    5325. 

  5325.             {

    5326. 

  5326.                 if (!(result.NodeType == et))

    5327. 

  5327.                 {

    5328. 

  5328.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5329. 

  5329.                     return 1;

    5330. 

  5330.                 }

    5331. 

  5331.                 if (!(result.Type == type))

    5332. 

  5332.                 {

    5333. 

  5333.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5334. 

  5334.                     return 1;

    5335. 

  5335.                 }

    5336. 

  5336. 

    5337. 

  5337.                 if (!(result.Constructor == constructor))

    5338. 

  5338.                 {

    5339. 

  5339.                     Console.WriteLine("Unexpected constructor");

    5340. 

  5340.                     return 1;

    5341. 

  5341.                 }

    5342. 

  5342. 

    5343. 

  5343.                 if (!(result.ToString() == str))

    5344. 

  5344.                 {

    5345. 

  5345.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5346. 

  5346.                     return 1;

    5347. 

  5347.                 }

    5348. 

  5348. 

    5349. 

  5349.                 if (arguments == null)

    5350. 

  5350.                 {

    5351. 

  5351.                     if (result.Arguments.Count != 0)

    5352. 

  5352.                     {

    5353. 

  5353.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    5354. 

  5354.                         return 1;

    5355. 

  5355.                     }

    5356. 

  5356.                 }

    5357. 

  5357.                 else

    5358. 

  5358.                 {

    5359. 

  5359.                     if (result.Arguments.Count != arguments.Length)

    5360. 

  5360.                     {

    5361. 

  5361.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    5362. 

  5362.                         return 1;

    5363. 

  5363.                     }

    5364. 

  5364.                     for (int i = 0; i < arguments.Length; i++)

    5365. 

  5365.                     {

    5366. 

  5366.                         if (result.Arguments[i] != arguments[i])

    5367. 

  5367.                         {

    5368. 

  5368.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    5369. 

  5369.                             return 1;

    5370. 

  5370.                         }

    5371. 

  5371.                     }

    5372. 

  5372.                 }

    5373. 

  5373. 

    5374. 

  5374.                 if (result.Members == null)

    5375. 

  5375.                 {

    5376. 

  5376.                     Console.WriteLine("result.Members was null");

    5377. 

  5377.                     return 1;

    5378. 

  5378.                 }

    5379. 

  5379. 

    5380. 

  5380.                 if (members == null)

    5381. 

  5381.                 {

    5382. 

  5382.                     if (result.Members.Count != 0)

    5383. 

  5383.                     {

    5384. 

  5384.                         Console.WriteLine("Got more than zero members");

    5385. 

  5385.                         return 1;

    5386. 

  5386.                     }

    5387. 

  5387.                 }

    5388. 

  5388.                 else

    5389. 

  5389.                 {

    5390. 

  5390.                     if (result.Members.Count != members.Length)

    5391. 

  5391.                     {

    5392. 

  5392.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    5393. 

  5393.                         return 1;

    5394. 

  5394.                     }

    5395. 

  5395. 

    5396. 

  5396.                     for (int i = 0; i < members.Length; i++)

    5397. 

  5397.                     {

    5398. 

  5398.                         if (result.Members[i] != members[i])

    5399. 

  5399.                         {

    5400. 

  5400.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    5401. 

  5401.                             return 1;

    5402. 

  5402.                         }

    5403. 

  5403.                     }

    5404. 

  5404.                 }

    5405. 

  5405. 

    5406. 

  5406.                 return 0;

    5407. 

  5407.             }

    5408. 

  5408. 

    5409. 

  5409.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    5410. 

  5410.             {

    5411. 

  5411.                 if (!(result.NodeType == et))

    5412. 

  5412.                 {

    5413. 

  5413.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5414. 

  5414.                     return 1;

    5415. 

  5415.                 }

    5416. 

  5416.                 if (!(result.Type == type))

    5417. 

  5417.                 {

    5418. 

  5418.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5419. 

  5419.                     return 1;

    5420. 

  5420.                 }

    5421. 

  5421. 

    5422. 

  5422.                 if (!(result.Constructor == constructor))

    5423. 

  5423.                 {

    5424. 

  5424.                     Console.WriteLine("Constructor is different from expected.");

    5425. 

  5425.                     return 1;

    5426. 

  5426.                 }

    5427. 

  5427. 

    5428. 

  5428.                 if (!(result.ToString() == str))

    5429. 

  5429.                 {

    5430. 

  5430.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5431. 

  5431.                     return 1;

    5432. 

  5432.                 }

    5433. 

  5433. 

    5434. 

  5434.                 if (result.Arguments.Count != arguments.Length)

    5435. 

  5435.                 {

    5436. 

  5436.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    5437. 

  5437.                     return 1;

    5438. 

  5438.                 }

    5439. 

  5439. 

    5440. 

  5440.                 for (int i = 0; i < arguments.Length; i++)

    5441. 

  5441.                 {

    5442. 

  5442.                     if (result.Arguments[i] != arguments[i])

    5443. 

  5443.                     {

    5444. 

  5444.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    5445. 

  5445.                         return 1;

    5446. 

  5446.                     }

    5447. 

  5447.                 }

    5448. 

  5448. 

    5449. 

  5449.                 if (result.Members != null)

    5450. 

  5450.                 {

    5451. 

  5451.                     Console.WriteLine("result.Members isn't null");

    5452. 

  5452.                     return 1;

    5453. 

  5453.                 }

    5454. 

  5454. 

    5455. 

  5455.                 return 0;

    5456. 

  5456.             }

    5457. 

  5457. 

    5458. 

  5458.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    5459. 

  5459.             {

    5460. 

  5460.                 if (!(result.NodeType == et))

    5461. 

  5461.                 {

    5462. 

  5462.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5463. 

  5463.                     return 1;

    5464. 

  5464.                 }

    5465. 

  5465.                 if (!(result.Type == type))

    5466. 

  5466.                 {

    5467. 

  5467.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5468. 

  5468.                     return 1;

    5469. 

  5469.                 }

    5470. 

  5470. 

    5471. 

  5471.                 if (!(result.NewExpression == newExpression)) return 1;

    5472. 

  5472. 

    5473. 

  5473.                 if (!(result.ToString() == str))

    5474. 

  5474.                 {

    5475. 

  5475.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5476. 

  5476.                     return 1;

    5477. 

  5477.                 }

    5478. 

  5478. 

    5479. 

  5479.                 if (result.Initializers.Count != initializers.Length) return 1;

    5480. 

  5480. 

    5481. 

  5481.                 for (int i = 0; i < initializers.Length; i++)

    5482. 

  5482.                 {

    5483. 

  5483.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    5484. 

  5484. 

    5485. 

  5485.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    5486. 

  5486. 

    5487. 

  5487.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    5488. 

  5488.                     {

    5489. 

  5489.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    5490. 

  5490.                     }

    5491. 

  5491.                 }

    5492. 

  5492. 

    5493. 

  5493.                 return 0;

    5494. 

  5494.             }

    5495. 

  5495. 

    5496. 

  5496.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    5497. 

  5497.             {

    5498. 

  5498.                 if (result.AddMethod != exp_mi) return 1;

    5499. 

  5499.                 if (!(result.ToString() == str))

    5500. 

  5500.                 {

    5501. 

  5501.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5502. 

  5502.                     return 1;

    5503. 

  5503.                 }

    5504. 

  5504. 

    5505. 

  5505.                 if (result.Arguments.Count != args.Length) return 1;

    5506. 

  5506. 

    5507. 

  5507.                 for (int i = 0; i < args.Length; i++)

    5508. 

  5508.                 {

    5509. 

  5509.                     if (result.Arguments[i] != args[i]) return 1;

    5510. 

  5510.                 }

    5511. 

  5511. 

    5512. 

  5512.                 return 0;

    5513. 

  5513.             }

    5514. 

  5514. 

    5515. 

  5515.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    5516. 

  5516.             {

    5517. 

  5517.                 if (!(result.BindingType == bt)) return 1;

    5518. 

  5518.                 if (!(result.Expression == expr)) return 1;

    5519. 

  5519.                 if (!(result.Member.Equals(member))) return 1;

    5520. 

  5520.                 if (!(result.ToString() == str))

    5521. 

  5521.                 {

    5522. 

  5522.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5523. 

  5523.                     return 1;

    5524. 

  5524.                 }

    5525. 

  5525. 

    5526. 

  5526.                 return 0;

    5527. 

  5527.             }

    5528. 

  5528. 

    5529. 

  5529.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    5530. 

  5530.             {

    5531. 

  5531.                 if (!(result.BindingType == bt)) return 1;

    5532. 

  5532. 

    5533. 

  5533.                 if (!(result.Member.Equals(member))) return 1;

    5534. 

  5534.                 if (!(result.ToString() == str))

    5535. 

  5535.                 {

    5536. 

  5536.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5537. 

  5537.                     return 1;

    5538. 

  5538.                 }

    5539. 

  5539. 

    5540. 

  5540.                 if (result.Initializers.Count != initializers.Length) return 1;

    5541. 

  5541. 

    5542. 

  5542.                 for (int i = 0; i < initializers.Length; i++)

    5543. 

  5543.                 {

    5544. 

  5544.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    5545. 

  5545. 

    5546. 

  5546.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    5547. 

  5547. 

    5548. 

  5548.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    5549. 

  5549.                     {

    5550. 

  5550.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    5551. 

  5551.                     }

    5552. 

  5552.                 }

    5553. 

  5553. 

    5554. 

  5554. 

    5555. 

  5555.                 return 0;

    5556. 

  5556.             }

    5557. 

  5557. 

    5558. 

  5558.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    5559. 

  5559.             {

    5560. 

  5560.                 if (!(result.BindingType == bt)) return 1;

    5561. 

  5561. 

    5562. 

  5562.                 if (!(result.Member.Equals(member))) return 1;

    5563. 

  5563.                 if (!(result.ToString() == str))

    5564. 

  5564.                 {

    5565. 

  5565.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5566. 

  5566.                     return 1;

    5567. 

  5567.                 }

    5568. 

  5568. 

    5569. 

  5569.                 if (result.Bindings.Count != bindings.Length) return 1;

    5570. 

  5570. 

    5571. 

  5571.                 for (int i = 0; i < bindings.Length; i++)

    5572. 

  5572.                 {

    5573. 

  5573.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    5574. 

  5574.                 }

    5575. 

  5575. 

    5576. 

  5576.                 return 0;

    5577. 

  5577.             }

    5578. 

  5578. 

    5579. 

  5579.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    5580. 

  5580.             {

    5581. 

  5581.                 if (!(result.NodeType == et))

    5582. 

  5582.                 {

    5583. 

  5583.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5584. 

  5584.                     return 1;

    5585. 

  5585.                 }

    5586. 

  5586.                 if (!(result.Type == type))

    5587. 

  5587.                 {

    5588. 

  5588.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5589. 

  5589.                     return 1;

    5590. 

  5590.                 }

    5591. 

  5591.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    5592. 

  5592.                 if (!(result.ToString() == str)) return 1;

    5593. 

  5593. 

    5594. 

  5594.                 if (result.Bindings.Count != bindings.Length) return 1;

    5595. 

  5595. 

    5596. 

  5596.                 for (int i = 0; i < bindings.Length; i++)

    5597. 

  5597.                 {

    5598. 

  5598.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    5599. 

  5599.                 }

    5600. 

  5600. 

    5601. 

  5601.                 return 0;

    5602. 

  5602.             }

    5603. 

  5603. 

    5604. 

  5604.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    5605. 

  5605.             {

    5606. 

  5606.                 if (!(result.NodeType == et))

    5607. 

  5607.                 {

    5608. 

  5608.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5609. 

  5609.                     return 1;

    5610. 

  5610.                 }

    5611. 

  5611.                 if (!(result.Type == type))

    5612. 

  5612.                 {

    5613. 

  5613.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5614. 

  5614.                     return 1;

    5615. 

  5615.                 }

    5616. 

  5616. 

    5617. 

  5617.                 if (result.Expressions.Count != expr.Length) return 1;

    5618. 

  5618. 

    5619. 

  5619.                 for (int i = 0; i < expr.Length; i++)

    5620. 

  5620.                 {

    5621. 

  5621.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    5622. 

  5622.                 }

    5623. 

  5623.                 if (!(result.ToString() == str))

    5624. 

  5624.                 {

    5625. 

  5625.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5626. 

  5626.                     return 1;

    5627. 

  5627.                 }

    5628. 

  5628. 

    5629. 

  5629.                 return 0;

    5630. 

  5630.             }

    5631. 

  5631. 

    5632. 

  5632.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    5633. 

  5633.             {

    5634. 

  5634.                 if (!(result.NodeType == et))

    5635. 

  5635.                 {

    5636. 

  5636.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5637. 

  5637.                     return 1;

    5638. 

  5638.                 }

    5639. 

  5639.                 if (!(result.Type == type))

    5640. 

  5640.                 {

    5641. 

  5641.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5642. 

  5642.                     return 1;

    5643. 

  5643.                 }

    5644. 

  5644.                 if (!(result.Name == name)) return 1;

    5645. 

  5645. 

    5646. 

  5646.                 if (!(result.ToString() == str))

    5647. 

  5647.                 {

    5648. 

  5648.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5649. 

  5649.                     return 1;

    5650. 

  5650.                 }

    5651. 

  5651. 

    5652. 

  5652.                 return 0;

    5653. 

  5653.             }

    5654. 

  5654. 

    5655. 

  5655.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    5656. 

  5656.             {

    5657. 

  5657.                 if (!(result.NodeType == et))

    5658. 

  5658.                 {

    5659. 

  5659.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5660. 

  5660.                     return 1;

    5661. 

  5661.                 }

    5662. 

  5662.                 if (!(result.Type == type))

    5663. 

  5663.                 {

    5664. 

  5664.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5665. 

  5665.                     return 1;

    5666. 

  5666.                 }

    5667. 

  5667. 

    5668. 

  5668.                 if (expr == null)

    5669. 

  5669.                 {

    5670. 

  5670.                     if (result.Body != null) return 1;

    5671. 

  5671.                 }

    5672. 

  5672.                 else

    5673. 

  5673.                 {

    5674. 

  5674.                     if (!(result.Body.Equals(expr))) return 1;

    5675. 

  5675.                 }

    5676. 

  5676. 

    5677. 

  5677.                 if (result.Parameters.Count != parms.Length) return 1;

    5678. 

  5678. 

    5679. 

  5679.                 for (int i = 0; i < parms.Length; i++)

    5680. 

  5680.                 {

    5681. 

  5681.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    5682. 

  5682.                 }

    5683. 

  5683. 

    5684. 

  5684.                 if (!(result.ToString() == str))

    5685. 

  5685.                 {

    5686. 

  5686.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    5687. 

  5687.                     return 1;

    5688. 

  5688.                 }

    5689. 

  5689. 

    5690. 

  5690.                 return 0;

    5691. 

  5691.             }

    5692. 

  5692. 

    5693. 

  5693.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    5694. 

  5694.             {

    5695. 

  5695.                 if (!(result.NodeType == et))

    5696. 

  5696.                 {

    5697. 

  5697.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5698. 

  5698.                     return 1;

    5699. 

  5699.                 }

    5700. 

  5700.                 if (!(result.Type == type))

    5701. 

  5701.                 {

    5702. 

  5702.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5703. 

  5703.                     return 1;

    5704. 

  5704.                 }

    5705. 

  5705. 

    5706. 

  5706.                 if (expr == null)

    5707. 

  5707.                 {

    5708. 

  5708.                     if (result.Expression != null) return 1;

    5709. 

  5709.                 }

    5710. 

  5710.                 else

    5711. 

  5711.                 {

    5712. 

  5712.                     if (!(result.Expression.Equals(expr))) return 1;

    5713. 

  5713.                 }

    5714. 

  5714. 

    5715. 

  5715.                 if (result.Arguments.Count != args.Length) return 1;

    5716. 

  5716. 

    5717. 

  5717.                 for (int i = 0; i < args.Length; i++)

    5718. 

  5718.                 {

    5719. 

  5719.                     if (!(result.Arguments[i].Equals(args[i])))

    5720. 

  5720.                     {

    5721. 

  5721.                         return 1;

    5722. 

  5722.                     }

    5723. 

  5723.                 }

    5724. 

  5724. 

    5725. 

  5725.                 if (result.ToString() != str)

    5726. 

  5726.                 {

    5727. 

  5727.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5728. 

  5728.                     return 1;

    5729. 

  5729.                 }

    5730. 

  5730. 

    5731. 

  5731.                 return 0;

    5732. 

  5732.             }

    5733. 

  5733.         }

    5734. 

  5734. 

    5735. 

  5735. 

    5736. 

  5736. 

    5737. 

  5737.         namespace Not

    5738. 

  5738.         {

    5739. 

  5739.             // Declaring user-defined types for testing

    5740. 

  5740.             struct TC1

    5741. 

  5741.             {

    5742. 

  5742.                 public static TC1 operator !(TC1 c)

    5743. 

  5743.                 {

    5744. 

  5744.                     return new TC1();

    5745. 

  5745.                 }

    5746. 

  5746. 

    5747. 

  5747.                 public static TC1 operator ~(TC1 c)

    5748. 

  5748.                 {

    5749. 

  5749.                     return new TC1();

    5750. 

  5750.                 }

    5751. 

  5751.             }

    5752. 

  5752. 

    5753. 

  5753.             struct TC2

    5754. 

  5754.             {

    5755. 

  5755.                 public static TC2 operator ~(TC2 c)

    5756. 

  5756.                 {

    5757. 

  5757.                     return new TC2();

    5758. 

  5758.                 }

    5759. 

  5759.             }

    5760. 

  5760. 

    5761. 

  5761.             struct TC3

    5762. 

  5762.             {

    5763. 

  5763.                 public static TC3 Meth1(TC3 c)

    5764. 

  5764.                 {

    5765. 

  5765.                     return new TC3();

    5766. 

  5766.                 }

    5767. 

  5767.             }

    5768. 

  5768.         }

    5769. 

  5769. 

    5770. 

  5770.     }

    5771. 

  5771. 

    5772. 

  5772.     //-------- Scenario 789

    5773. 

  5773.     namespace Scenario789

    5774. 

  5774.     {

    5775. 

  5775. 

    5776. 

  5776.         namespace Not

    5777. 

  5777.         {

    5778. 

  5778.             public class Test

    5779. 

  5779.             {

    5780. 

  5780.                 // Overload-1: Test for functionality: Argument is of type nullable user-defined type (Logical Not)

    5781. 

  5781.                 public static int Test8()

    5782. 

  5782.                 {

    5783. 

  5783.                     TC1? ctest = new TC1?();

    5784. 

  5784.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC1?));

    5785. 

  5785.                     Type exp_type = typeof(TC1?);

    5786. 

  5786.                     ExpressionType exp_et = ExpressionType.Not;

    5787. 

  5787.                     string exp_str = "Not(" + ce.ToString() + ")";

    5788. 

  5788.                     Expression exp_operand = ce;

    5789. 

  5789.                     MethodInfo exp_mi = typeof(TC1).GetMethod("op_LogicalNot");

    5790. 

  5790. 

    5791. 

  5791.                     UnaryExpression result = Expression.Not(ce);

    5792. 

  5792. 

    5793. 

  5793.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, true, true);

    5794. 

  5794.                 }

    5795. 

  5795. 

    5796. 

  5796. 

    5797. 

  5797.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not8__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    5798. 

  5798.                 public static Expression Not8__()

    5799. 

  5799.                 {

    5800. 

  5800.                     if (Main() != 0)

    5801. 

  5801.                     {

    5802. 

  5802.                         throw new Exception();

    5803. 

  5803.                     }

    5804. 

  5804.                     else

    5805. 

  5805.                     {

    5806. 

  5806.                         return Expression.Constant(0);

    5807. 

  5807.                     }

    5808. 

  5808.                 }

    5809. 

  5809.                 public static int Main()

    5810. 

  5810.                 {

    5811. 

  5811.                     return Test8();

    5812. 

  5812.                 }

    5813. 

  5813.             }

    5814. 

  5814.         }

    5815. 

  5815. 

    5816. 

  5816. 

    5817. 

  5817.         public static class Extension

    5818. 

  5818.         {

    5819. 

  5819.             public static bool CompareParamName(this ArgumentException ex, string expected)

    5820. 

  5820.             {

    5821. 

  5821. #if SILVERLIGHT

    5822. 

  5822. #if SLRESOURCES

    5823. 

  5823. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    5824. 

  5824. #else

    5825. 

  5825. 				        return true;

    5826. 

  5826. #endif

    5827. 

  5827. #else

    5828. 

  5828.                 return ex.ParamName == expected;

    5829. 

  5829. #endif

    5830. 

  5830.             }

    5831. 

  5831. 

    5832. 

  5832.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    5833. 

  5833.             {

    5834. 

  5834. #if SILVERLIGHT

    5835. 

  5835. #if SLRESOURCES

    5836. 

  5836. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    5837. 

  5837. #else

    5838. 

  5838. 				        return true;

    5839. 

  5839. #endif

    5840. 

  5840. #else

    5841. 

  5841.                 return ex.ParamName == expected;

    5842. 

  5842. #endif

    5843. 

  5843.             }

    5844. 

  5844.         }

    5845. 

  5845. 

    5846. 

  5846.         public static class Verification

    5847. 

  5847.         {

    5848. 

  5848.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    5849. 

  5849.             {

    5850. 

  5850.                 if (!(result.NodeType == et))

    5851. 

  5851.                 {

    5852. 

  5852.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5853. 

  5853.                     return 1;

    5854. 

  5854.                 }

    5855. 

  5855.                 if (!(result.Type == type))

    5856. 

  5856.                 {

    5857. 

  5857.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5858. 

  5858.                     return 1;

    5859. 

  5859.                 }

    5860. 

  5860.                 if (val == null)

    5861. 

  5861.                 {

    5862. 

  5862.                     if (result.Value != null) return 1;

    5863. 

  5863.                 }

    5864. 

  5864.                 else

    5865. 

  5865.                 {

    5866. 

  5866.                     if (!(result.Value.Equals(val))) return 1;

    5867. 

  5867.                 }

    5868. 

  5868.                 if (!(result.ToString() == str)) return 1;

    5869. 

  5869.                 return 0;

    5870. 

  5870.             }

    5871. 

  5871. 

    5872. 

  5872.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    5873. 

  5873.             {

    5874. 

  5874.                 if (!(result.NodeType == et))

    5875. 

  5875.                 {

    5876. 

  5876.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5877. 

  5877.                     return 1;

    5878. 

  5878.                 }

    5879. 

  5879.                 if (!(result.Type == type))

    5880. 

  5880.                 {

    5881. 

  5881.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5882. 

  5882.                     return 1;

    5883. 

  5883.                 }

    5884. 

  5884.                 if (operand == null)

    5885. 

  5885.                 {

    5886. 

  5886.                     if (result.Operand != null) return 1;

    5887. 

  5887.                 }

    5888. 

  5888.                 else

    5889. 

  5889.                 {

    5890. 

  5890.                     if (!(result.Operand.Equals(operand))) return 1;

    5891. 

  5891.                 }

    5892. 

  5892.                 if (!(result.ToString() == str))

    5893. 

  5893.                 {

    5894. 

  5894.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5895. 

  5895.                     return 1;

    5896. 

  5896.                 }

    5897. 

  5897. 

    5898. 

  5898.                 if (result.Method != mi) return 1;

    5899. 

  5899.                 if (result.IsLifted != islifted) return 1;

    5900. 

  5900.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5901. 

  5901. 

    5902. 

  5902.                 return 0;

    5903. 

  5903.             }

    5904. 

  5904. 

    5905. 

  5905.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    5906. 

  5906.             {

    5907. 

  5907.                 if (!(result.NodeType == et))

    5908. 

  5908.                 {

    5909. 

  5909.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5910. 

  5910.                     return 1;

    5911. 

  5911.                 }

    5912. 

  5912.                 if (!(result.Type == type))

    5913. 

  5913.                 {

    5914. 

  5914.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5915. 

  5915.                     return 1;

    5916. 

  5916.                 }

    5917. 

  5917. 

    5918. 

  5918.                 if (left == null)

    5919. 

  5919.                 {

    5920. 

  5920.                     if (result.Left != null)

    5921. 

  5921.                     {

    5922. 

  5922.                         Console.WriteLine("left was null");

    5923. 

  5923.                         return 1;

    5924. 

  5924.                     }

    5925. 

  5925.                 }

    5926. 

  5926.                 else

    5927. 

  5927.                 {

    5928. 

  5928.                     if (!(result.Left.Equals(left)))

    5929. 

  5929.                     {

    5930. 

  5930.                         Console.WriteLine("left was different");

    5931. 

  5931.                         return 1;

    5932. 

  5932.                     }

    5933. 

  5933.                 }

    5934. 

  5934. 

    5935. 

  5935.                 if (right == null)

    5936. 

  5936.                 {

    5937. 

  5937.                     if (result.Right != null) return 1;

    5938. 

  5938.                 }

    5939. 

  5939.                 else

    5940. 

  5940.                 {

    5941. 

  5941.                     if (!(result.Right.Equals(right))) return 1;

    5942. 

  5942.                 }

    5943. 

  5943. 

    5944. 

  5944.                 if (!(result.ToString() == str))

    5945. 

  5945.                 {

    5946. 

  5946.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    5947. 

  5947.                     return 1;

    5948. 

  5948.                 }

    5949. 

  5949. 

    5950. 

  5950.                 if (result.Method != mi) return 1;

    5951. 

  5951.                 if (result.IsLifted != islifted) return 1;

    5952. 

  5952.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5953. 

  5953. 

    5954. 

  5954.                 if (result.Conversion != null) return 1;

    5955. 

  5955. 

    5956. 

  5956.                 return 0;

    5957. 

  5957.             }

    5958. 

  5958. 

    5959. 

  5959.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    5960. 

  5960.             {

    5961. 

  5961.                 if (!(result.NodeType == et))

    5962. 

  5962.                 {

    5963. 

  5963.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    5964. 

  5964.                     return 1;

    5965. 

  5965.                 }

    5966. 

  5966.                 if (!(result.Type == type))

    5967. 

  5967.                 {

    5968. 

  5968.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    5969. 

  5969.                     return 1;

    5970. 

  5970.                 }

    5971. 

  5971. 

    5972. 

  5972.                 if (left == null)

    5973. 

  5973.                 {

    5974. 

  5974.                     if (result.Left != null) return 1;

    5975. 

  5975.                 }

    5976. 

  5976.                 else

    5977. 

  5977.                 {

    5978. 

  5978.                     if (!(result.Left.Equals(left))) return 1;

    5979. 

  5979.                 }

    5980. 

  5980. 

    5981. 

  5981.                 if (right == null)

    5982. 

  5982.                 {

    5983. 

  5983.                     if (result.Right != null) return 1;

    5984. 

  5984.                 }

    5985. 

  5985.                 else

    5986. 

  5986.                 {

    5987. 

  5987.                     if (!(result.Right.Equals(right))) return 1;

    5988. 

  5988.                 }

    5989. 

  5989. 

    5990. 

  5990.                 if (!(result.ToString() == str)) return 1;

    5991. 

  5991. 

    5992. 

  5992.                 if (result.Method != mi) return 1;

    5993. 

  5993.                 if (result.IsLifted != islifted) return 1;

    5994. 

  5994.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    5995. 

  5995. 

    5996. 

  5996.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    5997. 

  5997. 

    5998. 

  5998.                 return 0;

    5999. 

  5999.             }

    6000. 

  6000. 

    6001. 

  6001.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    6002. 

  6002.             {

    6003. 

  6003.                 if (!(result.NodeType == et))

    6004. 

  6004.                 {

    6005. 

  6005.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6006. 

  6006.                     return 1;

    6007. 

  6007.                 }

    6008. 

  6008.                 if (!(result.Type == type))

    6009. 

  6009.                 {

    6010. 

  6010.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6011. 

  6011.                     return 1;

    6012. 

  6012.                 }

    6013. 

  6013. 

    6014. 

  6014.                 if (!(result.Method == method)) return 1;

    6015. 

  6015. 

    6016. 

  6016.                 if (obj == null)

    6017. 

  6017.                 {

    6018. 

  6018.                     if (result.Object != null)

    6019. 

  6019.                     {

    6020. 

  6020.                         Console.WriteLine("Expected object to be null.");

    6021. 

  6021.                         return 1;

    6022. 

  6022.                     }

    6023. 

  6023.                 }

    6024. 

  6024.                 else

    6025. 

  6025.                 {

    6026. 

  6026.                     if (!(result.Object.Equals(obj)))

    6027. 

  6027.                     {

    6028. 

  6028.                         Console.WriteLine("Object on which call is made is different from the result.");

    6029. 

  6029.                         return 1;

    6030. 

  6030.                     }

    6031. 

  6031.                 }

    6032. 

  6032. 

    6033. 

  6033.                 if (!(result.ToString() == str))

    6034. 

  6034.                 {

    6035. 

  6035.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6036. 

  6036.                     return 1;

    6037. 

  6037.                 }

    6038. 

  6038. 

    6039. 

  6039.                 if (result.Arguments.Count != arguments.Length) return 1;

    6040. 

  6040. 

    6041. 

  6041.                 for (int i = 0; i < arguments.Length; i++)

    6042. 

  6042.                 {

    6043. 

  6043.                     if (result.Arguments[i] != arguments[i]) return 1;

    6044. 

  6044.                 }

    6045. 

  6045. 

    6046. 

  6046.                 return 0;

    6047. 

  6047.             }

    6048. 

  6048. 

    6049. 

  6049.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    6050. 

  6050.             {

    6051. 

  6051.                 if (!(result.NodeType == et))

    6052. 

  6052.                 {

    6053. 

  6053.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6054. 

  6054.                     return 1;

    6055. 

  6055.                 }

    6056. 

  6056.                 if (!(result.Type == type))

    6057. 

  6057.                 {

    6058. 

  6058.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6059. 

  6059.                     return 1;

    6060. 

  6060.                 }

    6061. 

  6061. 

    6062. 

  6062.                 if (expr == null)

    6063. 

  6063.                 {

    6064. 

  6064.                     Console.WriteLine("expr was null.");

    6065. 

  6065.                     if (result.Expression != null) return 1;

    6066. 

  6066.                 }

    6067. 

  6067.                 else

    6068. 

  6068.                 {

    6069. 

  6069.                     if (!(result.Expression.Equals(expr)))

    6070. 

  6070.                     {

    6071. 

  6071.                         return 1;

    6072. 

  6072.                     }

    6073. 

  6073.                 }

    6074. 

  6074. 

    6075. 

  6075.                 if (!(result.TypeOperand == typeop)) return 1;

    6076. 

  6076. 

    6077. 

  6077.                 if (!(result.ToString() == str))

    6078. 

  6078.                 {

    6079. 

  6079.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6080. 

  6080.                     return 1;

    6081. 

  6081.                 }

    6082. 

  6082. 

    6083. 

  6083.                 return 0;

    6084. 

  6084.             }

    6085. 

  6085. 

    6086. 

  6086.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    6087. 

  6087.             {

    6088. 

  6088.                 if (!(result.NodeType == et))

    6089. 

  6089.                 {

    6090. 

  6090.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6091. 

  6091.                     return 1;

    6092. 

  6092.                 }

    6093. 

  6093.                 if (!(result.Type == type))

    6094. 

  6094.                 {

    6095. 

  6095.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6096. 

  6096.                     return 1;

    6097. 

  6097.                 }

    6098. 

  6098. 

    6099. 

  6099.                 if (test == null)

    6100. 

  6100.                 {

    6101. 

  6101.                     if (result.Test != null) return 1;

    6102. 

  6102.                 }

    6103. 

  6103.                 else

    6104. 

  6104.                 {

    6105. 

  6105.                     if (!(result.Test.Equals(test))) return 1;

    6106. 

  6106.                 }

    6107. 

  6107. 

    6108. 

  6108.                 if (ifTrue == null)

    6109. 

  6109.                 {

    6110. 

  6110.                     if (result.IfTrue != null) return 1;

    6111. 

  6111.                 }

    6112. 

  6112.                 else

    6113. 

  6113.                 {

    6114. 

  6114.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    6115. 

  6115.                 }

    6116. 

  6116. 

    6117. 

  6117.                 if (ifFalse == null)

    6118. 

  6118.                 {

    6119. 

  6119.                     if (result.IfFalse != null) return 1;

    6120. 

  6120.                 }

    6121. 

  6121.                 else

    6122. 

  6122.                 {

    6123. 

  6123.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    6124. 

  6124.                 }

    6125. 

  6125. 

    6126. 

  6126.                 if (!(result.ToString() == str)) return 1;

    6127. 

  6127. 

    6128. 

  6128.                 return 0;

    6129. 

  6129.             }

    6130. 

  6130. 

    6131. 

  6131.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    6132. 

  6132.             {

    6133. 

  6133.                 if (!(result.NodeType == et))

    6134. 

  6134.                 {

    6135. 

  6135.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6136. 

  6136.                     return 1;

    6137. 

  6137.                 }

    6138. 

  6138.                 if (!(result.Type == type))

    6139. 

  6139.                 {

    6140. 

  6140.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6141. 

  6141.                     return 1;

    6142. 

  6142.                 }

    6143. 

  6143. 

    6144. 

  6144.                 if (exp_expr == null)

    6145. 

  6145.                 {

    6146. 

  6146.                     if (result.Expression != null)

    6147. 

  6147.                     {

    6148. 

  6148.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    6149. 

  6149.                         return 1;

    6150. 

  6150.                     }

    6151. 

  6151.                 }

    6152. 

  6152.                 else

    6153. 

  6153.                 {

    6154. 

  6154.                     if (!(result.Expression.Equals(exp_expr)))

    6155. 

  6155.                     {

    6156. 

  6156.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    6157. 

  6157.                         return 1;

    6158. 

  6158.                     }

    6159. 

  6159.                 }

    6160. 

  6160. 

    6161. 

  6161.                 if (!(result.Member == exp_member))

    6162. 

  6162.                 {

    6163. 

  6163.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    6164. 

  6164.                     return 1;

    6165. 

  6165.                 }

    6166. 

  6166. 

    6167. 

  6167.                 if (!(result.ToString() == str))

    6168. 

  6168.                 {

    6169. 

  6169.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6170. 

  6170.                     return 1;

    6171. 

  6171.                 }

    6172. 

  6172. 

    6173. 

  6173.                 return 0;

    6174. 

  6174.             }

    6175. 

  6175. 

    6176. 

  6176.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    6177. 

  6177.             {

    6178. 

  6178.                 if (!(result.NodeType == et))

    6179. 

  6179.                 {

    6180. 

  6180.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6181. 

  6181.                     return 1;

    6182. 

  6182.                 }

    6183. 

  6183.                 if (!(result.Type == type))

    6184. 

  6184.                 {

    6185. 

  6185.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6186. 

  6186.                     return 1;

    6187. 

  6187.                 }

    6188. 

  6188. 

    6189. 

  6189.                 if (!(result.Constructor == constructor))

    6190. 

  6190.                 {

    6191. 

  6191.                     Console.WriteLine("Unexpected constructor");

    6192. 

  6192.                     return 1;

    6193. 

  6193.                 }

    6194. 

  6194. 

    6195. 

  6195.                 if (!(result.ToString() == str))

    6196. 

  6196.                 {

    6197. 

  6197.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6198. 

  6198.                     return 1;

    6199. 

  6199.                 }

    6200. 

  6200. 

    6201. 

  6201.                 if (arguments == null)

    6202. 

  6202.                 {

    6203. 

  6203.                     if (result.Arguments.Count != 0)

    6204. 

  6204.                     {

    6205. 

  6205.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    6206. 

  6206.                         return 1;

    6207. 

  6207.                     }

    6208. 

  6208.                 }

    6209. 

  6209.                 else

    6210. 

  6210.                 {

    6211. 

  6211.                     if (result.Arguments.Count != arguments.Length)

    6212. 

  6212.                     {

    6213. 

  6213.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    6214. 

  6214.                         return 1;

    6215. 

  6215.                     }

    6216. 

  6216.                     for (int i = 0; i < arguments.Length; i++)

    6217. 

  6217.                     {

    6218. 

  6218.                         if (result.Arguments[i] != arguments[i])

    6219. 

  6219.                         {

    6220. 

  6220.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    6221. 

  6221.                             return 1;

    6222. 

  6222.                         }

    6223. 

  6223.                     }

    6224. 

  6224.                 }

    6225. 

  6225. 

    6226. 

  6226.                 if (result.Members == null)

    6227. 

  6227.                 {

    6228. 

  6228.                     Console.WriteLine("result.Members was null");

    6229. 

  6229.                     return 1;

    6230. 

  6230.                 }

    6231. 

  6231. 

    6232. 

  6232.                 if (members == null)

    6233. 

  6233.                 {

    6234. 

  6234.                     if (result.Members.Count != 0)

    6235. 

  6235.                     {

    6236. 

  6236.                         Console.WriteLine("Got more than zero members");

    6237. 

  6237.                         return 1;

    6238. 

  6238.                     }

    6239. 

  6239.                 }

    6240. 

  6240.                 else

    6241. 

  6241.                 {

    6242. 

  6242.                     if (result.Members.Count != members.Length)

    6243. 

  6243.                     {

    6244. 

  6244.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    6245. 

  6245.                         return 1;

    6246. 

  6246.                     }

    6247. 

  6247. 

    6248. 

  6248.                     for (int i = 0; i < members.Length; i++)

    6249. 

  6249.                     {

    6250. 

  6250.                         if (result.Members[i] != members[i])

    6251. 

  6251.                         {

    6252. 

  6252.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    6253. 

  6253.                             return 1;

    6254. 

  6254.                         }

    6255. 

  6255.                     }

    6256. 

  6256.                 }

    6257. 

  6257. 

    6258. 

  6258.                 return 0;

    6259. 

  6259.             }

    6260. 

  6260. 

    6261. 

  6261.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    6262. 

  6262.             {

    6263. 

  6263.                 if (!(result.NodeType == et))

    6264. 

  6264.                 {

    6265. 

  6265.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6266. 

  6266.                     return 1;

    6267. 

  6267.                 }

    6268. 

  6268.                 if (!(result.Type == type))

    6269. 

  6269.                 {

    6270. 

  6270.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6271. 

  6271.                     return 1;

    6272. 

  6272.                 }

    6273. 

  6273. 

    6274. 

  6274.                 if (!(result.Constructor == constructor))

    6275. 

  6275.                 {

    6276. 

  6276.                     Console.WriteLine("Constructor is different from expected.");

    6277. 

  6277.                     return 1;

    6278. 

  6278.                 }

    6279. 

  6279. 

    6280. 

  6280.                 if (!(result.ToString() == str))

    6281. 

  6281.                 {

    6282. 

  6282.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6283. 

  6283.                     return 1;

    6284. 

  6284.                 }

    6285. 

  6285. 

    6286. 

  6286.                 if (result.Arguments.Count != arguments.Length)

    6287. 

  6287.                 {

    6288. 

  6288.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    6289. 

  6289.                     return 1;

    6290. 

  6290.                 }

    6291. 

  6291. 

    6292. 

  6292.                 for (int i = 0; i < arguments.Length; i++)

    6293. 

  6293.                 {

    6294. 

  6294.                     if (result.Arguments[i] != arguments[i])

    6295. 

  6295.                     {

    6296. 

  6296.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    6297. 

  6297.                         return 1;

    6298. 

  6298.                     }

    6299. 

  6299.                 }

    6300. 

  6300. 

    6301. 

  6301.                 if (result.Members != null)

    6302. 

  6302.                 {

    6303. 

  6303.                     Console.WriteLine("result.Members isn't null");

    6304. 

  6304.                     return 1;

    6305. 

  6305.                 }

    6306. 

  6306. 

    6307. 

  6307.                 return 0;

    6308. 

  6308.             }

    6309. 

  6309. 

    6310. 

  6310.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    6311. 

  6311.             {

    6312. 

  6312.                 if (!(result.NodeType == et))

    6313. 

  6313.                 {

    6314. 

  6314.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6315. 

  6315.                     return 1;

    6316. 

  6316.                 }

    6317. 

  6317.                 if (!(result.Type == type))

    6318. 

  6318.                 {

    6319. 

  6319.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6320. 

  6320.                     return 1;

    6321. 

  6321.                 }

    6322. 

  6322. 

    6323. 

  6323.                 if (!(result.NewExpression == newExpression)) return 1;

    6324. 

  6324. 

    6325. 

  6325.                 if (!(result.ToString() == str))

    6326. 

  6326.                 {

    6327. 

  6327.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6328. 

  6328.                     return 1;

    6329. 

  6329.                 }

    6330. 

  6330. 

    6331. 

  6331.                 if (result.Initializers.Count != initializers.Length) return 1;

    6332. 

  6332. 

    6333. 

  6333.                 for (int i = 0; i < initializers.Length; i++)

    6334. 

  6334.                 {

    6335. 

  6335.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    6336. 

  6336. 

    6337. 

  6337.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    6338. 

  6338. 

    6339. 

  6339.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    6340. 

  6340.                     {

    6341. 

  6341.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    6342. 

  6342.                     }

    6343. 

  6343.                 }

    6344. 

  6344. 

    6345. 

  6345.                 return 0;

    6346. 

  6346.             }

    6347. 

  6347. 

    6348. 

  6348.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    6349. 

  6349.             {

    6350. 

  6350.                 if (result.AddMethod != exp_mi) return 1;

    6351. 

  6351.                 if (!(result.ToString() == str))

    6352. 

  6352.                 {

    6353. 

  6353.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6354. 

  6354.                     return 1;

    6355. 

  6355.                 }

    6356. 

  6356. 

    6357. 

  6357.                 if (result.Arguments.Count != args.Length) return 1;

    6358. 

  6358. 

    6359. 

  6359.                 for (int i = 0; i < args.Length; i++)

    6360. 

  6360.                 {

    6361. 

  6361.                     if (result.Arguments[i] != args[i]) return 1;

    6362. 

  6362.                 }

    6363. 

  6363. 

    6364. 

  6364.                 return 0;

    6365. 

  6365.             }

    6366. 

  6366. 

    6367. 

  6367.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    6368. 

  6368.             {

    6369. 

  6369.                 if (!(result.BindingType == bt)) return 1;

    6370. 

  6370.                 if (!(result.Expression == expr)) return 1;

    6371. 

  6371.                 if (!(result.Member.Equals(member))) return 1;

    6372. 

  6372.                 if (!(result.ToString() == str))

    6373. 

  6373.                 {

    6374. 

  6374.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6375. 

  6375.                     return 1;

    6376. 

  6376.                 }

    6377. 

  6377. 

    6378. 

  6378.                 return 0;

    6379. 

  6379.             }

    6380. 

  6380. 

    6381. 

  6381.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    6382. 

  6382.             {

    6383. 

  6383.                 if (!(result.BindingType == bt)) return 1;

    6384. 

  6384. 

    6385. 

  6385.                 if (!(result.Member.Equals(member))) return 1;

    6386. 

  6386.                 if (!(result.ToString() == str))

    6387. 

  6387.                 {

    6388. 

  6388.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6389. 

  6389.                     return 1;

    6390. 

  6390.                 }

    6391. 

  6391. 

    6392. 

  6392.                 if (result.Initializers.Count != initializers.Length) return 1;

    6393. 

  6393. 

    6394. 

  6394.                 for (int i = 0; i < initializers.Length; i++)

    6395. 

  6395.                 {

    6396. 

  6396.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    6397. 

  6397. 

    6398. 

  6398.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    6399. 

  6399. 

    6400. 

  6400.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    6401. 

  6401.                     {

    6402. 

  6402.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    6403. 

  6403.                     }

    6404. 

  6404.                 }

    6405. 

  6405. 

    6406. 

  6406. 

    6407. 

  6407.                 return 0;

    6408. 

  6408.             }

    6409. 

  6409. 

    6410. 

  6410.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    6411. 

  6411.             {

    6412. 

  6412.                 if (!(result.BindingType == bt)) return 1;

    6413. 

  6413. 

    6414. 

  6414.                 if (!(result.Member.Equals(member))) return 1;

    6415. 

  6415.                 if (!(result.ToString() == str))

    6416. 

  6416.                 {

    6417. 

  6417.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6418. 

  6418.                     return 1;

    6419. 

  6419.                 }

    6420. 

  6420. 

    6421. 

  6421.                 if (result.Bindings.Count != bindings.Length) return 1;

    6422. 

  6422. 

    6423. 

  6423.                 for (int i = 0; i < bindings.Length; i++)

    6424. 

  6424.                 {

    6425. 

  6425.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    6426. 

  6426.                 }

    6427. 

  6427. 

    6428. 

  6428.                 return 0;

    6429. 

  6429.             }

    6430. 

  6430. 

    6431. 

  6431.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    6432. 

  6432.             {

    6433. 

  6433.                 if (!(result.NodeType == et))

    6434. 

  6434.                 {

    6435. 

  6435.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6436. 

  6436.                     return 1;

    6437. 

  6437.                 }

    6438. 

  6438.                 if (!(result.Type == type))

    6439. 

  6439.                 {

    6440. 

  6440.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6441. 

  6441.                     return 1;

    6442. 

  6442.                 }

    6443. 

  6443.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    6444. 

  6444.                 if (!(result.ToString() == str)) return 1;

    6445. 

  6445. 

    6446. 

  6446.                 if (result.Bindings.Count != bindings.Length) return 1;

    6447. 

  6447. 

    6448. 

  6448.                 for (int i = 0; i < bindings.Length; i++)

    6449. 

  6449.                 {

    6450. 

  6450.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    6451. 

  6451.                 }

    6452. 

  6452. 

    6453. 

  6453.                 return 0;

    6454. 

  6454.             }

    6455. 

  6455. 

    6456. 

  6456.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    6457. 

  6457.             {

    6458. 

  6458.                 if (!(result.NodeType == et))

    6459. 

  6459.                 {

    6460. 

  6460.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6461. 

  6461.                     return 1;

    6462. 

  6462.                 }

    6463. 

  6463.                 if (!(result.Type == type))

    6464. 

  6464.                 {

    6465. 

  6465.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6466. 

  6466.                     return 1;

    6467. 

  6467.                 }

    6468. 

  6468. 

    6469. 

  6469.                 if (result.Expressions.Count != expr.Length) return 1;

    6470. 

  6470. 

    6471. 

  6471.                 for (int i = 0; i < expr.Length; i++)

    6472. 

  6472.                 {

    6473. 

  6473.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    6474. 

  6474.                 }

    6475. 

  6475.                 if (!(result.ToString() == str))

    6476. 

  6476.                 {

    6477. 

  6477.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6478. 

  6478.                     return 1;

    6479. 

  6479.                 }

    6480. 

  6480. 

    6481. 

  6481.                 return 0;

    6482. 

  6482.             }

    6483. 

  6483. 

    6484. 

  6484.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    6485. 

  6485.             {

    6486. 

  6486.                 if (!(result.NodeType == et))

    6487. 

  6487.                 {

    6488. 

  6488.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6489. 

  6489.                     return 1;

    6490. 

  6490.                 }

    6491. 

  6491.                 if (!(result.Type == type))

    6492. 

  6492.                 {

    6493. 

  6493.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6494. 

  6494.                     return 1;

    6495. 

  6495.                 }

    6496. 

  6496.                 if (!(result.Name == name)) return 1;

    6497. 

  6497. 

    6498. 

  6498.                 if (!(result.ToString() == str))

    6499. 

  6499.                 {

    6500. 

  6500.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6501. 

  6501.                     return 1;

    6502. 

  6502.                 }

    6503. 

  6503. 

    6504. 

  6504.                 return 0;

    6505. 

  6505.             }

    6506. 

  6506. 

    6507. 

  6507.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    6508. 

  6508.             {

    6509. 

  6509.                 if (!(result.NodeType == et))

    6510. 

  6510.                 {

    6511. 

  6511.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6512. 

  6512.                     return 1;

    6513. 

  6513.                 }

    6514. 

  6514.                 if (!(result.Type == type))

    6515. 

  6515.                 {

    6516. 

  6516.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6517. 

  6517.                     return 1;

    6518. 

  6518.                 }

    6519. 

  6519. 

    6520. 

  6520.                 if (expr == null)

    6521. 

  6521.                 {

    6522. 

  6522.                     if (result.Body != null) return 1;

    6523. 

  6523.                 }

    6524. 

  6524.                 else

    6525. 

  6525.                 {

    6526. 

  6526.                     if (!(result.Body.Equals(expr))) return 1;

    6527. 

  6527.                 }

    6528. 

  6528. 

    6529. 

  6529.                 if (result.Parameters.Count != parms.Length) return 1;

    6530. 

  6530. 

    6531. 

  6531.                 for (int i = 0; i < parms.Length; i++)

    6532. 

  6532.                 {

    6533. 

  6533.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    6534. 

  6534.                 }

    6535. 

  6535. 

    6536. 

  6536.                 if (!(result.ToString() == str))

    6537. 

  6537.                 {

    6538. 

  6538.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    6539. 

  6539.                     return 1;

    6540. 

  6540.                 }

    6541. 

  6541. 

    6542. 

  6542.                 return 0;

    6543. 

  6543.             }

    6544. 

  6544. 

    6545. 

  6545.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    6546. 

  6546.             {

    6547. 

  6547.                 if (!(result.NodeType == et))

    6548. 

  6548.                 {

    6549. 

  6549.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6550. 

  6550.                     return 1;

    6551. 

  6551.                 }

    6552. 

  6552.                 if (!(result.Type == type))

    6553. 

  6553.                 {

    6554. 

  6554.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6555. 

  6555.                     return 1;

    6556. 

  6556.                 }

    6557. 

  6557. 

    6558. 

  6558.                 if (expr == null)

    6559. 

  6559.                 {

    6560. 

  6560.                     if (result.Expression != null) return 1;

    6561. 

  6561.                 }

    6562. 

  6562.                 else

    6563. 

  6563.                 {

    6564. 

  6564.                     if (!(result.Expression.Equals(expr))) return 1;

    6565. 

  6565.                 }

    6566. 

  6566. 

    6567. 

  6567.                 if (result.Arguments.Count != args.Length) return 1;

    6568. 

  6568. 

    6569. 

  6569.                 for (int i = 0; i < args.Length; i++)

    6570. 

  6570.                 {

    6571. 

  6571.                     if (!(result.Arguments[i].Equals(args[i])))

    6572. 

  6572.                     {

    6573. 

  6573.                         return 1;

    6574. 

  6574.                     }

    6575. 

  6575.                 }

    6576. 

  6576. 

    6577. 

  6577.                 if (result.ToString() != str)

    6578. 

  6578.                 {

    6579. 

  6579.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6580. 

  6580.                     return 1;

    6581. 

  6581.                 }

    6582. 

  6582. 

    6583. 

  6583.                 return 0;

    6584. 

  6584.             }

    6585. 

  6585.         }

    6586. 

  6586. 

    6587. 

  6587. 

    6588. 

  6588. 

    6589. 

  6589.         namespace Not

    6590. 

  6590.         {

    6591. 

  6591.             // Declaring user-defined types for testing

    6592. 

  6592.             struct TC1

    6593. 

  6593.             {

    6594. 

  6594.                 public static TC1 operator !(TC1 c)

    6595. 

  6595.                 {

    6596. 

  6596.                     return new TC1();

    6597. 

  6597.                 }

    6598. 

  6598. 

    6599. 

  6599.                 public static TC1 operator ~(TC1 c)

    6600. 

  6600.                 {

    6601. 

  6601.                     return new TC1();

    6602. 

  6602.                 }

    6603. 

  6603.             }

    6604. 

  6604. 

    6605. 

  6605.             struct TC2

    6606. 

  6606.             {

    6607. 

  6607.                 public static TC2 operator ~(TC2 c)

    6608. 

  6608.                 {

    6609. 

  6609.                     return new TC2();

    6610. 

  6610.                 }

    6611. 

  6611.             }

    6612. 

  6612. 

    6613. 

  6613.             struct TC3

    6614. 

  6614.             {

    6615. 

  6615.                 public static TC3 Meth1(TC3 c)

    6616. 

  6616.                 {

    6617. 

  6617.                     return new TC3();

    6618. 

  6618.                 }

    6619. 

  6619.             }

    6620. 

  6620.         }

    6621. 

  6621. 

    6622. 

  6622.     }

    6623. 

  6623. 

    6624. 

  6624.     //-------- Scenario 790

    6625. 

  6625.     namespace Scenario790

    6626. 

  6626.     {

    6627. 

  6627. 

    6628. 

  6628.         namespace Not

    6629. 

  6629.         {

    6630. 

  6630.             public class Test

    6631. 

  6631.             {

    6632. 

  6632.                 // Overload-1: Test for functionality: Argument is of type user-defined type (Bitwise Complement)

    6633. 

  6633.                 public static int Test9()

    6634. 

  6634.                 {

    6635. 

  6635.                     TC2 ctest = new TC2();

    6636. 

  6636.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC2));

    6637. 

  6637.                     Type exp_type = typeof(TC2);

    6638. 

  6638.                     ExpressionType exp_et = ExpressionType.Not;

    6639. 

  6639.                     string exp_str = "Not(" + ce.ToString() + ")";

    6640. 

  6640.                     Expression exp_operand = ce;

    6641. 

  6641.                     MethodInfo exp_mi = typeof(TC2).GetMethod("op_OnesComplement");

    6642. 

  6642. 

    6643. 

  6643.                     UnaryExpression result = Expression.Not(ce);

    6644. 

  6644. 

    6645. 

  6645.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, false, false);

    6646. 

  6646.                 }

    6647. 

  6647. 

    6648. 

  6648. 

    6649. 

  6649.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not9__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    6650. 

  6650.                 public static Expression Not9__()

    6651. 

  6651.                 {

    6652. 

  6652.                     if (Main() != 0)

    6653. 

  6653.                     {

    6654. 

  6654.                         throw new Exception();

    6655. 

  6655.                     }

    6656. 

  6656.                     else

    6657. 

  6657.                     {

    6658. 

  6658.                         return Expression.Constant(0);

    6659. 

  6659.                     }

    6660. 

  6660.                 }

    6661. 

  6661.                 public static int Main()

    6662. 

  6662.                 {

    6663. 

  6663.                     return Test9();

    6664. 

  6664.                 }

    6665. 

  6665.             }

    6666. 

  6666.         }

    6667. 

  6667. 

    6668. 

  6668. 

    6669. 

  6669.         public static class Extension

    6670. 

  6670.         {

    6671. 

  6671.             public static bool CompareParamName(this ArgumentException ex, string expected)

    6672. 

  6672.             {

    6673. 

  6673. #if SILVERLIGHT

    6674. 

  6674. #if SLRESOURCES

    6675. 

  6675. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    6676. 

  6676. #else

    6677. 

  6677. 				        return true;

    6678. 

  6678. #endif

    6679. 

  6679. #else

    6680. 

  6680.                 return ex.ParamName == expected;

    6681. 

  6681. #endif

    6682. 

  6682.             }

    6683. 

  6683. 

    6684. 

  6684.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    6685. 

  6685.             {

    6686. 

  6686. #if SILVERLIGHT

    6687. 

  6687. #if SLRESOURCES

    6688. 

  6688. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    6689. 

  6689. #else

    6690. 

  6690. 				        return true;

    6691. 

  6691. #endif

    6692. 

  6692. #else

    6693. 

  6693.                 return ex.ParamName == expected;

    6694. 

  6694. #endif

    6695. 

  6695.             }

    6696. 

  6696.         }

    6697. 

  6697. 

    6698. 

  6698.         public static class Verification

    6699. 

  6699.         {

    6700. 

  6700.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    6701. 

  6701.             {

    6702. 

  6702.                 if (!(result.NodeType == et))

    6703. 

  6703.                 {

    6704. 

  6704.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6705. 

  6705.                     return 1;

    6706. 

  6706.                 }

    6707. 

  6707.                 if (!(result.Type == type))

    6708. 

  6708.                 {

    6709. 

  6709.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6710. 

  6710.                     return 1;

    6711. 

  6711.                 }

    6712. 

  6712.                 if (val == null)

    6713. 

  6713.                 {

    6714. 

  6714.                     if (result.Value != null) return 1;

    6715. 

  6715.                 }

    6716. 

  6716.                 else

    6717. 

  6717.                 {

    6718. 

  6718.                     if (!(result.Value.Equals(val))) return 1;

    6719. 

  6719.                 }

    6720. 

  6720.                 if (!(result.ToString() == str)) return 1;

    6721. 

  6721.                 return 0;

    6722. 

  6722.             }

    6723. 

  6723. 

    6724. 

  6724.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    6725. 

  6725.             {

    6726. 

  6726.                 if (!(result.NodeType == et))

    6727. 

  6727.                 {

    6728. 

  6728.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6729. 

  6729.                     return 1;

    6730. 

  6730.                 }

    6731. 

  6731.                 if (!(result.Type == type))

    6732. 

  6732.                 {

    6733. 

  6733.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6734. 

  6734.                     return 1;

    6735. 

  6735.                 }

    6736. 

  6736.                 if (operand == null)

    6737. 

  6737.                 {

    6738. 

  6738.                     if (result.Operand != null) return 1;

    6739. 

  6739.                 }

    6740. 

  6740.                 else

    6741. 

  6741.                 {

    6742. 

  6742.                     if (!(result.Operand.Equals(operand))) return 1;

    6743. 

  6743.                 }

    6744. 

  6744.                 if (!(result.ToString() == str))

    6745. 

  6745.                 {

    6746. 

  6746.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6747. 

  6747.                     return 1;

    6748. 

  6748.                 }

    6749. 

  6749. 

    6750. 

  6750.                 if (result.Method != mi) return 1;

    6751. 

  6751.                 if (result.IsLifted != islifted) return 1;

    6752. 

  6752.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    6753. 

  6753. 

    6754. 

  6754.                 return 0;

    6755. 

  6755.             }

    6756. 

  6756. 

    6757. 

  6757.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    6758. 

  6758.             {

    6759. 

  6759.                 if (!(result.NodeType == et))

    6760. 

  6760.                 {

    6761. 

  6761.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6762. 

  6762.                     return 1;

    6763. 

  6763.                 }

    6764. 

  6764.                 if (!(result.Type == type))

    6765. 

  6765.                 {

    6766. 

  6766.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6767. 

  6767.                     return 1;

    6768. 

  6768.                 }

    6769. 

  6769. 

    6770. 

  6770.                 if (left == null)

    6771. 

  6771.                 {

    6772. 

  6772.                     if (result.Left != null)

    6773. 

  6773.                     {

    6774. 

  6774.                         Console.WriteLine("left was null");

    6775. 

  6775.                         return 1;

    6776. 

  6776.                     }

    6777. 

  6777.                 }

    6778. 

  6778.                 else

    6779. 

  6779.                 {

    6780. 

  6780.                     if (!(result.Left.Equals(left)))

    6781. 

  6781.                     {

    6782. 

  6782.                         Console.WriteLine("left was different");

    6783. 

  6783.                         return 1;

    6784. 

  6784.                     }

    6785. 

  6785.                 }

    6786. 

  6786. 

    6787. 

  6787.                 if (right == null)

    6788. 

  6788.                 {

    6789. 

  6789.                     if (result.Right != null) return 1;

    6790. 

  6790.                 }

    6791. 

  6791.                 else

    6792. 

  6792.                 {

    6793. 

  6793.                     if (!(result.Right.Equals(right))) return 1;

    6794. 

  6794.                 }

    6795. 

  6795. 

    6796. 

  6796.                 if (!(result.ToString() == str))

    6797. 

  6797.                 {

    6798. 

  6798.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6799. 

  6799.                     return 1;

    6800. 

  6800.                 }

    6801. 

  6801. 

    6802. 

  6802.                 if (result.Method != mi) return 1;

    6803. 

  6803.                 if (result.IsLifted != islifted) return 1;

    6804. 

  6804.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    6805. 

  6805. 

    6806. 

  6806.                 if (result.Conversion != null) return 1;

    6807. 

  6807. 

    6808. 

  6808.                 return 0;

    6809. 

  6809.             }

    6810. 

  6810. 

    6811. 

  6811.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    6812. 

  6812.             {

    6813. 

  6813.                 if (!(result.NodeType == et))

    6814. 

  6814.                 {

    6815. 

  6815.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6816. 

  6816.                     return 1;

    6817. 

  6817.                 }

    6818. 

  6818.                 if (!(result.Type == type))

    6819. 

  6819.                 {

    6820. 

  6820.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6821. 

  6821.                     return 1;

    6822. 

  6822.                 }

    6823. 

  6823. 

    6824. 

  6824.                 if (left == null)

    6825. 

  6825.                 {

    6826. 

  6826.                     if (result.Left != null) return 1;

    6827. 

  6827.                 }

    6828. 

  6828.                 else

    6829. 

  6829.                 {

    6830. 

  6830.                     if (!(result.Left.Equals(left))) return 1;

    6831. 

  6831.                 }

    6832. 

  6832. 

    6833. 

  6833.                 if (right == null)

    6834. 

  6834.                 {

    6835. 

  6835.                     if (result.Right != null) return 1;

    6836. 

  6836.                 }

    6837. 

  6837.                 else

    6838. 

  6838.                 {

    6839. 

  6839.                     if (!(result.Right.Equals(right))) return 1;

    6840. 

  6840.                 }

    6841. 

  6841. 

    6842. 

  6842.                 if (!(result.ToString() == str)) return 1;

    6843. 

  6843. 

    6844. 

  6844.                 if (result.Method != mi) return 1;

    6845. 

  6845.                 if (result.IsLifted != islifted) return 1;

    6846. 

  6846.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    6847. 

  6847. 

    6848. 

  6848.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    6849. 

  6849. 

    6850. 

  6850.                 return 0;

    6851. 

  6851.             }

    6852. 

  6852. 

    6853. 

  6853.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    6854. 

  6854.             {

    6855. 

  6855.                 if (!(result.NodeType == et))

    6856. 

  6856.                 {

    6857. 

  6857.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6858. 

  6858.                     return 1;

    6859. 

  6859.                 }

    6860. 

  6860.                 if (!(result.Type == type))

    6861. 

  6861.                 {

    6862. 

  6862.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6863. 

  6863.                     return 1;

    6864. 

  6864.                 }

    6865. 

  6865. 

    6866. 

  6866.                 if (!(result.Method == method)) return 1;

    6867. 

  6867. 

    6868. 

  6868.                 if (obj == null)

    6869. 

  6869.                 {

    6870. 

  6870.                     if (result.Object != null)

    6871. 

  6871.                     {

    6872. 

  6872.                         Console.WriteLine("Expected object to be null.");

    6873. 

  6873.                         return 1;

    6874. 

  6874.                     }

    6875. 

  6875.                 }

    6876. 

  6876.                 else

    6877. 

  6877.                 {

    6878. 

  6878.                     if (!(result.Object.Equals(obj)))

    6879. 

  6879.                     {

    6880. 

  6880.                         Console.WriteLine("Object on which call is made is different from the result.");

    6881. 

  6881.                         return 1;

    6882. 

  6882.                     }

    6883. 

  6883.                 }

    6884. 

  6884. 

    6885. 

  6885.                 if (!(result.ToString() == str))

    6886. 

  6886.                 {

    6887. 

  6887.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6888. 

  6888.                     return 1;

    6889. 

  6889.                 }

    6890. 

  6890. 

    6891. 

  6891.                 if (result.Arguments.Count != arguments.Length) return 1;

    6892. 

  6892. 

    6893. 

  6893.                 for (int i = 0; i < arguments.Length; i++)

    6894. 

  6894.                 {

    6895. 

  6895.                     if (result.Arguments[i] != arguments[i]) return 1;

    6896. 

  6896.                 }

    6897. 

  6897. 

    6898. 

  6898.                 return 0;

    6899. 

  6899.             }

    6900. 

  6900. 

    6901. 

  6901.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    6902. 

  6902.             {

    6903. 

  6903.                 if (!(result.NodeType == et))

    6904. 

  6904.                 {

    6905. 

  6905.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6906. 

  6906.                     return 1;

    6907. 

  6907.                 }

    6908. 

  6908.                 if (!(result.Type == type))

    6909. 

  6909.                 {

    6910. 

  6910.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6911. 

  6911.                     return 1;

    6912. 

  6912.                 }

    6913. 

  6913. 

    6914. 

  6914.                 if (expr == null)

    6915. 

  6915.                 {

    6916. 

  6916.                     Console.WriteLine("expr was null.");

    6917. 

  6917.                     if (result.Expression != null) return 1;

    6918. 

  6918.                 }

    6919. 

  6919.                 else

    6920. 

  6920.                 {

    6921. 

  6921.                     if (!(result.Expression.Equals(expr)))

    6922. 

  6922.                     {

    6923. 

  6923.                         return 1;

    6924. 

  6924.                     }

    6925. 

  6925.                 }

    6926. 

  6926. 

    6927. 

  6927.                 if (!(result.TypeOperand == typeop)) return 1;

    6928. 

  6928. 

    6929. 

  6929.                 if (!(result.ToString() == str))

    6930. 

  6930.                 {

    6931. 

  6931.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    6932. 

  6932.                     return 1;

    6933. 

  6933.                 }

    6934. 

  6934. 

    6935. 

  6935.                 return 0;

    6936. 

  6936.             }

    6937. 

  6937. 

    6938. 

  6938.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    6939. 

  6939.             {

    6940. 

  6940.                 if (!(result.NodeType == et))

    6941. 

  6941.                 {

    6942. 

  6942.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6943. 

  6943.                     return 1;

    6944. 

  6944.                 }

    6945. 

  6945.                 if (!(result.Type == type))

    6946. 

  6946.                 {

    6947. 

  6947.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6948. 

  6948.                     return 1;

    6949. 

  6949.                 }

    6950. 

  6950. 

    6951. 

  6951.                 if (test == null)

    6952. 

  6952.                 {

    6953. 

  6953.                     if (result.Test != null) return 1;

    6954. 

  6954.                 }

    6955. 

  6955.                 else

    6956. 

  6956.                 {

    6957. 

  6957.                     if (!(result.Test.Equals(test))) return 1;

    6958. 

  6958.                 }

    6959. 

  6959. 

    6960. 

  6960.                 if (ifTrue == null)

    6961. 

  6961.                 {

    6962. 

  6962.                     if (result.IfTrue != null) return 1;

    6963. 

  6963.                 }

    6964. 

  6964.                 else

    6965. 

  6965.                 {

    6966. 

  6966.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    6967. 

  6967.                 }

    6968. 

  6968. 

    6969. 

  6969.                 if (ifFalse == null)

    6970. 

  6970.                 {

    6971. 

  6971.                     if (result.IfFalse != null) return 1;

    6972. 

  6972.                 }

    6973. 

  6973.                 else

    6974. 

  6974.                 {

    6975. 

  6975.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    6976. 

  6976.                 }

    6977. 

  6977. 

    6978. 

  6978.                 if (!(result.ToString() == str)) return 1;

    6979. 

  6979. 

    6980. 

  6980.                 return 0;

    6981. 

  6981.             }

    6982. 

  6982. 

    6983. 

  6983.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    6984. 

  6984.             {

    6985. 

  6985.                 if (!(result.NodeType == et))

    6986. 

  6986.                 {

    6987. 

  6987.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    6988. 

  6988.                     return 1;

    6989. 

  6989.                 }

    6990. 

  6990.                 if (!(result.Type == type))

    6991. 

  6991.                 {

    6992. 

  6992.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    6993. 

  6993.                     return 1;

    6994. 

  6994.                 }

    6995. 

  6995. 

    6996. 

  6996.                 if (exp_expr == null)

    6997. 

  6997.                 {

    6998. 

  6998.                     if (result.Expression != null)

    6999. 

  6999.                     {

    7000. 

  7000.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    7001. 

  7001.                         return 1;

    7002. 

  7002.                     }

    7003. 

  7003.                 }

    7004. 

  7004.                 else

    7005. 

  7005.                 {

    7006. 

  7006.                     if (!(result.Expression.Equals(exp_expr)))

    7007. 

  7007.                     {

    7008. 

  7008.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    7009. 

  7009.                         return 1;

    7010. 

  7010.                     }

    7011. 

  7011.                 }

    7012. 

  7012. 

    7013. 

  7013.                 if (!(result.Member == exp_member))

    7014. 

  7014.                 {

    7015. 

  7015.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    7016. 

  7016.                     return 1;

    7017. 

  7017.                 }

    7018. 

  7018. 

    7019. 

  7019.                 if (!(result.ToString() == str))

    7020. 

  7020.                 {

    7021. 

  7021.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7022. 

  7022.                     return 1;

    7023. 

  7023.                 }

    7024. 

  7024. 

    7025. 

  7025.                 return 0;

    7026. 

  7026.             }

    7027. 

  7027. 

    7028. 

  7028.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    7029. 

  7029.             {

    7030. 

  7030.                 if (!(result.NodeType == et))

    7031. 

  7031.                 {

    7032. 

  7032.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7033. 

  7033.                     return 1;

    7034. 

  7034.                 }

    7035. 

  7035.                 if (!(result.Type == type))

    7036. 

  7036.                 {

    7037. 

  7037.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7038. 

  7038.                     return 1;

    7039. 

  7039.                 }

    7040. 

  7040. 

    7041. 

  7041.                 if (!(result.Constructor == constructor))

    7042. 

  7042.                 {

    7043. 

  7043.                     Console.WriteLine("Unexpected constructor");

    7044. 

  7044.                     return 1;

    7045. 

  7045.                 }

    7046. 

  7046. 

    7047. 

  7047.                 if (!(result.ToString() == str))

    7048. 

  7048.                 {

    7049. 

  7049.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7050. 

  7050.                     return 1;

    7051. 

  7051.                 }

    7052. 

  7052. 

    7053. 

  7053.                 if (arguments == null)

    7054. 

  7054.                 {

    7055. 

  7055.                     if (result.Arguments.Count != 0)

    7056. 

  7056.                     {

    7057. 

  7057.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    7058. 

  7058.                         return 1;

    7059. 

  7059.                     }

    7060. 

  7060.                 }

    7061. 

  7061.                 else

    7062. 

  7062.                 {

    7063. 

  7063.                     if (result.Arguments.Count != arguments.Length)

    7064. 

  7064.                     {

    7065. 

  7065.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    7066. 

  7066.                         return 1;

    7067. 

  7067.                     }

    7068. 

  7068.                     for (int i = 0; i < arguments.Length; i++)

    7069. 

  7069.                     {

    7070. 

  7070.                         if (result.Arguments[i] != arguments[i])

    7071. 

  7071.                         {

    7072. 

  7072.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    7073. 

  7073.                             return 1;

    7074. 

  7074.                         }

    7075. 

  7075.                     }

    7076. 

  7076.                 }

    7077. 

  7077. 

    7078. 

  7078.                 if (result.Members == null)

    7079. 

  7079.                 {

    7080. 

  7080.                     Console.WriteLine("result.Members was null");

    7081. 

  7081.                     return 1;

    7082. 

  7082.                 }

    7083. 

  7083. 

    7084. 

  7084.                 if (members == null)

    7085. 

  7085.                 {

    7086. 

  7086.                     if (result.Members.Count != 0)

    7087. 

  7087.                     {

    7088. 

  7088.                         Console.WriteLine("Got more than zero members");

    7089. 

  7089.                         return 1;

    7090. 

  7090.                     }

    7091. 

  7091.                 }

    7092. 

  7092.                 else

    7093. 

  7093.                 {

    7094. 

  7094.                     if (result.Members.Count != members.Length)

    7095. 

  7095.                     {

    7096. 

  7096.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    7097. 

  7097.                         return 1;

    7098. 

  7098.                     }

    7099. 

  7099. 

    7100. 

  7100.                     for (int i = 0; i < members.Length; i++)

    7101. 

  7101.                     {

    7102. 

  7102.                         if (result.Members[i] != members[i])

    7103. 

  7103.                         {

    7104. 

  7104.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    7105. 

  7105.                             return 1;

    7106. 

  7106.                         }

    7107. 

  7107.                     }

    7108. 

  7108.                 }

    7109. 

  7109. 

    7110. 

  7110.                 return 0;

    7111. 

  7111.             }

    7112. 

  7112. 

    7113. 

  7113.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    7114. 

  7114.             {

    7115. 

  7115.                 if (!(result.NodeType == et))

    7116. 

  7116.                 {

    7117. 

  7117.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7118. 

  7118.                     return 1;

    7119. 

  7119.                 }

    7120. 

  7120.                 if (!(result.Type == type))

    7121. 

  7121.                 {

    7122. 

  7122.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7123. 

  7123.                     return 1;

    7124. 

  7124.                 }

    7125. 

  7125. 

    7126. 

  7126.                 if (!(result.Constructor == constructor))

    7127. 

  7127.                 {

    7128. 

  7128.                     Console.WriteLine("Constructor is different from expected.");

    7129. 

  7129.                     return 1;

    7130. 

  7130.                 }

    7131. 

  7131. 

    7132. 

  7132.                 if (!(result.ToString() == str))

    7133. 

  7133.                 {

    7134. 

  7134.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7135. 

  7135.                     return 1;

    7136. 

  7136.                 }

    7137. 

  7137. 

    7138. 

  7138.                 if (result.Arguments.Count != arguments.Length)

    7139. 

  7139.                 {

    7140. 

  7140.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    7141. 

  7141.                     return 1;

    7142. 

  7142.                 }

    7143. 

  7143. 

    7144. 

  7144.                 for (int i = 0; i < arguments.Length; i++)

    7145. 

  7145.                 {

    7146. 

  7146.                     if (result.Arguments[i] != arguments[i])

    7147. 

  7147.                     {

    7148. 

  7148.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    7149. 

  7149.                         return 1;

    7150. 

  7150.                     }

    7151. 

  7151.                 }

    7152. 

  7152. 

    7153. 

  7153.                 if (result.Members != null)

    7154. 

  7154.                 {

    7155. 

  7155.                     Console.WriteLine("result.Members isn't null");

    7156. 

  7156.                     return 1;

    7157. 

  7157.                 }

    7158. 

  7158. 

    7159. 

  7159.                 return 0;

    7160. 

  7160.             }

    7161. 

  7161. 

    7162. 

  7162.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    7163. 

  7163.             {

    7164. 

  7164.                 if (!(result.NodeType == et))

    7165. 

  7165.                 {

    7166. 

  7166.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7167. 

  7167.                     return 1;

    7168. 

  7168.                 }

    7169. 

  7169.                 if (!(result.Type == type))

    7170. 

  7170.                 {

    7171. 

  7171.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7172. 

  7172.                     return 1;

    7173. 

  7173.                 }

    7174. 

  7174. 

    7175. 

  7175.                 if (!(result.NewExpression == newExpression)) return 1;

    7176. 

  7176. 

    7177. 

  7177.                 if (!(result.ToString() == str))

    7178. 

  7178.                 {

    7179. 

  7179.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7180. 

  7180.                     return 1;

    7181. 

  7181.                 }

    7182. 

  7182. 

    7183. 

  7183.                 if (result.Initializers.Count != initializers.Length) return 1;

    7184. 

  7184. 

    7185. 

  7185.                 for (int i = 0; i < initializers.Length; i++)

    7186. 

  7186.                 {

    7187. 

  7187.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    7188. 

  7188. 

    7189. 

  7189.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    7190. 

  7190. 

    7191. 

  7191.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    7192. 

  7192.                     {

    7193. 

  7193.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    7194. 

  7194.                     }

    7195. 

  7195.                 }

    7196. 

  7196. 

    7197. 

  7197.                 return 0;

    7198. 

  7198.             }

    7199. 

  7199. 

    7200. 

  7200.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    7201. 

  7201.             {

    7202. 

  7202.                 if (result.AddMethod != exp_mi) return 1;

    7203. 

  7203.                 if (!(result.ToString() == str))

    7204. 

  7204.                 {

    7205. 

  7205.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7206. 

  7206.                     return 1;

    7207. 

  7207.                 }

    7208. 

  7208. 

    7209. 

  7209.                 if (result.Arguments.Count != args.Length) return 1;

    7210. 

  7210. 

    7211. 

  7211.                 for (int i = 0; i < args.Length; i++)

    7212. 

  7212.                 {

    7213. 

  7213.                     if (result.Arguments[i] != args[i]) return 1;

    7214. 

  7214.                 }

    7215. 

  7215. 

    7216. 

  7216.                 return 0;

    7217. 

  7217.             }

    7218. 

  7218. 

    7219. 

  7219.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    7220. 

  7220.             {

    7221. 

  7221.                 if (!(result.BindingType == bt)) return 1;

    7222. 

  7222.                 if (!(result.Expression == expr)) return 1;

    7223. 

  7223.                 if (!(result.Member.Equals(member))) return 1;

    7224. 

  7224.                 if (!(result.ToString() == str))

    7225. 

  7225.                 {

    7226. 

  7226.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7227. 

  7227.                     return 1;

    7228. 

  7228.                 }

    7229. 

  7229. 

    7230. 

  7230.                 return 0;

    7231. 

  7231.             }

    7232. 

  7232. 

    7233. 

  7233.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    7234. 

  7234.             {

    7235. 

  7235.                 if (!(result.BindingType == bt)) return 1;

    7236. 

  7236. 

    7237. 

  7237.                 if (!(result.Member.Equals(member))) return 1;

    7238. 

  7238.                 if (!(result.ToString() == str))

    7239. 

  7239.                 {

    7240. 

  7240.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7241. 

  7241.                     return 1;

    7242. 

  7242.                 }

    7243. 

  7243. 

    7244. 

  7244.                 if (result.Initializers.Count != initializers.Length) return 1;

    7245. 

  7245. 

    7246. 

  7246.                 for (int i = 0; i < initializers.Length; i++)

    7247. 

  7247.                 {

    7248. 

  7248.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    7249. 

  7249. 

    7250. 

  7250.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    7251. 

  7251. 

    7252. 

  7252.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    7253. 

  7253.                     {

    7254. 

  7254.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    7255. 

  7255.                     }

    7256. 

  7256.                 }

    7257. 

  7257. 

    7258. 

  7258. 

    7259. 

  7259.                 return 0;

    7260. 

  7260.             }

    7261. 

  7261. 

    7262. 

  7262.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    7263. 

  7263.             {

    7264. 

  7264.                 if (!(result.BindingType == bt)) return 1;

    7265. 

  7265. 

    7266. 

  7266.                 if (!(result.Member.Equals(member))) return 1;

    7267. 

  7267.                 if (!(result.ToString() == str))

    7268. 

  7268.                 {

    7269. 

  7269.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7270. 

  7270.                     return 1;

    7271. 

  7271.                 }

    7272. 

  7272. 

    7273. 

  7273.                 if (result.Bindings.Count != bindings.Length) return 1;

    7274. 

  7274. 

    7275. 

  7275.                 for (int i = 0; i < bindings.Length; i++)

    7276. 

  7276.                 {

    7277. 

  7277.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    7278. 

  7278.                 }

    7279. 

  7279. 

    7280. 

  7280.                 return 0;

    7281. 

  7281.             }

    7282. 

  7282. 

    7283. 

  7283.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    7284. 

  7284.             {

    7285. 

  7285.                 if (!(result.NodeType == et))

    7286. 

  7286.                 {

    7287. 

  7287.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7288. 

  7288.                     return 1;

    7289. 

  7289.                 }

    7290. 

  7290.                 if (!(result.Type == type))

    7291. 

  7291.                 {

    7292. 

  7292.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7293. 

  7293.                     return 1;

    7294. 

  7294.                 }

    7295. 

  7295.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    7296. 

  7296.                 if (!(result.ToString() == str)) return 1;

    7297. 

  7297. 

    7298. 

  7298.                 if (result.Bindings.Count != bindings.Length) return 1;

    7299. 

  7299. 

    7300. 

  7300.                 for (int i = 0; i < bindings.Length; i++)

    7301. 

  7301.                 {

    7302. 

  7302.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    7303. 

  7303.                 }

    7304. 

  7304. 

    7305. 

  7305.                 return 0;

    7306. 

  7306.             }

    7307. 

  7307. 

    7308. 

  7308.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    7309. 

  7309.             {

    7310. 

  7310.                 if (!(result.NodeType == et))

    7311. 

  7311.                 {

    7312. 

  7312.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7313. 

  7313.                     return 1;

    7314. 

  7314.                 }

    7315. 

  7315.                 if (!(result.Type == type))

    7316. 

  7316.                 {

    7317. 

  7317.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7318. 

  7318.                     return 1;

    7319. 

  7319.                 }

    7320. 

  7320. 

    7321. 

  7321.                 if (result.Expressions.Count != expr.Length) return 1;

    7322. 

  7322. 

    7323. 

  7323.                 for (int i = 0; i < expr.Length; i++)

    7324. 

  7324.                 {

    7325. 

  7325.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    7326. 

  7326.                 }

    7327. 

  7327.                 if (!(result.ToString() == str))

    7328. 

  7328.                 {

    7329. 

  7329.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7330. 

  7330.                     return 1;

    7331. 

  7331.                 }

    7332. 

  7332. 

    7333. 

  7333.                 return 0;

    7334. 

  7334.             }

    7335. 

  7335. 

    7336. 

  7336.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    7337. 

  7337.             {

    7338. 

  7338.                 if (!(result.NodeType == et))

    7339. 

  7339.                 {

    7340. 

  7340.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7341. 

  7341.                     return 1;

    7342. 

  7342.                 }

    7343. 

  7343.                 if (!(result.Type == type))

    7344. 

  7344.                 {

    7345. 

  7345.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7346. 

  7346.                     return 1;

    7347. 

  7347.                 }

    7348. 

  7348.                 if (!(result.Name == name)) return 1;

    7349. 

  7349. 

    7350. 

  7350.                 if (!(result.ToString() == str))

    7351. 

  7351.                 {

    7352. 

  7352.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7353. 

  7353.                     return 1;

    7354. 

  7354.                 }

    7355. 

  7355. 

    7356. 

  7356.                 return 0;

    7357. 

  7357.             }

    7358. 

  7358. 

    7359. 

  7359.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    7360. 

  7360.             {

    7361. 

  7361.                 if (!(result.NodeType == et))

    7362. 

  7362.                 {

    7363. 

  7363.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7364. 

  7364.                     return 1;

    7365. 

  7365.                 }

    7366. 

  7366.                 if (!(result.Type == type))

    7367. 

  7367.                 {

    7368. 

  7368.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7369. 

  7369.                     return 1;

    7370. 

  7370.                 }

    7371. 

  7371. 

    7372. 

  7372.                 if (expr == null)

    7373. 

  7373.                 {

    7374. 

  7374.                     if (result.Body != null) return 1;

    7375. 

  7375.                 }

    7376. 

  7376.                 else

    7377. 

  7377.                 {

    7378. 

  7378.                     if (!(result.Body.Equals(expr))) return 1;

    7379. 

  7379.                 }

    7380. 

  7380. 

    7381. 

  7381.                 if (result.Parameters.Count != parms.Length) return 1;

    7382. 

  7382. 

    7383. 

  7383.                 for (int i = 0; i < parms.Length; i++)

    7384. 

  7384.                 {

    7385. 

  7385.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    7386. 

  7386.                 }

    7387. 

  7387. 

    7388. 

  7388.                 if (!(result.ToString() == str))

    7389. 

  7389.                 {

    7390. 

  7390.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7391. 

  7391.                     return 1;

    7392. 

  7392.                 }

    7393. 

  7393. 

    7394. 

  7394.                 return 0;

    7395. 

  7395.             }

    7396. 

  7396. 

    7397. 

  7397.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    7398. 

  7398.             {

    7399. 

  7399.                 if (!(result.NodeType == et))

    7400. 

  7400.                 {

    7401. 

  7401.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7402. 

  7402.                     return 1;

    7403. 

  7403.                 }

    7404. 

  7404.                 if (!(result.Type == type))

    7405. 

  7405.                 {

    7406. 

  7406.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7407. 

  7407.                     return 1;

    7408. 

  7408.                 }

    7409. 

  7409. 

    7410. 

  7410.                 if (expr == null)

    7411. 

  7411.                 {

    7412. 

  7412.                     if (result.Expression != null) return 1;

    7413. 

  7413.                 }

    7414. 

  7414.                 else

    7415. 

  7415.                 {

    7416. 

  7416.                     if (!(result.Expression.Equals(expr))) return 1;

    7417. 

  7417.                 }

    7418. 

  7418. 

    7419. 

  7419.                 if (result.Arguments.Count != args.Length) return 1;

    7420. 

  7420. 

    7421. 

  7421.                 for (int i = 0; i < args.Length; i++)

    7422. 

  7422.                 {

    7423. 

  7423.                     if (!(result.Arguments[i].Equals(args[i])))

    7424. 

  7424.                     {

    7425. 

  7425.                         return 1;

    7426. 

  7426.                     }

    7427. 

  7427.                 }

    7428. 

  7428. 

    7429. 

  7429.                 if (result.ToString() != str)

    7430. 

  7430.                 {

    7431. 

  7431.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    7432. 

  7432.                     return 1;

    7433. 

  7433.                 }

    7434. 

  7434. 

    7435. 

  7435.                 return 0;

    7436. 

  7436.             }

    7437. 

  7437.         }

    7438. 

  7438. 

    7439. 

  7439. 

    7440. 

  7440. 

    7441. 

  7441.         namespace Not

    7442. 

  7442.         {

    7443. 

  7443.             // Declaring user-defined types for testing

    7444. 

  7444.             struct TC1

    7445. 

  7445.             {

    7446. 

  7446.                 public static TC1 operator !(TC1 c)

    7447. 

  7447.                 {

    7448. 

  7448.                     return new TC1();

    7449. 

  7449.                 }

    7450. 

  7450. 

    7451. 

  7451.                 public static TC1 operator ~(TC1 c)

    7452. 

  7452.                 {

    7453. 

  7453.                     return new TC1();

    7454. 

  7454.                 }

    7455. 

  7455.             }

    7456. 

  7456. 

    7457. 

  7457.             struct TC2

    7458. 

  7458.             {

    7459. 

  7459.                 public static TC2 operator ~(TC2 c)

    7460. 

  7460.                 {

    7461. 

  7461.                     return new TC2();

    7462. 

  7462.                 }

    7463. 

  7463.             }

    7464. 

  7464. 

    7465. 

  7465.             struct TC3

    7466. 

  7466.             {

    7467. 

  7467.                 public static TC3 Meth1(TC3 c)

    7468. 

  7468.                 {

    7469. 

  7469.                     return new TC3();

    7470. 

  7470.                 }

    7471. 

  7471.             }

    7472. 

  7472.         }

    7473. 

  7473. 

    7474. 

  7474.     }

    7475. 

  7475. 

    7476. 

  7476.     //-------- Scenario 791

    7477. 

  7477.     namespace Scenario791

    7478. 

  7478.     {

    7479. 

  7479. 

    7480. 

  7480.         namespace Not

    7481. 

  7481.         {

    7482. 

  7482.             public class Test

    7483. 

  7483.             {

    7484. 

  7484.                 // Overload-1: Test for functionality: Argument is of type nullable user-defined type (Logical Not)

    7485. 

  7485.                 public static int Test10()

    7486. 

  7486.                 {

    7487. 

  7487.                     TC2? ctest = new TC2?();

    7488. 

  7488.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC2?));

    7489. 

  7489.                     Type exp_type = typeof(TC2?);

    7490. 

  7490.                     ExpressionType exp_et = ExpressionType.Not;

    7491. 

  7491.                     string exp_str = "Not(" + ce.ToString() + ")";

    7492. 

  7492.                     Expression exp_operand = ce;

    7493. 

  7493.                     MethodInfo exp_mi = typeof(TC2).GetMethod("op_OnesComplement");

    7494. 

  7494. 

    7495. 

  7495.                     UnaryExpression result = Expression.Not(ce);

    7496. 

  7496. 

    7497. 

  7497.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, true, true);

    7498. 

  7498.                 }

    7499. 

  7499. 

    7500. 

  7500. 

    7501. 

  7501.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not10__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    7502. 

  7502.                 public static Expression Not10__()

    7503. 

  7503.                 {

    7504. 

  7504.                     if (Main() != 0)

    7505. 

  7505.                     {

    7506. 

  7506.                         throw new Exception();

    7507. 

  7507.                     }

    7508. 

  7508.                     else

    7509. 

  7509.                     {

    7510. 

  7510.                         return Expression.Constant(0);

    7511. 

  7511.                     }

    7512. 

  7512.                 }

    7513. 

  7513.                 public static int Main()

    7514. 

  7514.                 {

    7515. 

  7515.                     return Test10();

    7516. 

  7516.                 }

    7517. 

  7517.             }

    7518. 

  7518.         }

    7519. 

  7519. 

    7520. 

  7520. 

    7521. 

  7521.         public static class Extension

    7522. 

  7522.         {

    7523. 

  7523.             public static bool CompareParamName(this ArgumentException ex, string expected)

    7524. 

  7524.             {

    7525. 

  7525. #if SILVERLIGHT

    7526. 

  7526. #if SLRESOURCES

    7527. 

  7527. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    7528. 

  7528. #else

    7529. 

  7529. 				        return true;

    7530. 

  7530. #endif

    7531. 

  7531. #else

    7532. 

  7532.                 return ex.ParamName == expected;

    7533. 

  7533. #endif

    7534. 

  7534.             }

    7535. 

  7535. 

    7536. 

  7536.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    7537. 

  7537.             {

    7538. 

  7538. #if SILVERLIGHT

    7539. 

  7539. #if SLRESOURCES

    7540. 

  7540. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    7541. 

  7541. #else

    7542. 

  7542. 				        return true;

    7543. 

  7543. #endif

    7544. 

  7544. #else

    7545. 

  7545.                 return ex.ParamName == expected;

    7546. 

  7546. #endif

    7547. 

  7547.             }

    7548. 

  7548.         }

    7549. 

  7549. 

    7550. 

  7550.         public static class Verification

    7551. 

  7551.         {

    7552. 

  7552.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    7553. 

  7553.             {

    7554. 

  7554.                 if (!(result.NodeType == et))

    7555. 

  7555.                 {

    7556. 

  7556.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7557. 

  7557.                     return 1;

    7558. 

  7558.                 }

    7559. 

  7559.                 if (!(result.Type == type))

    7560. 

  7560.                 {

    7561. 

  7561.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7562. 

  7562.                     return 1;

    7563. 

  7563.                 }

    7564. 

  7564.                 if (val == null)

    7565. 

  7565.                 {

    7566. 

  7566.                     if (result.Value != null) return 1;

    7567. 

  7567.                 }

    7568. 

  7568.                 else

    7569. 

  7569.                 {

    7570. 

  7570.                     if (!(result.Value.Equals(val))) return 1;

    7571. 

  7571.                 }

    7572. 

  7572.                 if (!(result.ToString() == str)) return 1;

    7573. 

  7573.                 return 0;

    7574. 

  7574.             }

    7575. 

  7575. 

    7576. 

  7576.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    7577. 

  7577.             {

    7578. 

  7578.                 if (!(result.NodeType == et))

    7579. 

  7579.                 {

    7580. 

  7580.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7581. 

  7581.                     return 1;

    7582. 

  7582.                 }

    7583. 

  7583.                 if (!(result.Type == type))

    7584. 

  7584.                 {

    7585. 

  7585.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7586. 

  7586.                     return 1;

    7587. 

  7587.                 }

    7588. 

  7588.                 if (operand == null)

    7589. 

  7589.                 {

    7590. 

  7590.                     if (result.Operand != null) return 1;

    7591. 

  7591.                 }

    7592. 

  7592.                 else

    7593. 

  7593.                 {

    7594. 

  7594.                     if (!(result.Operand.Equals(operand))) return 1;

    7595. 

  7595.                 }

    7596. 

  7596.                 if (!(result.ToString() == str))

    7597. 

  7597.                 {

    7598. 

  7598.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    7599. 

  7599.                     return 1;

    7600. 

  7600.                 }

    7601. 

  7601. 

    7602. 

  7602.                 if (result.Method != mi) return 1;

    7603. 

  7603.                 if (result.IsLifted != islifted) return 1;

    7604. 

  7604.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    7605. 

  7605. 

    7606. 

  7606.                 return 0;

    7607. 

  7607.             }

    7608. 

  7608. 

    7609. 

  7609.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    7610. 

  7610.             {

    7611. 

  7611.                 if (!(result.NodeType == et))

    7612. 

  7612.                 {

    7613. 

  7613.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7614. 

  7614.                     return 1;

    7615. 

  7615.                 }

    7616. 

  7616.                 if (!(result.Type == type))

    7617. 

  7617.                 {

    7618. 

  7618.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7619. 

  7619.                     return 1;

    7620. 

  7620.                 }

    7621. 

  7621. 

    7622. 

  7622.                 if (left == null)

    7623. 

  7623.                 {

    7624. 

  7624.                     if (result.Left != null)

    7625. 

  7625.                     {

    7626. 

  7626.                         Console.WriteLine("left was null");

    7627. 

  7627.                         return 1;

    7628. 

  7628.                     }

    7629. 

  7629.                 }

    7630. 

  7630.                 else

    7631. 

  7631.                 {

    7632. 

  7632.                     if (!(result.Left.Equals(left)))

    7633. 

  7633.                     {

    7634. 

  7634.                         Console.WriteLine("left was different");

    7635. 

  7635.                         return 1;

    7636. 

  7636.                     }

    7637. 

  7637.                 }

    7638. 

  7638. 

    7639. 

  7639.                 if (right == null)

    7640. 

  7640.                 {

    7641. 

  7641.                     if (result.Right != null) return 1;

    7642. 

  7642.                 }

    7643. 

  7643.                 else

    7644. 

  7644.                 {

    7645. 

  7645.                     if (!(result.Right.Equals(right))) return 1;

    7646. 

  7646.                 }

    7647. 

  7647. 

    7648. 

  7648.                 if (!(result.ToString() == str))

    7649. 

  7649.                 {

    7650. 

  7650.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    7651. 

  7651.                     return 1;

    7652. 

  7652.                 }

    7653. 

  7653. 

    7654. 

  7654.                 if (result.Method != mi) return 1;

    7655. 

  7655.                 if (result.IsLifted != islifted) return 1;

    7656. 

  7656.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    7657. 

  7657. 

    7658. 

  7658.                 if (result.Conversion != null) return 1;

    7659. 

  7659. 

    7660. 

  7660.                 return 0;

    7661. 

  7661.             }

    7662. 

  7662. 

    7663. 

  7663.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    7664. 

  7664.             {

    7665. 

  7665.                 if (!(result.NodeType == et))

    7666. 

  7666.                 {

    7667. 

  7667.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7668. 

  7668.                     return 1;

    7669. 

  7669.                 }

    7670. 

  7670.                 if (!(result.Type == type))

    7671. 

  7671.                 {

    7672. 

  7672.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7673. 

  7673.                     return 1;

    7674. 

  7674.                 }

    7675. 

  7675. 

    7676. 

  7676.                 if (left == null)

    7677. 

  7677.                 {

    7678. 

  7678.                     if (result.Left != null) return 1;

    7679. 

  7679.                 }

    7680. 

  7680.                 else

    7681. 

  7681.                 {

    7682. 

  7682.                     if (!(result.Left.Equals(left))) return 1;

    7683. 

  7683.                 }

    7684. 

  7684. 

    7685. 

  7685.                 if (right == null)

    7686. 

  7686.                 {

    7687. 

  7687.                     if (result.Right != null) return 1;

    7688. 

  7688.                 }

    7689. 

  7689.                 else

    7690. 

  7690.                 {

    7691. 

  7691.                     if (!(result.Right.Equals(right))) return 1;

    7692. 

  7692.                 }

    7693. 

  7693. 

    7694. 

  7694.                 if (!(result.ToString() == str)) return 1;

    7695. 

  7695. 

    7696. 

  7696.                 if (result.Method != mi) return 1;

    7697. 

  7697.                 if (result.IsLifted != islifted) return 1;

    7698. 

  7698.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    7699. 

  7699. 

    7700. 

  7700.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    7701. 

  7701. 

    7702. 

  7702.                 return 0;

    7703. 

  7703.             }

    7704. 

  7704. 

    7705. 

  7705.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    7706. 

  7706.             {

    7707. 

  7707.                 if (!(result.NodeType == et))

    7708. 

  7708.                 {

    7709. 

  7709.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7710. 

  7710.                     return 1;

    7711. 

  7711.                 }

    7712. 

  7712.                 if (!(result.Type == type))

    7713. 

  7713.                 {

    7714. 

  7714.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7715. 

  7715.                     return 1;

    7716. 

  7716.                 }

    7717. 

  7717. 

    7718. 

  7718.                 if (!(result.Method == method)) return 1;

    7719. 

  7719. 

    7720. 

  7720.                 if (obj == null)

    7721. 

  7721.                 {

    7722. 

  7722.                     if (result.Object != null)

    7723. 

  7723.                     {

    7724. 

  7724.                         Console.WriteLine("Expected object to be null.");

    7725. 

  7725.                         return 1;

    7726. 

  7726.                     }

    7727. 

  7727.                 }

    7728. 

  7728.                 else

    7729. 

  7729.                 {

    7730. 

  7730.                     if (!(result.Object.Equals(obj)))

    7731. 

  7731.                     {

    7732. 

  7732.                         Console.WriteLine("Object on which call is made is different from the result.");

    7733. 

  7733.                         return 1;

    7734. 

  7734.                     }

    7735. 

  7735.                 }

    7736. 

  7736. 

    7737. 

  7737.                 if (!(result.ToString() == str))

    7738. 

  7738.                 {

    7739. 

  7739.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    7740. 

  7740.                     return 1;

    7741. 

  7741.                 }

    7742. 

  7742. 

    7743. 

  7743.                 if (result.Arguments.Count != arguments.Length) return 1;

    7744. 

  7744. 

    7745. 

  7745.                 for (int i = 0; i < arguments.Length; i++)

    7746. 

  7746.                 {

    7747. 

  7747.                     if (result.Arguments[i] != arguments[i]) return 1;

    7748. 

  7748.                 }

    7749. 

  7749. 

    7750. 

  7750.                 return 0;

    7751. 

  7751.             }

    7752. 

  7752. 

    7753. 

  7753.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    7754. 

  7754.             {

    7755. 

  7755.                 if (!(result.NodeType == et))

    7756. 

  7756.                 {

    7757. 

  7757.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7758. 

  7758.                     return 1;

    7759. 

  7759.                 }

    7760. 

  7760.                 if (!(result.Type == type))

    7761. 

  7761.                 {

    7762. 

  7762.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7763. 

  7763.                     return 1;

    7764. 

  7764.                 }

    7765. 

  7765. 

    7766. 

  7766.                 if (expr == null)

    7767. 

  7767.                 {

    7768. 

  7768.                     Console.WriteLine("expr was null.");

    7769. 

  7769.                     if (result.Expression != null) return 1;

    7770. 

  7770.                 }

    7771. 

  7771.                 else

    7772. 

  7772.                 {

    7773. 

  7773.                     if (!(result.Expression.Equals(expr)))

    7774. 

  7774.                     {

    7775. 

  7775.                         return 1;

    7776. 

  7776.                     }

    7777. 

  7777.                 }

    7778. 

  7778. 

    7779. 

  7779.                 if (!(result.TypeOperand == typeop)) return 1;

    7780. 

  7780. 

    7781. 

  7781.                 if (!(result.ToString() == str))

    7782. 

  7782.                 {

    7783. 

  7783.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    7784. 

  7784.                     return 1;

    7785. 

  7785.                 }

    7786. 

  7786. 

    7787. 

  7787.                 return 0;

    7788. 

  7788.             }

    7789. 

  7789. 

    7790. 

  7790.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    7791. 

  7791.             {

    7792. 

  7792.                 if (!(result.NodeType == et))

    7793. 

  7793.                 {

    7794. 

  7794.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7795. 

  7795.                     return 1;

    7796. 

  7796.                 }

    7797. 

  7797.                 if (!(result.Type == type))

    7798. 

  7798.                 {

    7799. 

  7799.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7800. 

  7800.                     return 1;

    7801. 

  7801.                 }

    7802. 

  7802. 

    7803. 

  7803.                 if (test == null)

    7804. 

  7804.                 {

    7805. 

  7805.                     if (result.Test != null) return 1;

    7806. 

  7806.                 }

    7807. 

  7807.                 else

    7808. 

  7808.                 {

    7809. 

  7809.                     if (!(result.Test.Equals(test))) return 1;

    7810. 

  7810.                 }

    7811. 

  7811. 

    7812. 

  7812.                 if (ifTrue == null)

    7813. 

  7813.                 {

    7814. 

  7814.                     if (result.IfTrue != null) return 1;

    7815. 

  7815.                 }

    7816. 

  7816.                 else

    7817. 

  7817.                 {

    7818. 

  7818.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    7819. 

  7819.                 }

    7820. 

  7820. 

    7821. 

  7821.                 if (ifFalse == null)

    7822. 

  7822.                 {

    7823. 

  7823.                     if (result.IfFalse != null) return 1;

    7824. 

  7824.                 }

    7825. 

  7825.                 else

    7826. 

  7826.                 {

    7827. 

  7827.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    7828. 

  7828.                 }

    7829. 

  7829. 

    7830. 

  7830.                 if (!(result.ToString() == str)) return 1;

    7831. 

  7831. 

    7832. 

  7832.                 return 0;

    7833. 

  7833.             }

    7834. 

  7834. 

    7835. 

  7835.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    7836. 

  7836.             {

    7837. 

  7837.                 if (!(result.NodeType == et))

    7838. 

  7838.                 {

    7839. 

  7839.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7840. 

  7840.                     return 1;

    7841. 

  7841.                 }

    7842. 

  7842.                 if (!(result.Type == type))

    7843. 

  7843.                 {

    7844. 

  7844.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7845. 

  7845.                     return 1;

    7846. 

  7846.                 }

    7847. 

  7847. 

    7848. 

  7848.                 if (exp_expr == null)

    7849. 

  7849.                 {

    7850. 

  7850.                     if (result.Expression != null)

    7851. 

  7851.                     {

    7852. 

  7852.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    7853. 

  7853.                         return 1;

    7854. 

  7854.                     }

    7855. 

  7855.                 }

    7856. 

  7856.                 else

    7857. 

  7857.                 {

    7858. 

  7858.                     if (!(result.Expression.Equals(exp_expr)))

    7859. 

  7859.                     {

    7860. 

  7860.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    7861. 

  7861.                         return 1;

    7862. 

  7862.                     }

    7863. 

  7863.                 }

    7864. 

  7864. 

    7865. 

  7865.                 if (!(result.Member == exp_member))

    7866. 

  7866.                 {

    7867. 

  7867.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    7868. 

  7868.                     return 1;

    7869. 

  7869.                 }

    7870. 

  7870. 

    7871. 

  7871.                 if (!(result.ToString() == str))

    7872. 

  7872.                 {

    7873. 

  7873.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7874. 

  7874.                     return 1;

    7875. 

  7875.                 }

    7876. 

  7876. 

    7877. 

  7877.                 return 0;

    7878. 

  7878.             }

    7879. 

  7879. 

    7880. 

  7880.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    7881. 

  7881.             {

    7882. 

  7882.                 if (!(result.NodeType == et))

    7883. 

  7883.                 {

    7884. 

  7884.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7885. 

  7885.                     return 1;

    7886. 

  7886.                 }

    7887. 

  7887.                 if (!(result.Type == type))

    7888. 

  7888.                 {

    7889. 

  7889.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7890. 

  7890.                     return 1;

    7891. 

  7891.                 }

    7892. 

  7892. 

    7893. 

  7893.                 if (!(result.Constructor == constructor))

    7894. 

  7894.                 {

    7895. 

  7895.                     Console.WriteLine("Unexpected constructor");

    7896. 

  7896.                     return 1;

    7897. 

  7897.                 }

    7898. 

  7898. 

    7899. 

  7899.                 if (!(result.ToString() == str))

    7900. 

  7900.                 {

    7901. 

  7901.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7902. 

  7902.                     return 1;

    7903. 

  7903.                 }

    7904. 

  7904. 

    7905. 

  7905.                 if (arguments == null)

    7906. 

  7906.                 {

    7907. 

  7907.                     if (result.Arguments.Count != 0)

    7908. 

  7908.                     {

    7909. 

  7909.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    7910. 

  7910.                         return 1;

    7911. 

  7911.                     }

    7912. 

  7912.                 }

    7913. 

  7913.                 else

    7914. 

  7914.                 {

    7915. 

  7915.                     if (result.Arguments.Count != arguments.Length)

    7916. 

  7916.                     {

    7917. 

  7917.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    7918. 

  7918.                         return 1;

    7919. 

  7919.                     }

    7920. 

  7920.                     for (int i = 0; i < arguments.Length; i++)

    7921. 

  7921.                     {

    7922. 

  7922.                         if (result.Arguments[i] != arguments[i])

    7923. 

  7923.                         {

    7924. 

  7924.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    7925. 

  7925.                             return 1;

    7926. 

  7926.                         }

    7927. 

  7927.                     }

    7928. 

  7928.                 }

    7929. 

  7929. 

    7930. 

  7930.                 if (result.Members == null)

    7931. 

  7931.                 {

    7932. 

  7932.                     Console.WriteLine("result.Members was null");

    7933. 

  7933.                     return 1;

    7934. 

  7934.                 }

    7935. 

  7935. 

    7936. 

  7936.                 if (members == null)

    7937. 

  7937.                 {

    7938. 

  7938.                     if (result.Members.Count != 0)

    7939. 

  7939.                     {

    7940. 

  7940.                         Console.WriteLine("Got more than zero members");

    7941. 

  7941.                         return 1;

    7942. 

  7942.                     }

    7943. 

  7943.                 }

    7944. 

  7944.                 else

    7945. 

  7945.                 {

    7946. 

  7946.                     if (result.Members.Count != members.Length)

    7947. 

  7947.                     {

    7948. 

  7948.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    7949. 

  7949.                         return 1;

    7950. 

  7950.                     }

    7951. 

  7951. 

    7952. 

  7952.                     for (int i = 0; i < members.Length; i++)

    7953. 

  7953.                     {

    7954. 

  7954.                         if (result.Members[i] != members[i])

    7955. 

  7955.                         {

    7956. 

  7956.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    7957. 

  7957.                             return 1;

    7958. 

  7958.                         }

    7959. 

  7959.                     }

    7960. 

  7960.                 }

    7961. 

  7961. 

    7962. 

  7962.                 return 0;

    7963. 

  7963.             }

    7964. 

  7964. 

    7965. 

  7965.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    7966. 

  7966.             {

    7967. 

  7967.                 if (!(result.NodeType == et))

    7968. 

  7968.                 {

    7969. 

  7969.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    7970. 

  7970.                     return 1;

    7971. 

  7971.                 }

    7972. 

  7972.                 if (!(result.Type == type))

    7973. 

  7973.                 {

    7974. 

  7974.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    7975. 

  7975.                     return 1;

    7976. 

  7976.                 }

    7977. 

  7977. 

    7978. 

  7978.                 if (!(result.Constructor == constructor))

    7979. 

  7979.                 {

    7980. 

  7980.                     Console.WriteLine("Constructor is different from expected.");

    7981. 

  7981.                     return 1;

    7982. 

  7982.                 }

    7983. 

  7983. 

    7984. 

  7984.                 if (!(result.ToString() == str))

    7985. 

  7985.                 {

    7986. 

  7986.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    7987. 

  7987.                     return 1;

    7988. 

  7988.                 }

    7989. 

  7989. 

    7990. 

  7990.                 if (result.Arguments.Count != arguments.Length)

    7991. 

  7991.                 {

    7992. 

  7992.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    7993. 

  7993.                     return 1;

    7994. 

  7994.                 }

    7995. 

  7995. 

    7996. 

  7996.                 for (int i = 0; i < arguments.Length; i++)

    7997. 

  7997.                 {

    7998. 

  7998.                     if (result.Arguments[i] != arguments[i])

    7999. 

  7999.                     {

    8000. 

  8000.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    8001. 

  8001.                         return 1;

    8002. 

  8002.                     }

    8003. 

  8003.                 }

    8004. 

  8004. 

    8005. 

  8005.                 if (result.Members != null)

    8006. 

  8006.                 {

    8007. 

  8007.                     Console.WriteLine("result.Members isn't null");

    8008. 

  8008.                     return 1;

    8009. 

  8009.                 }

    8010. 

  8010. 

    8011. 

  8011.                 return 0;

    8012. 

  8012.             }

    8013. 

  8013. 

    8014. 

  8014.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    8015. 

  8015.             {

    8016. 

  8016.                 if (!(result.NodeType == et))

    8017. 

  8017.                 {

    8018. 

  8018.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8019. 

  8019.                     return 1;

    8020. 

  8020.                 }

    8021. 

  8021.                 if (!(result.Type == type))

    8022. 

  8022.                 {

    8023. 

  8023.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8024. 

  8024.                     return 1;

    8025. 

  8025.                 }

    8026. 

  8026. 

    8027. 

  8027.                 if (!(result.NewExpression == newExpression)) return 1;

    8028. 

  8028. 

    8029. 

  8029.                 if (!(result.ToString() == str))

    8030. 

  8030.                 {

    8031. 

  8031.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8032. 

  8032.                     return 1;

    8033. 

  8033.                 }

    8034. 

  8034. 

    8035. 

  8035.                 if (result.Initializers.Count != initializers.Length) return 1;

    8036. 

  8036. 

    8037. 

  8037.                 for (int i = 0; i < initializers.Length; i++)

    8038. 

  8038.                 {

    8039. 

  8039.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    8040. 

  8040. 

    8041. 

  8041.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    8042. 

  8042. 

    8043. 

  8043.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    8044. 

  8044.                     {

    8045. 

  8045.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    8046. 

  8046.                     }

    8047. 

  8047.                 }

    8048. 

  8048. 

    8049. 

  8049.                 return 0;

    8050. 

  8050.             }

    8051. 

  8051. 

    8052. 

  8052.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    8053. 

  8053.             {

    8054. 

  8054.                 if (result.AddMethod != exp_mi) return 1;

    8055. 

  8055.                 if (!(result.ToString() == str))

    8056. 

  8056.                 {

    8057. 

  8057.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8058. 

  8058.                     return 1;

    8059. 

  8059.                 }

    8060. 

  8060. 

    8061. 

  8061.                 if (result.Arguments.Count != args.Length) return 1;

    8062. 

  8062. 

    8063. 

  8063.                 for (int i = 0; i < args.Length; i++)

    8064. 

  8064.                 {

    8065. 

  8065.                     if (result.Arguments[i] != args[i]) return 1;

    8066. 

  8066.                 }

    8067. 

  8067. 

    8068. 

  8068.                 return 0;

    8069. 

  8069.             }

    8070. 

  8070. 

    8071. 

  8071.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    8072. 

  8072.             {

    8073. 

  8073.                 if (!(result.BindingType == bt)) return 1;

    8074. 

  8074.                 if (!(result.Expression == expr)) return 1;

    8075. 

  8075.                 if (!(result.Member.Equals(member))) return 1;

    8076. 

  8076.                 if (!(result.ToString() == str))

    8077. 

  8077.                 {

    8078. 

  8078.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8079. 

  8079.                     return 1;

    8080. 

  8080.                 }

    8081. 

  8081. 

    8082. 

  8082.                 return 0;

    8083. 

  8083.             }

    8084. 

  8084. 

    8085. 

  8085.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    8086. 

  8086.             {

    8087. 

  8087.                 if (!(result.BindingType == bt)) return 1;

    8088. 

  8088. 

    8089. 

  8089.                 if (!(result.Member.Equals(member))) return 1;

    8090. 

  8090.                 if (!(result.ToString() == str))

    8091. 

  8091.                 {

    8092. 

  8092.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8093. 

  8093.                     return 1;

    8094. 

  8094.                 }

    8095. 

  8095. 

    8096. 

  8096.                 if (result.Initializers.Count != initializers.Length) return 1;

    8097. 

  8097. 

    8098. 

  8098.                 for (int i = 0; i < initializers.Length; i++)

    8099. 

  8099.                 {

    8100. 

  8100.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    8101. 

  8101. 

    8102. 

  8102.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    8103. 

  8103. 

    8104. 

  8104.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    8105. 

  8105.                     {

    8106. 

  8106.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    8107. 

  8107.                     }

    8108. 

  8108.                 }

    8109. 

  8109. 

    8110. 

  8110. 

    8111. 

  8111.                 return 0;

    8112. 

  8112.             }

    8113. 

  8113. 

    8114. 

  8114.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    8115. 

  8115.             {

    8116. 

  8116.                 if (!(result.BindingType == bt)) return 1;

    8117. 

  8117. 

    8118. 

  8118.                 if (!(result.Member.Equals(member))) return 1;

    8119. 

  8119.                 if (!(result.ToString() == str))

    8120. 

  8120.                 {

    8121. 

  8121.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8122. 

  8122.                     return 1;

    8123. 

  8123.                 }

    8124. 

  8124. 

    8125. 

  8125.                 if (result.Bindings.Count != bindings.Length) return 1;

    8126. 

  8126. 

    8127. 

  8127.                 for (int i = 0; i < bindings.Length; i++)

    8128. 

  8128.                 {

    8129. 

  8129.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    8130. 

  8130.                 }

    8131. 

  8131. 

    8132. 

  8132.                 return 0;

    8133. 

  8133.             }

    8134. 

  8134. 

    8135. 

  8135.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    8136. 

  8136.             {

    8137. 

  8137.                 if (!(result.NodeType == et))

    8138. 

  8138.                 {

    8139. 

  8139.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8140. 

  8140.                     return 1;

    8141. 

  8141.                 }

    8142. 

  8142.                 if (!(result.Type == type))

    8143. 

  8143.                 {

    8144. 

  8144.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8145. 

  8145.                     return 1;

    8146. 

  8146.                 }

    8147. 

  8147.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    8148. 

  8148.                 if (!(result.ToString() == str)) return 1;

    8149. 

  8149. 

    8150. 

  8150.                 if (result.Bindings.Count != bindings.Length) return 1;

    8151. 

  8151. 

    8152. 

  8152.                 for (int i = 0; i < bindings.Length; i++)

    8153. 

  8153.                 {

    8154. 

  8154.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    8155. 

  8155.                 }

    8156. 

  8156. 

    8157. 

  8157.                 return 0;

    8158. 

  8158.             }

    8159. 

  8159. 

    8160. 

  8160.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    8161. 

  8161.             {

    8162. 

  8162.                 if (!(result.NodeType == et))

    8163. 

  8163.                 {

    8164. 

  8164.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8165. 

  8165.                     return 1;

    8166. 

  8166.                 }

    8167. 

  8167.                 if (!(result.Type == type))

    8168. 

  8168.                 {

    8169. 

  8169.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8170. 

  8170.                     return 1;

    8171. 

  8171.                 }

    8172. 

  8172. 

    8173. 

  8173.                 if (result.Expressions.Count != expr.Length) return 1;

    8174. 

  8174. 

    8175. 

  8175.                 for (int i = 0; i < expr.Length; i++)

    8176. 

  8176.                 {

    8177. 

  8177.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    8178. 

  8178.                 }

    8179. 

  8179.                 if (!(result.ToString() == str))

    8180. 

  8180.                 {

    8181. 

  8181.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8182. 

  8182.                     return 1;

    8183. 

  8183.                 }

    8184. 

  8184. 

    8185. 

  8185.                 return 0;

    8186. 

  8186.             }

    8187. 

  8187. 

    8188. 

  8188.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    8189. 

  8189.             {

    8190. 

  8190.                 if (!(result.NodeType == et))

    8191. 

  8191.                 {

    8192. 

  8192.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8193. 

  8193.                     return 1;

    8194. 

  8194.                 }

    8195. 

  8195.                 if (!(result.Type == type))

    8196. 

  8196.                 {

    8197. 

  8197.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8198. 

  8198.                     return 1;

    8199. 

  8199.                 }

    8200. 

  8200.                 if (!(result.Name == name)) return 1;

    8201. 

  8201. 

    8202. 

  8202.                 if (!(result.ToString() == str))

    8203. 

  8203.                 {

    8204. 

  8204.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8205. 

  8205.                     return 1;

    8206. 

  8206.                 }

    8207. 

  8207. 

    8208. 

  8208.                 return 0;

    8209. 

  8209.             }

    8210. 

  8210. 

    8211. 

  8211.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    8212. 

  8212.             {

    8213. 

  8213.                 if (!(result.NodeType == et))

    8214. 

  8214.                 {

    8215. 

  8215.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8216. 

  8216.                     return 1;

    8217. 

  8217.                 }

    8218. 

  8218.                 if (!(result.Type == type))

    8219. 

  8219.                 {

    8220. 

  8220.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8221. 

  8221.                     return 1;

    8222. 

  8222.                 }

    8223. 

  8223. 

    8224. 

  8224.                 if (expr == null)

    8225. 

  8225.                 {

    8226. 

  8226.                     if (result.Body != null) return 1;

    8227. 

  8227.                 }

    8228. 

  8228.                 else

    8229. 

  8229.                 {

    8230. 

  8230.                     if (!(result.Body.Equals(expr))) return 1;

    8231. 

  8231.                 }

    8232. 

  8232. 

    8233. 

  8233.                 if (result.Parameters.Count != parms.Length) return 1;

    8234. 

  8234. 

    8235. 

  8235.                 for (int i = 0; i < parms.Length; i++)

    8236. 

  8236.                 {

    8237. 

  8237.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    8238. 

  8238.                 }

    8239. 

  8239. 

    8240. 

  8240.                 if (!(result.ToString() == str))

    8241. 

  8241.                 {

    8242. 

  8242.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8243. 

  8243.                     return 1;

    8244. 

  8244.                 }

    8245. 

  8245. 

    8246. 

  8246.                 return 0;

    8247. 

  8247.             }

    8248. 

  8248. 

    8249. 

  8249.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    8250. 

  8250.             {

    8251. 

  8251.                 if (!(result.NodeType == et))

    8252. 

  8252.                 {

    8253. 

  8253.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8254. 

  8254.                     return 1;

    8255. 

  8255.                 }

    8256. 

  8256.                 if (!(result.Type == type))

    8257. 

  8257.                 {

    8258. 

  8258.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8259. 

  8259.                     return 1;

    8260. 

  8260.                 }

    8261. 

  8261. 

    8262. 

  8262.                 if (expr == null)

    8263. 

  8263.                 {

    8264. 

  8264.                     if (result.Expression != null) return 1;

    8265. 

  8265.                 }

    8266. 

  8266.                 else

    8267. 

  8267.                 {

    8268. 

  8268.                     if (!(result.Expression.Equals(expr))) return 1;

    8269. 

  8269.                 }

    8270. 

  8270. 

    8271. 

  8271.                 if (result.Arguments.Count != args.Length) return 1;

    8272. 

  8272. 

    8273. 

  8273.                 for (int i = 0; i < args.Length; i++)

    8274. 

  8274.                 {

    8275. 

  8275.                     if (!(result.Arguments[i].Equals(args[i])))

    8276. 

  8276.                     {

    8277. 

  8277.                         return 1;

    8278. 

  8278.                     }

    8279. 

  8279.                 }

    8280. 

  8280. 

    8281. 

  8281.                 if (result.ToString() != str)

    8282. 

  8282.                 {

    8283. 

  8283.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    8284. 

  8284.                     return 1;

    8285. 

  8285.                 }

    8286. 

  8286. 

    8287. 

  8287.                 return 0;

    8288. 

  8288.             }

    8289. 

  8289.         }

    8290. 

  8290. 

    8291. 

  8291. 

    8292. 

  8292. 

    8293. 

  8293.         namespace Not

    8294. 

  8294.         {

    8295. 

  8295.             // Declaring user-defined types for testing

    8296. 

  8296.             struct TC1

    8297. 

  8297.             {

    8298. 

  8298.                 public static TC1 operator !(TC1 c)

    8299. 

  8299.                 {

    8300. 

  8300.                     return new TC1();

    8301. 

  8301.                 }

    8302. 

  8302. 

    8303. 

  8303.                 public static TC1 operator ~(TC1 c)

    8304. 

  8304.                 {

    8305. 

  8305.                     return new TC1();

    8306. 

  8306.                 }

    8307. 

  8307.             }

    8308. 

  8308. 

    8309. 

  8309.             struct TC2

    8310. 

  8310.             {

    8311. 

  8311.                 public static TC2 operator ~(TC2 c)

    8312. 

  8312.                 {

    8313. 

  8313.                     return new TC2();

    8314. 

  8314.                 }

    8315. 

  8315.             }

    8316. 

  8316. 

    8317. 

  8317.             struct TC3

    8318. 

  8318.             {

    8319. 

  8319.                 public static TC3 Meth1(TC3 c)

    8320. 

  8320.                 {

    8321. 

  8321.                     return new TC3();

    8322. 

  8322.                 }

    8323. 

  8323.             }

    8324. 

  8324.         }

    8325. 

  8325. 

    8326. 

  8326.     }

    8327. 

  8327. 

    8328. 

  8328.     //-------- Scenario 792

    8329. 

  8329.     namespace Scenario792

    8330. 

  8330.     {

    8331. 

  8331. 

    8332. 

  8332.         namespace Not

    8333. 

  8333.         {

    8334. 

  8334.             public class Test

    8335. 

  8335.             {

    8336. 

  8336.                 // Overload-1: User-defined type without operator overloading

    8337. 

  8337.                 public static int Test11()

    8338. 

  8338.                 {

    8339. 

  8339.                     TC3 ctest = new TC3();

    8340. 

  8340.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC3));

    8341. 

  8341. 

    8342. 

  8342.                     try

    8343. 

  8343.                     {

    8344. 

  8344.                         UnaryExpression result = Expression.Not(ce);

    8345. 

  8345.                         return 1;

    8346. 

  8346.                     }

    8347. 

  8347.                     catch (InvalidOperationException)

    8348. 

  8348.                     {

    8349. 

  8349.                         return 0;

    8350. 

  8350.                     }

    8351. 

  8351.                 }

    8352. 

  8352. 

    8353. 

  8353. 

    8354. 

  8354.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not11__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    8355. 

  8355.                 public static Expression Not11__()

    8356. 

  8356.                 {

    8357. 

  8357.                     if (Main() != 0)

    8358. 

  8358.                     {

    8359. 

  8359.                         throw new Exception();

    8360. 

  8360.                     }

    8361. 

  8361.                     else

    8362. 

  8362.                     {

    8363. 

  8363.                         return Expression.Constant(0);

    8364. 

  8364.                     }

    8365. 

  8365.                 }

    8366. 

  8366.                 public static int Main()

    8367. 

  8367.                 {

    8368. 

  8368.                     return Test11();

    8369. 

  8369.                 }

    8370. 

  8370.             }

    8371. 

  8371.         }

    8372. 

  8372. 

    8373. 

  8373. 

    8374. 

  8374.         public static class Extension

    8375. 

  8375.         {

    8376. 

  8376.             public static bool CompareParamName(this ArgumentException ex, string expected)

    8377. 

  8377.             {

    8378. 

  8378. #if SILVERLIGHT

    8379. 

  8379. #if SLRESOURCES

    8380. 

  8380. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    8381. 

  8381. #else

    8382. 

  8382. 				        return true;

    8383. 

  8383. #endif

    8384. 

  8384. #else

    8385. 

  8385.                 return ex.ParamName == expected;

    8386. 

  8386. #endif

    8387. 

  8387.             }

    8388. 

  8388. 

    8389. 

  8389.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    8390. 

  8390.             {

    8391. 

  8391. #if SILVERLIGHT

    8392. 

  8392. #if SLRESOURCES

    8393. 

  8393. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    8394. 

  8394. #else

    8395. 

  8395. 				        return true;

    8396. 

  8396. #endif

    8397. 

  8397. #else

    8398. 

  8398.                 return ex.ParamName == expected;

    8399. 

  8399. #endif

    8400. 

  8400.             }

    8401. 

  8401.         }

    8402. 

  8402. 

    8403. 

  8403.         public static class Verification

    8404. 

  8404.         {

    8405. 

  8405.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    8406. 

  8406.             {

    8407. 

  8407.                 if (!(result.NodeType == et))

    8408. 

  8408.                 {

    8409. 

  8409.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8410. 

  8410.                     return 1;

    8411. 

  8411.                 }

    8412. 

  8412.                 if (!(result.Type == type))

    8413. 

  8413.                 {

    8414. 

  8414.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8415. 

  8415.                     return 1;

    8416. 

  8416.                 }

    8417. 

  8417.                 if (val == null)

    8418. 

  8418.                 {

    8419. 

  8419.                     if (result.Value != null) return 1;

    8420. 

  8420.                 }

    8421. 

  8421.                 else

    8422. 

  8422.                 {

    8423. 

  8423.                     if (!(result.Value.Equals(val))) return 1;

    8424. 

  8424.                 }

    8425. 

  8425.                 if (!(result.ToString() == str)) return 1;

    8426. 

  8426.                 return 0;

    8427. 

  8427.             }

    8428. 

  8428. 

    8429. 

  8429.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    8430. 

  8430.             {

    8431. 

  8431.                 if (!(result.NodeType == et))

    8432. 

  8432.                 {

    8433. 

  8433.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8434. 

  8434.                     return 1;

    8435. 

  8435.                 }

    8436. 

  8436.                 if (!(result.Type == type))

    8437. 

  8437.                 {

    8438. 

  8438.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8439. 

  8439.                     return 1;

    8440. 

  8440.                 }

    8441. 

  8441.                 if (operand == null)

    8442. 

  8442.                 {

    8443. 

  8443.                     if (result.Operand != null) return 1;

    8444. 

  8444.                 }

    8445. 

  8445.                 else

    8446. 

  8446.                 {

    8447. 

  8447.                     if (!(result.Operand.Equals(operand))) return 1;

    8448. 

  8448.                 }

    8449. 

  8449.                 if (!(result.ToString() == str))

    8450. 

  8450.                 {

    8451. 

  8451.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    8452. 

  8452.                     return 1;

    8453. 

  8453.                 }

    8454. 

  8454. 

    8455. 

  8455.                 if (result.Method != mi) return 1;

    8456. 

  8456.                 if (result.IsLifted != islifted) return 1;

    8457. 

  8457.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    8458. 

  8458. 

    8459. 

  8459.                 return 0;

    8460. 

  8460.             }

    8461. 

  8461. 

    8462. 

  8462.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    8463. 

  8463.             {

    8464. 

  8464.                 if (!(result.NodeType == et))

    8465. 

  8465.                 {

    8466. 

  8466.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8467. 

  8467.                     return 1;

    8468. 

  8468.                 }

    8469. 

  8469.                 if (!(result.Type == type))

    8470. 

  8470.                 {

    8471. 

  8471.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8472. 

  8472.                     return 1;

    8473. 

  8473.                 }

    8474. 

  8474. 

    8475. 

  8475.                 if (left == null)

    8476. 

  8476.                 {

    8477. 

  8477.                     if (result.Left != null)

    8478. 

  8478.                     {

    8479. 

  8479.                         Console.WriteLine("left was null");

    8480. 

  8480.                         return 1;

    8481. 

  8481.                     }

    8482. 

  8482.                 }

    8483. 

  8483.                 else

    8484. 

  8484.                 {

    8485. 

  8485.                     if (!(result.Left.Equals(left)))

    8486. 

  8486.                     {

    8487. 

  8487.                         Console.WriteLine("left was different");

    8488. 

  8488.                         return 1;

    8489. 

  8489.                     }

    8490. 

  8490.                 }

    8491. 

  8491. 

    8492. 

  8492.                 if (right == null)

    8493. 

  8493.                 {

    8494. 

  8494.                     if (result.Right != null) return 1;

    8495. 

  8495.                 }

    8496. 

  8496.                 else

    8497. 

  8497.                 {

    8498. 

  8498.                     if (!(result.Right.Equals(right))) return 1;

    8499. 

  8499.                 }

    8500. 

  8500. 

    8501. 

  8501.                 if (!(result.ToString() == str))

    8502. 

  8502.                 {

    8503. 

  8503.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    8504. 

  8504.                     return 1;

    8505. 

  8505.                 }

    8506. 

  8506. 

    8507. 

  8507.                 if (result.Method != mi) return 1;

    8508. 

  8508.                 if (result.IsLifted != islifted) return 1;

    8509. 

  8509.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    8510. 

  8510. 

    8511. 

  8511.                 if (result.Conversion != null) return 1;

    8512. 

  8512. 

    8513. 

  8513.                 return 0;

    8514. 

  8514.             }

    8515. 

  8515. 

    8516. 

  8516.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    8517. 

  8517.             {

    8518. 

  8518.                 if (!(result.NodeType == et))

    8519. 

  8519.                 {

    8520. 

  8520.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8521. 

  8521.                     return 1;

    8522. 

  8522.                 }

    8523. 

  8523.                 if (!(result.Type == type))

    8524. 

  8524.                 {

    8525. 

  8525.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8526. 

  8526.                     return 1;

    8527. 

  8527.                 }

    8528. 

  8528. 

    8529. 

  8529.                 if (left == null)

    8530. 

  8530.                 {

    8531. 

  8531.                     if (result.Left != null) return 1;

    8532. 

  8532.                 }

    8533. 

  8533.                 else

    8534. 

  8534.                 {

    8535. 

  8535.                     if (!(result.Left.Equals(left))) return 1;

    8536. 

  8536.                 }

    8537. 

  8537. 

    8538. 

  8538.                 if (right == null)

    8539. 

  8539.                 {

    8540. 

  8540.                     if (result.Right != null) return 1;

    8541. 

  8541.                 }

    8542. 

  8542.                 else

    8543. 

  8543.                 {

    8544. 

  8544.                     if (!(result.Right.Equals(right))) return 1;

    8545. 

  8545.                 }

    8546. 

  8546. 

    8547. 

  8547.                 if (!(result.ToString() == str)) return 1;

    8548. 

  8548. 

    8549. 

  8549.                 if (result.Method != mi) return 1;

    8550. 

  8550.                 if (result.IsLifted != islifted) return 1;

    8551. 

  8551.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    8552. 

  8552. 

    8553. 

  8553.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    8554. 

  8554. 

    8555. 

  8555.                 return 0;

    8556. 

  8556.             }

    8557. 

  8557. 

    8558. 

  8558.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    8559. 

  8559.             {

    8560. 

  8560.                 if (!(result.NodeType == et))

    8561. 

  8561.                 {

    8562. 

  8562.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8563. 

  8563.                     return 1;

    8564. 

  8564.                 }

    8565. 

  8565.                 if (!(result.Type == type))

    8566. 

  8566.                 {

    8567. 

  8567.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8568. 

  8568.                     return 1;

    8569. 

  8569.                 }

    8570. 

  8570. 

    8571. 

  8571.                 if (!(result.Method == method)) return 1;

    8572. 

  8572. 

    8573. 

  8573.                 if (obj == null)

    8574. 

  8574.                 {

    8575. 

  8575.                     if (result.Object != null)

    8576. 

  8576.                     {

    8577. 

  8577.                         Console.WriteLine("Expected object to be null.");

    8578. 

  8578.                         return 1;

    8579. 

  8579.                     }

    8580. 

  8580.                 }

    8581. 

  8581.                 else

    8582. 

  8582.                 {

    8583. 

  8583.                     if (!(result.Object.Equals(obj)))

    8584. 

  8584.                     {

    8585. 

  8585.                         Console.WriteLine("Object on which call is made is different from the result.");

    8586. 

  8586.                         return 1;

    8587. 

  8587.                     }

    8588. 

  8588.                 }

    8589. 

  8589. 

    8590. 

  8590.                 if (!(result.ToString() == str))

    8591. 

  8591.                 {

    8592. 

  8592.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    8593. 

  8593.                     return 1;

    8594. 

  8594.                 }

    8595. 

  8595. 

    8596. 

  8596.                 if (result.Arguments.Count != arguments.Length) return 1;

    8597. 

  8597. 

    8598. 

  8598.                 for (int i = 0; i < arguments.Length; i++)

    8599. 

  8599.                 {

    8600. 

  8600.                     if (result.Arguments[i] != arguments[i]) return 1;

    8601. 

  8601.                 }

    8602. 

  8602. 

    8603. 

  8603.                 return 0;

    8604. 

  8604.             }

    8605. 

  8605. 

    8606. 

  8606.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    8607. 

  8607.             {

    8608. 

  8608.                 if (!(result.NodeType == et))

    8609. 

  8609.                 {

    8610. 

  8610.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8611. 

  8611.                     return 1;

    8612. 

  8612.                 }

    8613. 

  8613.                 if (!(result.Type == type))

    8614. 

  8614.                 {

    8615. 

  8615.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8616. 

  8616.                     return 1;

    8617. 

  8617.                 }

    8618. 

  8618. 

    8619. 

  8619.                 if (expr == null)

    8620. 

  8620.                 {

    8621. 

  8621.                     Console.WriteLine("expr was null.");

    8622. 

  8622.                     if (result.Expression != null) return 1;

    8623. 

  8623.                 }

    8624. 

  8624.                 else

    8625. 

  8625.                 {

    8626. 

  8626.                     if (!(result.Expression.Equals(expr)))

    8627. 

  8627.                     {

    8628. 

  8628.                         return 1;

    8629. 

  8629.                     }

    8630. 

  8630.                 }

    8631. 

  8631. 

    8632. 

  8632.                 if (!(result.TypeOperand == typeop)) return 1;

    8633. 

  8633. 

    8634. 

  8634.                 if (!(result.ToString() == str))

    8635. 

  8635.                 {

    8636. 

  8636.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    8637. 

  8637.                     return 1;

    8638. 

  8638.                 }

    8639. 

  8639. 

    8640. 

  8640.                 return 0;

    8641. 

  8641.             }

    8642. 

  8642. 

    8643. 

  8643.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    8644. 

  8644.             {

    8645. 

  8645.                 if (!(result.NodeType == et))

    8646. 

  8646.                 {

    8647. 

  8647.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8648. 

  8648.                     return 1;

    8649. 

  8649.                 }

    8650. 

  8650.                 if (!(result.Type == type))

    8651. 

  8651.                 {

    8652. 

  8652.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8653. 

  8653.                     return 1;

    8654. 

  8654.                 }

    8655. 

  8655. 

    8656. 

  8656.                 if (test == null)

    8657. 

  8657.                 {

    8658. 

  8658.                     if (result.Test != null) return 1;

    8659. 

  8659.                 }

    8660. 

  8660.                 else

    8661. 

  8661.                 {

    8662. 

  8662.                     if (!(result.Test.Equals(test))) return 1;

    8663. 

  8663.                 }

    8664. 

  8664. 

    8665. 

  8665.                 if (ifTrue == null)

    8666. 

  8666.                 {

    8667. 

  8667.                     if (result.IfTrue != null) return 1;

    8668. 

  8668.                 }

    8669. 

  8669.                 else

    8670. 

  8670.                 {

    8671. 

  8671.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    8672. 

  8672.                 }

    8673. 

  8673. 

    8674. 

  8674.                 if (ifFalse == null)

    8675. 

  8675.                 {

    8676. 

  8676.                     if (result.IfFalse != null) return 1;

    8677. 

  8677.                 }

    8678. 

  8678.                 else

    8679. 

  8679.                 {

    8680. 

  8680.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    8681. 

  8681.                 }

    8682. 

  8682. 

    8683. 

  8683.                 if (!(result.ToString() == str)) return 1;

    8684. 

  8684. 

    8685. 

  8685.                 return 0;

    8686. 

  8686.             }

    8687. 

  8687. 

    8688. 

  8688.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    8689. 

  8689.             {

    8690. 

  8690.                 if (!(result.NodeType == et))

    8691. 

  8691.                 {

    8692. 

  8692.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8693. 

  8693.                     return 1;

    8694. 

  8694.                 }

    8695. 

  8695.                 if (!(result.Type == type))

    8696. 

  8696.                 {

    8697. 

  8697.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8698. 

  8698.                     return 1;

    8699. 

  8699.                 }

    8700. 

  8700. 

    8701. 

  8701.                 if (exp_expr == null)

    8702. 

  8702.                 {

    8703. 

  8703.                     if (result.Expression != null)

    8704. 

  8704.                     {

    8705. 

  8705.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    8706. 

  8706.                         return 1;

    8707. 

  8707.                     }

    8708. 

  8708.                 }

    8709. 

  8709.                 else

    8710. 

  8710.                 {

    8711. 

  8711.                     if (!(result.Expression.Equals(exp_expr)))

    8712. 

  8712.                     {

    8713. 

  8713.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    8714. 

  8714.                         return 1;

    8715. 

  8715.                     }

    8716. 

  8716.                 }

    8717. 

  8717. 

    8718. 

  8718.                 if (!(result.Member == exp_member))

    8719. 

  8719.                 {

    8720. 

  8720.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    8721. 

  8721.                     return 1;

    8722. 

  8722.                 }

    8723. 

  8723. 

    8724. 

  8724.                 if (!(result.ToString() == str))

    8725. 

  8725.                 {

    8726. 

  8726.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8727. 

  8727.                     return 1;

    8728. 

  8728.                 }

    8729. 

  8729. 

    8730. 

  8730.                 return 0;

    8731. 

  8731.             }

    8732. 

  8732. 

    8733. 

  8733.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    8734. 

  8734.             {

    8735. 

  8735.                 if (!(result.NodeType == et))

    8736. 

  8736.                 {

    8737. 

  8737.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8738. 

  8738.                     return 1;

    8739. 

  8739.                 }

    8740. 

  8740.                 if (!(result.Type == type))

    8741. 

  8741.                 {

    8742. 

  8742.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8743. 

  8743.                     return 1;

    8744. 

  8744.                 }

    8745. 

  8745. 

    8746. 

  8746.                 if (!(result.Constructor == constructor))

    8747. 

  8747.                 {

    8748. 

  8748.                     Console.WriteLine("Unexpected constructor");

    8749. 

  8749.                     return 1;

    8750. 

  8750.                 }

    8751. 

  8751. 

    8752. 

  8752.                 if (!(result.ToString() == str))

    8753. 

  8753.                 {

    8754. 

  8754.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8755. 

  8755.                     return 1;

    8756. 

  8756.                 }

    8757. 

  8757. 

    8758. 

  8758.                 if (arguments == null)

    8759. 

  8759.                 {

    8760. 

  8760.                     if (result.Arguments.Count != 0)

    8761. 

  8761.                     {

    8762. 

  8762.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    8763. 

  8763.                         return 1;

    8764. 

  8764.                     }

    8765. 

  8765.                 }

    8766. 

  8766.                 else

    8767. 

  8767.                 {

    8768. 

  8768.                     if (result.Arguments.Count != arguments.Length)

    8769. 

  8769.                     {

    8770. 

  8770.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    8771. 

  8771.                         return 1;

    8772. 

  8772.                     }

    8773. 

  8773.                     for (int i = 0; i < arguments.Length; i++)

    8774. 

  8774.                     {

    8775. 

  8775.                         if (result.Arguments[i] != arguments[i])

    8776. 

  8776.                         {

    8777. 

  8777.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    8778. 

  8778.                             return 1;

    8779. 

  8779.                         }

    8780. 

  8780.                     }

    8781. 

  8781.                 }

    8782. 

  8782. 

    8783. 

  8783.                 if (result.Members == null)

    8784. 

  8784.                 {

    8785. 

  8785.                     Console.WriteLine("result.Members was null");

    8786. 

  8786.                     return 1;

    8787. 

  8787.                 }

    8788. 

  8788. 

    8789. 

  8789.                 if (members == null)

    8790. 

  8790.                 {

    8791. 

  8791.                     if (result.Members.Count != 0)

    8792. 

  8792.                     {

    8793. 

  8793.                         Console.WriteLine("Got more than zero members");

    8794. 

  8794.                         return 1;

    8795. 

  8795.                     }

    8796. 

  8796.                 }

    8797. 

  8797.                 else

    8798. 

  8798.                 {

    8799. 

  8799.                     if (result.Members.Count != members.Length)

    8800. 

  8800.                     {

    8801. 

  8801.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    8802. 

  8802.                         return 1;

    8803. 

  8803.                     }

    8804. 

  8804. 

    8805. 

  8805.                     for (int i = 0; i < members.Length; i++)

    8806. 

  8806.                     {

    8807. 

  8807.                         if (result.Members[i] != members[i])

    8808. 

  8808.                         {

    8809. 

  8809.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    8810. 

  8810.                             return 1;

    8811. 

  8811.                         }

    8812. 

  8812.                     }

    8813. 

  8813.                 }

    8814. 

  8814. 

    8815. 

  8815.                 return 0;

    8816. 

  8816.             }

    8817. 

  8817. 

    8818. 

  8818.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    8819. 

  8819.             {

    8820. 

  8820.                 if (!(result.NodeType == et))

    8821. 

  8821.                 {

    8822. 

  8822.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8823. 

  8823.                     return 1;

    8824. 

  8824.                 }

    8825. 

  8825.                 if (!(result.Type == type))

    8826. 

  8826.                 {

    8827. 

  8827.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8828. 

  8828.                     return 1;

    8829. 

  8829.                 }

    8830. 

  8830. 

    8831. 

  8831.                 if (!(result.Constructor == constructor))

    8832. 

  8832.                 {

    8833. 

  8833.                     Console.WriteLine("Constructor is different from expected.");

    8834. 

  8834.                     return 1;

    8835. 

  8835.                 }

    8836. 

  8836. 

    8837. 

  8837.                 if (!(result.ToString() == str))

    8838. 

  8838.                 {

    8839. 

  8839.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8840. 

  8840.                     return 1;

    8841. 

  8841.                 }

    8842. 

  8842. 

    8843. 

  8843.                 if (result.Arguments.Count != arguments.Length)

    8844. 

  8844.                 {

    8845. 

  8845.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    8846. 

  8846.                     return 1;

    8847. 

  8847.                 }

    8848. 

  8848. 

    8849. 

  8849.                 for (int i = 0; i < arguments.Length; i++)

    8850. 

  8850.                 {

    8851. 

  8851.                     if (result.Arguments[i] != arguments[i])

    8852. 

  8852.                     {

    8853. 

  8853.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    8854. 

  8854.                         return 1;

    8855. 

  8855.                     }

    8856. 

  8856.                 }

    8857. 

  8857. 

    8858. 

  8858.                 if (result.Members != null)

    8859. 

  8859.                 {

    8860. 

  8860.                     Console.WriteLine("result.Members isn't null");

    8861. 

  8861.                     return 1;

    8862. 

  8862.                 }

    8863. 

  8863. 

    8864. 

  8864.                 return 0;

    8865. 

  8865.             }

    8866. 

  8866. 

    8867. 

  8867.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    8868. 

  8868.             {

    8869. 

  8869.                 if (!(result.NodeType == et))

    8870. 

  8870.                 {

    8871. 

  8871.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8872. 

  8872.                     return 1;

    8873. 

  8873.                 }

    8874. 

  8874.                 if (!(result.Type == type))

    8875. 

  8875.                 {

    8876. 

  8876.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8877. 

  8877.                     return 1;

    8878. 

  8878.                 }

    8879. 

  8879. 

    8880. 

  8880.                 if (!(result.NewExpression == newExpression)) return 1;

    8881. 

  8881. 

    8882. 

  8882.                 if (!(result.ToString() == str))

    8883. 

  8883.                 {

    8884. 

  8884.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8885. 

  8885.                     return 1;

    8886. 

  8886.                 }

    8887. 

  8887. 

    8888. 

  8888.                 if (result.Initializers.Count != initializers.Length) return 1;

    8889. 

  8889. 

    8890. 

  8890.                 for (int i = 0; i < initializers.Length; i++)

    8891. 

  8891.                 {

    8892. 

  8892.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    8893. 

  8893. 

    8894. 

  8894.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    8895. 

  8895. 

    8896. 

  8896.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    8897. 

  8897.                     {

    8898. 

  8898.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    8899. 

  8899.                     }

    8900. 

  8900.                 }

    8901. 

  8901. 

    8902. 

  8902.                 return 0;

    8903. 

  8903.             }

    8904. 

  8904. 

    8905. 

  8905.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    8906. 

  8906.             {

    8907. 

  8907.                 if (result.AddMethod != exp_mi) return 1;

    8908. 

  8908.                 if (!(result.ToString() == str))

    8909. 

  8909.                 {

    8910. 

  8910.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8911. 

  8911.                     return 1;

    8912. 

  8912.                 }

    8913. 

  8913. 

    8914. 

  8914.                 if (result.Arguments.Count != args.Length) return 1;

    8915. 

  8915. 

    8916. 

  8916.                 for (int i = 0; i < args.Length; i++)

    8917. 

  8917.                 {

    8918. 

  8918.                     if (result.Arguments[i] != args[i]) return 1;

    8919. 

  8919.                 }

    8920. 

  8920. 

    8921. 

  8921.                 return 0;

    8922. 

  8922.             }

    8923. 

  8923. 

    8924. 

  8924.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    8925. 

  8925.             {

    8926. 

  8926.                 if (!(result.BindingType == bt)) return 1;

    8927. 

  8927.                 if (!(result.Expression == expr)) return 1;

    8928. 

  8928.                 if (!(result.Member.Equals(member))) return 1;

    8929. 

  8929.                 if (!(result.ToString() == str))

    8930. 

  8930.                 {

    8931. 

  8931.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8932. 

  8932.                     return 1;

    8933. 

  8933.                 }

    8934. 

  8934. 

    8935. 

  8935.                 return 0;

    8936. 

  8936.             }

    8937. 

  8937. 

    8938. 

  8938.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    8939. 

  8939.             {

    8940. 

  8940.                 if (!(result.BindingType == bt)) return 1;

    8941. 

  8941. 

    8942. 

  8942.                 if (!(result.Member.Equals(member))) return 1;

    8943. 

  8943.                 if (!(result.ToString() == str))

    8944. 

  8944.                 {

    8945. 

  8945.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8946. 

  8946.                     return 1;

    8947. 

  8947.                 }

    8948. 

  8948. 

    8949. 

  8949.                 if (result.Initializers.Count != initializers.Length) return 1;

    8950. 

  8950. 

    8951. 

  8951.                 for (int i = 0; i < initializers.Length; i++)

    8952. 

  8952.                 {

    8953. 

  8953.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    8954. 

  8954. 

    8955. 

  8955.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    8956. 

  8956. 

    8957. 

  8957.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    8958. 

  8958.                     {

    8959. 

  8959.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    8960. 

  8960.                     }

    8961. 

  8961.                 }

    8962. 

  8962. 

    8963. 

  8963. 

    8964. 

  8964.                 return 0;

    8965. 

  8965.             }

    8966. 

  8966. 

    8967. 

  8967.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    8968. 

  8968.             {

    8969. 

  8969.                 if (!(result.BindingType == bt)) return 1;

    8970. 

  8970. 

    8971. 

  8971.                 if (!(result.Member.Equals(member))) return 1;

    8972. 

  8972.                 if (!(result.ToString() == str))

    8973. 

  8973.                 {

    8974. 

  8974.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    8975. 

  8975.                     return 1;

    8976. 

  8976.                 }

    8977. 

  8977. 

    8978. 

  8978.                 if (result.Bindings.Count != bindings.Length) return 1;

    8979. 

  8979. 

    8980. 

  8980.                 for (int i = 0; i < bindings.Length; i++)

    8981. 

  8981.                 {

    8982. 

  8982.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    8983. 

  8983.                 }

    8984. 

  8984. 

    8985. 

  8985.                 return 0;

    8986. 

  8986.             }

    8987. 

  8987. 

    8988. 

  8988.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    8989. 

  8989.             {

    8990. 

  8990.                 if (!(result.NodeType == et))

    8991. 

  8991.                 {

    8992. 

  8992.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    8993. 

  8993.                     return 1;

    8994. 

  8994.                 }

    8995. 

  8995.                 if (!(result.Type == type))

    8996. 

  8996.                 {

    8997. 

  8997.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    8998. 

  8998.                     return 1;

    8999. 

  8999.                 }

    9000. 

  9000.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    9001. 

  9001.                 if (!(result.ToString() == str)) return 1;

    9002. 

  9002. 

    9003. 

  9003.                 if (result.Bindings.Count != bindings.Length) return 1;

    9004. 

  9004. 

    9005. 

  9005.                 for (int i = 0; i < bindings.Length; i++)

    9006. 

  9006.                 {

    9007. 

  9007.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    9008. 

  9008.                 }

    9009. 

  9009. 

    9010. 

  9010.                 return 0;

    9011. 

  9011.             }

    9012. 

  9012. 

    9013. 

  9013.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    9014. 

  9014.             {

    9015. 

  9015.                 if (!(result.NodeType == et))

    9016. 

  9016.                 {

    9017. 

  9017.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9018. 

  9018.                     return 1;

    9019. 

  9019.                 }

    9020. 

  9020.                 if (!(result.Type == type))

    9021. 

  9021.                 {

    9022. 

  9022.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9023. 

  9023.                     return 1;

    9024. 

  9024.                 }

    9025. 

  9025. 

    9026. 

  9026.                 if (result.Expressions.Count != expr.Length) return 1;

    9027. 

  9027. 

    9028. 

  9028.                 for (int i = 0; i < expr.Length; i++)

    9029. 

  9029.                 {

    9030. 

  9030.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    9031. 

  9031.                 }

    9032. 

  9032.                 if (!(result.ToString() == str))

    9033. 

  9033.                 {

    9034. 

  9034.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9035. 

  9035.                     return 1;

    9036. 

  9036.                 }

    9037. 

  9037. 

    9038. 

  9038.                 return 0;

    9039. 

  9039.             }

    9040. 

  9040. 

    9041. 

  9041.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    9042. 

  9042.             {

    9043. 

  9043.                 if (!(result.NodeType == et))

    9044. 

  9044.                 {

    9045. 

  9045.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9046. 

  9046.                     return 1;

    9047. 

  9047.                 }

    9048. 

  9048.                 if (!(result.Type == type))

    9049. 

  9049.                 {

    9050. 

  9050.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9051. 

  9051.                     return 1;

    9052. 

  9052.                 }

    9053. 

  9053.                 if (!(result.Name == name)) return 1;

    9054. 

  9054. 

    9055. 

  9055.                 if (!(result.ToString() == str))

    9056. 

  9056.                 {

    9057. 

  9057.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9058. 

  9058.                     return 1;

    9059. 

  9059.                 }

    9060. 

  9060. 

    9061. 

  9061.                 return 0;

    9062. 

  9062.             }

    9063. 

  9063. 

    9064. 

  9064.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    9065. 

  9065.             {

    9066. 

  9066.                 if (!(result.NodeType == et))

    9067. 

  9067.                 {

    9068. 

  9068.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9069. 

  9069.                     return 1;

    9070. 

  9070.                 }

    9071. 

  9071.                 if (!(result.Type == type))

    9072. 

  9072.                 {

    9073. 

  9073.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9074. 

  9074.                     return 1;

    9075. 

  9075.                 }

    9076. 

  9076. 

    9077. 

  9077.                 if (expr == null)

    9078. 

  9078.                 {

    9079. 

  9079.                     if (result.Body != null) return 1;

    9080. 

  9080.                 }

    9081. 

  9081.                 else

    9082. 

  9082.                 {

    9083. 

  9083.                     if (!(result.Body.Equals(expr))) return 1;

    9084. 

  9084.                 }

    9085. 

  9085. 

    9086. 

  9086.                 if (result.Parameters.Count != parms.Length) return 1;

    9087. 

  9087. 

    9088. 

  9088.                 for (int i = 0; i < parms.Length; i++)

    9089. 

  9089.                 {

    9090. 

  9090.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    9091. 

  9091.                 }

    9092. 

  9092. 

    9093. 

  9093.                 if (!(result.ToString() == str))

    9094. 

  9094.                 {

    9095. 

  9095.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9096. 

  9096.                     return 1;

    9097. 

  9097.                 }

    9098. 

  9098. 

    9099. 

  9099.                 return 0;

    9100. 

  9100.             }

    9101. 

  9101. 

    9102. 

  9102.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    9103. 

  9103.             {

    9104. 

  9104.                 if (!(result.NodeType == et))

    9105. 

  9105.                 {

    9106. 

  9106.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9107. 

  9107.                     return 1;

    9108. 

  9108.                 }

    9109. 

  9109.                 if (!(result.Type == type))

    9110. 

  9110.                 {

    9111. 

  9111.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9112. 

  9112.                     return 1;

    9113. 

  9113.                 }

    9114. 

  9114. 

    9115. 

  9115.                 if (expr == null)

    9116. 

  9116.                 {

    9117. 

  9117.                     if (result.Expression != null) return 1;

    9118. 

  9118.                 }

    9119. 

  9119.                 else

    9120. 

  9120.                 {

    9121. 

  9121.                     if (!(result.Expression.Equals(expr))) return 1;

    9122. 

  9122.                 }

    9123. 

  9123. 

    9124. 

  9124.                 if (result.Arguments.Count != args.Length) return 1;

    9125. 

  9125. 

    9126. 

  9126.                 for (int i = 0; i < args.Length; i++)

    9127. 

  9127.                 {

    9128. 

  9128.                     if (!(result.Arguments[i].Equals(args[i])))

    9129. 

  9129.                     {

    9130. 

  9130.                         return 1;

    9131. 

  9131.                     }

    9132. 

  9132.                 }

    9133. 

  9133. 

    9134. 

  9134.                 if (result.ToString() != str)

    9135. 

  9135.                 {

    9136. 

  9136.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9137. 

  9137.                     return 1;

    9138. 

  9138.                 }

    9139. 

  9139. 

    9140. 

  9140.                 return 0;

    9141. 

  9141.             }

    9142. 

  9142.         }

    9143. 

  9143. 

    9144. 

  9144. 

    9145. 

  9145. 

    9146. 

  9146.         namespace Not

    9147. 

  9147.         {

    9148. 

  9148.             // Declaring user-defined types for testing

    9149. 

  9149.             struct TC1

    9150. 

  9150.             {

    9151. 

  9151.                 public static TC1 operator !(TC1 c)

    9152. 

  9152.                 {

    9153. 

  9153.                     return new TC1();

    9154. 

  9154.                 }

    9155. 

  9155. 

    9156. 

  9156.                 public static TC1 operator ~(TC1 c)

    9157. 

  9157.                 {

    9158. 

  9158.                     return new TC1();

    9159. 

  9159.                 }

    9160. 

  9160.             }

    9161. 

  9161. 

    9162. 

  9162.             struct TC2

    9163. 

  9163.             {

    9164. 

  9164.                 public static TC2 operator ~(TC2 c)

    9165. 

  9165.                 {

    9166. 

  9166.                     return new TC2();

    9167. 

  9167.                 }

    9168. 

  9168.             }

    9169. 

  9169. 

    9170. 

  9170.             struct TC3

    9171. 

  9171.             {

    9172. 

  9172.                 public static TC3 Meth1(TC3 c)

    9173. 

  9173.                 {

    9174. 

  9174.                     return new TC3();

    9175. 

  9175.                 }

    9176. 

  9176.             }

    9177. 

  9177.         }

    9178. 

  9178. 

    9179. 

  9179.     }

    9180. 

  9180. 

    9181. 

  9181.     //-------- Scenario 793

    9182. 

  9182.     namespace Scenario793

    9183. 

  9183.     {

    9184. 

  9184. 

    9185. 

  9185.         namespace Not

    9186. 

  9186.         {

    9187. 

  9187.             public class Test

    9188. 

  9188.             {

    9189. 

  9189.                 // Overload-2: Test for functionality: Passing null methodinfo

    9190. 

  9190.                 public static int Test12()

    9191. 

  9191.                 {

    9192. 

  9192.                     TC2? ctest = new TC2?();

    9193. 

  9193.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC2?));

    9194. 

  9194.                     Type exp_type = typeof(TC2?);

    9195. 

  9195.                     ExpressionType exp_et = ExpressionType.Not;

    9196. 

  9196.                     string exp_str = "Not(" + ce.ToString() + ")";

    9197. 

  9197.                     Expression exp_operand = ce;

    9198. 

  9198.                     MethodInfo exp_mi = typeof(TC2).GetMethod("op_OnesComplement");

    9199. 

  9199. 

    9200. 

  9200.                     UnaryExpression result = Expression.Not(ce, null);

    9201. 

  9201. 

    9202. 

  9202.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, true, true);

    9203. 

  9203.                 }

    9204. 

  9204. 

    9205. 

  9205. 

    9206. 

  9206.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not12__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    9207. 

  9207.                 public static Expression Not12__()

    9208. 

  9208.                 {

    9209. 

  9209.                     if (Main() != 0)

    9210. 

  9210.                     {

    9211. 

  9211.                         throw new Exception();

    9212. 

  9212.                     }

    9213. 

  9213.                     else

    9214. 

  9214.                     {

    9215. 

  9215.                         return Expression.Constant(0);

    9216. 

  9216.                     }

    9217. 

  9217.                 }

    9218. 

  9218.                 public static int Main()

    9219. 

  9219.                 {

    9220. 

  9220.                     return Test12();

    9221. 

  9221.                 }

    9222. 

  9222.             }

    9223. 

  9223.         }

    9224. 

  9224. 

    9225. 

  9225. 

    9226. 

  9226.         public static class Extension

    9227. 

  9227.         {

    9228. 

  9228.             public static bool CompareParamName(this ArgumentException ex, string expected)

    9229. 

  9229.             {

    9230. 

  9230. #if SILVERLIGHT

    9231. 

  9231. #if SLRESOURCES

    9232. 

  9232. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    9233. 

  9233. #else

    9234. 

  9234. 				        return true;

    9235. 

  9235. #endif

    9236. 

  9236. #else

    9237. 

  9237.                 return ex.ParamName == expected;

    9238. 

  9238. #endif

    9239. 

  9239.             }

    9240. 

  9240. 

    9241. 

  9241.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    9242. 

  9242.             {

    9243. 

  9243. #if SILVERLIGHT

    9244. 

  9244. #if SLRESOURCES

    9245. 

  9245. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    9246. 

  9246. #else

    9247. 

  9247. 				        return true;

    9248. 

  9248. #endif

    9249. 

  9249. #else

    9250. 

  9250.                 return ex.ParamName == expected;

    9251. 

  9251. #endif

    9252. 

  9252.             }

    9253. 

  9253.         }

    9254. 

  9254. 

    9255. 

  9255.         public static class Verification

    9256. 

  9256.         {

    9257. 

  9257.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    9258. 

  9258.             {

    9259. 

  9259.                 if (!(result.NodeType == et))

    9260. 

  9260.                 {

    9261. 

  9261.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9262. 

  9262.                     return 1;

    9263. 

  9263.                 }

    9264. 

  9264.                 if (!(result.Type == type))

    9265. 

  9265.                 {

    9266. 

  9266.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9267. 

  9267.                     return 1;

    9268. 

  9268.                 }

    9269. 

  9269.                 if (val == null)

    9270. 

  9270.                 {

    9271. 

  9271.                     if (result.Value != null) return 1;

    9272. 

  9272.                 }

    9273. 

  9273.                 else

    9274. 

  9274.                 {

    9275. 

  9275.                     if (!(result.Value.Equals(val))) return 1;

    9276. 

  9276.                 }

    9277. 

  9277.                 if (!(result.ToString() == str)) return 1;

    9278. 

  9278.                 return 0;

    9279. 

  9279.             }

    9280. 

  9280. 

    9281. 

  9281.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    9282. 

  9282.             {

    9283. 

  9283.                 if (!(result.NodeType == et))

    9284. 

  9284.                 {

    9285. 

  9285.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9286. 

  9286.                     return 1;

    9287. 

  9287.                 }

    9288. 

  9288.                 if (!(result.Type == type))

    9289. 

  9289.                 {

    9290. 

  9290.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9291. 

  9291.                     return 1;

    9292. 

  9292.                 }

    9293. 

  9293.                 if (operand == null)

    9294. 

  9294.                 {

    9295. 

  9295.                     if (result.Operand != null) return 1;

    9296. 

  9296.                 }

    9297. 

  9297.                 else

    9298. 

  9298.                 {

    9299. 

  9299.                     if (!(result.Operand.Equals(operand))) return 1;

    9300. 

  9300.                 }

    9301. 

  9301.                 if (!(result.ToString() == str))

    9302. 

  9302.                 {

    9303. 

  9303.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9304. 

  9304.                     return 1;

    9305. 

  9305.                 }

    9306. 

  9306. 

    9307. 

  9307.                 if (result.Method != mi) return 1;

    9308. 

  9308.                 if (result.IsLifted != islifted) return 1;

    9309. 

  9309.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    9310. 

  9310. 

    9311. 

  9311.                 return 0;

    9312. 

  9312.             }

    9313. 

  9313. 

    9314. 

  9314.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    9315. 

  9315.             {

    9316. 

  9316.                 if (!(result.NodeType == et))

    9317. 

  9317.                 {

    9318. 

  9318.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9319. 

  9319.                     return 1;

    9320. 

  9320.                 }

    9321. 

  9321.                 if (!(result.Type == type))

    9322. 

  9322.                 {

    9323. 

  9323.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9324. 

  9324.                     return 1;

    9325. 

  9325.                 }

    9326. 

  9326. 

    9327. 

  9327.                 if (left == null)

    9328. 

  9328.                 {

    9329. 

  9329.                     if (result.Left != null)

    9330. 

  9330.                     {

    9331. 

  9331.                         Console.WriteLine("left was null");

    9332. 

  9332.                         return 1;

    9333. 

  9333.                     }

    9334. 

  9334.                 }

    9335. 

  9335.                 else

    9336. 

  9336.                 {

    9337. 

  9337.                     if (!(result.Left.Equals(left)))

    9338. 

  9338.                     {

    9339. 

  9339.                         Console.WriteLine("left was different");

    9340. 

  9340.                         return 1;

    9341. 

  9341.                     }

    9342. 

  9342.                 }

    9343. 

  9343. 

    9344. 

  9344.                 if (right == null)

    9345. 

  9345.                 {

    9346. 

  9346.                     if (result.Right != null) return 1;

    9347. 

  9347.                 }

    9348. 

  9348.                 else

    9349. 

  9349.                 {

    9350. 

  9350.                     if (!(result.Right.Equals(right))) return 1;

    9351. 

  9351.                 }

    9352. 

  9352. 

    9353. 

  9353.                 if (!(result.ToString() == str))

    9354. 

  9354.                 {

    9355. 

  9355.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9356. 

  9356.                     return 1;

    9357. 

  9357.                 }

    9358. 

  9358. 

    9359. 

  9359.                 if (result.Method != mi) return 1;

    9360. 

  9360.                 if (result.IsLifted != islifted) return 1;

    9361. 

  9361.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    9362. 

  9362. 

    9363. 

  9363.                 if (result.Conversion != null) return 1;

    9364. 

  9364. 

    9365. 

  9365.                 return 0;

    9366. 

  9366.             }

    9367. 

  9367. 

    9368. 

  9368.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    9369. 

  9369.             {

    9370. 

  9370.                 if (!(result.NodeType == et))

    9371. 

  9371.                 {

    9372. 

  9372.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9373. 

  9373.                     return 1;

    9374. 

  9374.                 }

    9375. 

  9375.                 if (!(result.Type == type))

    9376. 

  9376.                 {

    9377. 

  9377.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9378. 

  9378.                     return 1;

    9379. 

  9379.                 }

    9380. 

  9380. 

    9381. 

  9381.                 if (left == null)

    9382. 

  9382.                 {

    9383. 

  9383.                     if (result.Left != null) return 1;

    9384. 

  9384.                 }

    9385. 

  9385.                 else

    9386. 

  9386.                 {

    9387. 

  9387.                     if (!(result.Left.Equals(left))) return 1;

    9388. 

  9388.                 }

    9389. 

  9389. 

    9390. 

  9390.                 if (right == null)

    9391. 

  9391.                 {

    9392. 

  9392.                     if (result.Right != null) return 1;

    9393. 

  9393.                 }

    9394. 

  9394.                 else

    9395. 

  9395.                 {

    9396. 

  9396.                     if (!(result.Right.Equals(right))) return 1;

    9397. 

  9397.                 }

    9398. 

  9398. 

    9399. 

  9399.                 if (!(result.ToString() == str)) return 1;

    9400. 

  9400. 

    9401. 

  9401.                 if (result.Method != mi) return 1;

    9402. 

  9402.                 if (result.IsLifted != islifted) return 1;

    9403. 

  9403.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    9404. 

  9404. 

    9405. 

  9405.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    9406. 

  9406. 

    9407. 

  9407.                 return 0;

    9408. 

  9408.             }

    9409. 

  9409. 

    9410. 

  9410.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    9411. 

  9411.             {

    9412. 

  9412.                 if (!(result.NodeType == et))

    9413. 

  9413.                 {

    9414. 

  9414.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9415. 

  9415.                     return 1;

    9416. 

  9416.                 }

    9417. 

  9417.                 if (!(result.Type == type))

    9418. 

  9418.                 {

    9419. 

  9419.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9420. 

  9420.                     return 1;

    9421. 

  9421.                 }

    9422. 

  9422. 

    9423. 

  9423.                 if (!(result.Method == method)) return 1;

    9424. 

  9424. 

    9425. 

  9425.                 if (obj == null)

    9426. 

  9426.                 {

    9427. 

  9427.                     if (result.Object != null)

    9428. 

  9428.                     {

    9429. 

  9429.                         Console.WriteLine("Expected object to be null.");

    9430. 

  9430.                         return 1;

    9431. 

  9431.                     }

    9432. 

  9432.                 }

    9433. 

  9433.                 else

    9434. 

  9434.                 {

    9435. 

  9435.                     if (!(result.Object.Equals(obj)))

    9436. 

  9436.                     {

    9437. 

  9437.                         Console.WriteLine("Object on which call is made is different from the result.");

    9438. 

  9438.                         return 1;

    9439. 

  9439.                     }

    9440. 

  9440.                 }

    9441. 

  9441. 

    9442. 

  9442.                 if (!(result.ToString() == str))

    9443. 

  9443.                 {

    9444. 

  9444.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9445. 

  9445.                     return 1;

    9446. 

  9446.                 }

    9447. 

  9447. 

    9448. 

  9448.                 if (result.Arguments.Count != arguments.Length) return 1;

    9449. 

  9449. 

    9450. 

  9450.                 for (int i = 0; i < arguments.Length; i++)

    9451. 

  9451.                 {

    9452. 

  9452.                     if (result.Arguments[i] != arguments[i]) return 1;

    9453. 

  9453.                 }

    9454. 

  9454. 

    9455. 

  9455.                 return 0;

    9456. 

  9456.             }

    9457. 

  9457. 

    9458. 

  9458.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    9459. 

  9459.             {

    9460. 

  9460.                 if (!(result.NodeType == et))

    9461. 

  9461.                 {

    9462. 

  9462.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9463. 

  9463.                     return 1;

    9464. 

  9464.                 }

    9465. 

  9465.                 if (!(result.Type == type))

    9466. 

  9466.                 {

    9467. 

  9467.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9468. 

  9468.                     return 1;

    9469. 

  9469.                 }

    9470. 

  9470. 

    9471. 

  9471.                 if (expr == null)

    9472. 

  9472.                 {

    9473. 

  9473.                     Console.WriteLine("expr was null.");

    9474. 

  9474.                     if (result.Expression != null) return 1;

    9475. 

  9475.                 }

    9476. 

  9476.                 else

    9477. 

  9477.                 {

    9478. 

  9478.                     if (!(result.Expression.Equals(expr)))

    9479. 

  9479.                     {

    9480. 

  9480.                         return 1;

    9481. 

  9481.                     }

    9482. 

  9482.                 }

    9483. 

  9483. 

    9484. 

  9484.                 if (!(result.TypeOperand == typeop)) return 1;

    9485. 

  9485. 

    9486. 

  9486.                 if (!(result.ToString() == str))

    9487. 

  9487.                 {

    9488. 

  9488.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9489. 

  9489.                     return 1;

    9490. 

  9490.                 }

    9491. 

  9491. 

    9492. 

  9492.                 return 0;

    9493. 

  9493.             }

    9494. 

  9494. 

    9495. 

  9495.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    9496. 

  9496.             {

    9497. 

  9497.                 if (!(result.NodeType == et))

    9498. 

  9498.                 {

    9499. 

  9499.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9500. 

  9500.                     return 1;

    9501. 

  9501.                 }

    9502. 

  9502.                 if (!(result.Type == type))

    9503. 

  9503.                 {

    9504. 

  9504.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9505. 

  9505.                     return 1;

    9506. 

  9506.                 }

    9507. 

  9507. 

    9508. 

  9508.                 if (test == null)

    9509. 

  9509.                 {

    9510. 

  9510.                     if (result.Test != null) return 1;

    9511. 

  9511.                 }

    9512. 

  9512.                 else

    9513. 

  9513.                 {

    9514. 

  9514.                     if (!(result.Test.Equals(test))) return 1;

    9515. 

  9515.                 }

    9516. 

  9516. 

    9517. 

  9517.                 if (ifTrue == null)

    9518. 

  9518.                 {

    9519. 

  9519.                     if (result.IfTrue != null) return 1;

    9520. 

  9520.                 }

    9521. 

  9521.                 else

    9522. 

  9522.                 {

    9523. 

  9523.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    9524. 

  9524.                 }

    9525. 

  9525. 

    9526. 

  9526.                 if (ifFalse == null)

    9527. 

  9527.                 {

    9528. 

  9528.                     if (result.IfFalse != null) return 1;

    9529. 

  9529.                 }

    9530. 

  9530.                 else

    9531. 

  9531.                 {

    9532. 

  9532.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    9533. 

  9533.                 }

    9534. 

  9534. 

    9535. 

  9535.                 if (!(result.ToString() == str)) return 1;

    9536. 

  9536. 

    9537. 

  9537.                 return 0;

    9538. 

  9538.             }

    9539. 

  9539. 

    9540. 

  9540.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    9541. 

  9541.             {

    9542. 

  9542.                 if (!(result.NodeType == et))

    9543. 

  9543.                 {

    9544. 

  9544.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9545. 

  9545.                     return 1;

    9546. 

  9546.                 }

    9547. 

  9547.                 if (!(result.Type == type))

    9548. 

  9548.                 {

    9549. 

  9549.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9550. 

  9550.                     return 1;

    9551. 

  9551.                 }

    9552. 

  9552. 

    9553. 

  9553.                 if (exp_expr == null)

    9554. 

  9554.                 {

    9555. 

  9555.                     if (result.Expression != null)

    9556. 

  9556.                     {

    9557. 

  9557.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    9558. 

  9558.                         return 1;

    9559. 

  9559.                     }

    9560. 

  9560.                 }

    9561. 

  9561.                 else

    9562. 

  9562.                 {

    9563. 

  9563.                     if (!(result.Expression.Equals(exp_expr)))

    9564. 

  9564.                     {

    9565. 

  9565.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    9566. 

  9566.                         return 1;

    9567. 

  9567.                     }

    9568. 

  9568.                 }

    9569. 

  9569. 

    9570. 

  9570.                 if (!(result.Member == exp_member))

    9571. 

  9571.                 {

    9572. 

  9572.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    9573. 

  9573.                     return 1;

    9574. 

  9574.                 }

    9575. 

  9575. 

    9576. 

  9576.                 if (!(result.ToString() == str))

    9577. 

  9577.                 {

    9578. 

  9578.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9579. 

  9579.                     return 1;

    9580. 

  9580.                 }

    9581. 

  9581. 

    9582. 

  9582.                 return 0;

    9583. 

  9583.             }

    9584. 

  9584. 

    9585. 

  9585.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    9586. 

  9586.             {

    9587. 

  9587.                 if (!(result.NodeType == et))

    9588. 

  9588.                 {

    9589. 

  9589.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9590. 

  9590.                     return 1;

    9591. 

  9591.                 }

    9592. 

  9592.                 if (!(result.Type == type))

    9593. 

  9593.                 {

    9594. 

  9594.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9595. 

  9595.                     return 1;

    9596. 

  9596.                 }

    9597. 

  9597. 

    9598. 

  9598.                 if (!(result.Constructor == constructor))

    9599. 

  9599.                 {

    9600. 

  9600.                     Console.WriteLine("Unexpected constructor");

    9601. 

  9601.                     return 1;

    9602. 

  9602.                 }

    9603. 

  9603. 

    9604. 

  9604.                 if (!(result.ToString() == str))

    9605. 

  9605.                 {

    9606. 

  9606.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9607. 

  9607.                     return 1;

    9608. 

  9608.                 }

    9609. 

  9609. 

    9610. 

  9610.                 if (arguments == null)

    9611. 

  9611.                 {

    9612. 

  9612.                     if (result.Arguments.Count != 0)

    9613. 

  9613.                     {

    9614. 

  9614.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    9615. 

  9615.                         return 1;

    9616. 

  9616.                     }

    9617. 

  9617.                 }

    9618. 

  9618.                 else

    9619. 

  9619.                 {

    9620. 

  9620.                     if (result.Arguments.Count != arguments.Length)

    9621. 

  9621.                     {

    9622. 

  9622.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    9623. 

  9623.                         return 1;

    9624. 

  9624.                     }

    9625. 

  9625.                     for (int i = 0; i < arguments.Length; i++)

    9626. 

  9626.                     {

    9627. 

  9627.                         if (result.Arguments[i] != arguments[i])

    9628. 

  9628.                         {

    9629. 

  9629.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    9630. 

  9630.                             return 1;

    9631. 

  9631.                         }

    9632. 

  9632.                     }

    9633. 

  9633.                 }

    9634. 

  9634. 

    9635. 

  9635.                 if (result.Members == null)

    9636. 

  9636.                 {

    9637. 

  9637.                     Console.WriteLine("result.Members was null");

    9638. 

  9638.                     return 1;

    9639. 

  9639.                 }

    9640. 

  9640. 

    9641. 

  9641.                 if (members == null)

    9642. 

  9642.                 {

    9643. 

  9643.                     if (result.Members.Count != 0)

    9644. 

  9644.                     {

    9645. 

  9645.                         Console.WriteLine("Got more than zero members");

    9646. 

  9646.                         return 1;

    9647. 

  9647.                     }

    9648. 

  9648.                 }

    9649. 

  9649.                 else

    9650. 

  9650.                 {

    9651. 

  9651.                     if (result.Members.Count != members.Length)

    9652. 

  9652.                     {

    9653. 

  9653.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    9654. 

  9654.                         return 1;

    9655. 

  9655.                     }

    9656. 

  9656. 

    9657. 

  9657.                     for (int i = 0; i < members.Length; i++)

    9658. 

  9658.                     {

    9659. 

  9659.                         if (result.Members[i] != members[i])

    9660. 

  9660.                         {

    9661. 

  9661.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    9662. 

  9662.                             return 1;

    9663. 

  9663.                         }

    9664. 

  9664.                     }

    9665. 

  9665.                 }

    9666. 

  9666. 

    9667. 

  9667.                 return 0;

    9668. 

  9668.             }

    9669. 

  9669. 

    9670. 

  9670.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    9671. 

  9671.             {

    9672. 

  9672.                 if (!(result.NodeType == et))

    9673. 

  9673.                 {

    9674. 

  9674.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9675. 

  9675.                     return 1;

    9676. 

  9676.                 }

    9677. 

  9677.                 if (!(result.Type == type))

    9678. 

  9678.                 {

    9679. 

  9679.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9680. 

  9680.                     return 1;

    9681. 

  9681.                 }

    9682. 

  9682. 

    9683. 

  9683.                 if (!(result.Constructor == constructor))

    9684. 

  9684.                 {

    9685. 

  9685.                     Console.WriteLine("Constructor is different from expected.");

    9686. 

  9686.                     return 1;

    9687. 

  9687.                 }

    9688. 

  9688. 

    9689. 

  9689.                 if (!(result.ToString() == str))

    9690. 

  9690.                 {

    9691. 

  9691.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9692. 

  9692.                     return 1;

    9693. 

  9693.                 }

    9694. 

  9694. 

    9695. 

  9695.                 if (result.Arguments.Count != arguments.Length)

    9696. 

  9696.                 {

    9697. 

  9697.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    9698. 

  9698.                     return 1;

    9699. 

  9699.                 }

    9700. 

  9700. 

    9701. 

  9701.                 for (int i = 0; i < arguments.Length; i++)

    9702. 

  9702.                 {

    9703. 

  9703.                     if (result.Arguments[i] != arguments[i])

    9704. 

  9704.                     {

    9705. 

  9705.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    9706. 

  9706.                         return 1;

    9707. 

  9707.                     }

    9708. 

  9708.                 }

    9709. 

  9709. 

    9710. 

  9710.                 if (result.Members != null)

    9711. 

  9711.                 {

    9712. 

  9712.                     Console.WriteLine("result.Members isn't null");

    9713. 

  9713.                     return 1;

    9714. 

  9714.                 }

    9715. 

  9715. 

    9716. 

  9716.                 return 0;

    9717. 

  9717.             }

    9718. 

  9718. 

    9719. 

  9719.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    9720. 

  9720.             {

    9721. 

  9721.                 if (!(result.NodeType == et))

    9722. 

  9722.                 {

    9723. 

  9723.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9724. 

  9724.                     return 1;

    9725. 

  9725.                 }

    9726. 

  9726.                 if (!(result.Type == type))

    9727. 

  9727.                 {

    9728. 

  9728.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9729. 

  9729.                     return 1;

    9730. 

  9730.                 }

    9731. 

  9731. 

    9732. 

  9732.                 if (!(result.NewExpression == newExpression)) return 1;

    9733. 

  9733. 

    9734. 

  9734.                 if (!(result.ToString() == str))

    9735. 

  9735.                 {

    9736. 

  9736.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9737. 

  9737.                     return 1;

    9738. 

  9738.                 }

    9739. 

  9739. 

    9740. 

  9740.                 if (result.Initializers.Count != initializers.Length) return 1;

    9741. 

  9741. 

    9742. 

  9742.                 for (int i = 0; i < initializers.Length; i++)

    9743. 

  9743.                 {

    9744. 

  9744.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    9745. 

  9745. 

    9746. 

  9746.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    9747. 

  9747. 

    9748. 

  9748.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    9749. 

  9749.                     {

    9750. 

  9750.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    9751. 

  9751.                     }

    9752. 

  9752.                 }

    9753. 

  9753. 

    9754. 

  9754.                 return 0;

    9755. 

  9755.             }

    9756. 

  9756. 

    9757. 

  9757.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    9758. 

  9758.             {

    9759. 

  9759.                 if (result.AddMethod != exp_mi) return 1;

    9760. 

  9760.                 if (!(result.ToString() == str))

    9761. 

  9761.                 {

    9762. 

  9762.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9763. 

  9763.                     return 1;

    9764. 

  9764.                 }

    9765. 

  9765. 

    9766. 

  9766.                 if (result.Arguments.Count != args.Length) return 1;

    9767. 

  9767. 

    9768. 

  9768.                 for (int i = 0; i < args.Length; i++)

    9769. 

  9769.                 {

    9770. 

  9770.                     if (result.Arguments[i] != args[i]) return 1;

    9771. 

  9771.                 }

    9772. 

  9772. 

    9773. 

  9773.                 return 0;

    9774. 

  9774.             }

    9775. 

  9775. 

    9776. 

  9776.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    9777. 

  9777.             {

    9778. 

  9778.                 if (!(result.BindingType == bt)) return 1;

    9779. 

  9779.                 if (!(result.Expression == expr)) return 1;

    9780. 

  9780.                 if (!(result.Member.Equals(member))) return 1;

    9781. 

  9781.                 if (!(result.ToString() == str))

    9782. 

  9782.                 {

    9783. 

  9783.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9784. 

  9784.                     return 1;

    9785. 

  9785.                 }

    9786. 

  9786. 

    9787. 

  9787.                 return 0;

    9788. 

  9788.             }

    9789. 

  9789. 

    9790. 

  9790.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    9791. 

  9791.             {

    9792. 

  9792.                 if (!(result.BindingType == bt)) return 1;

    9793. 

  9793. 

    9794. 

  9794.                 if (!(result.Member.Equals(member))) return 1;

    9795. 

  9795.                 if (!(result.ToString() == str))

    9796. 

  9796.                 {

    9797. 

  9797.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9798. 

  9798.                     return 1;

    9799. 

  9799.                 }

    9800. 

  9800. 

    9801. 

  9801.                 if (result.Initializers.Count != initializers.Length) return 1;

    9802. 

  9802. 

    9803. 

  9803.                 for (int i = 0; i < initializers.Length; i++)

    9804. 

  9804.                 {

    9805. 

  9805.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    9806. 

  9806. 

    9807. 

  9807.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    9808. 

  9808. 

    9809. 

  9809.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    9810. 

  9810.                     {

    9811. 

  9811.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    9812. 

  9812.                     }

    9813. 

  9813.                 }

    9814. 

  9814. 

    9815. 

  9815. 

    9816. 

  9816.                 return 0;

    9817. 

  9817.             }

    9818. 

  9818. 

    9819. 

  9819.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    9820. 

  9820.             {

    9821. 

  9821.                 if (!(result.BindingType == bt)) return 1;

    9822. 

  9822. 

    9823. 

  9823.                 if (!(result.Member.Equals(member))) return 1;

    9824. 

  9824.                 if (!(result.ToString() == str))

    9825. 

  9825.                 {

    9826. 

  9826.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9827. 

  9827.                     return 1;

    9828. 

  9828.                 }

    9829. 

  9829. 

    9830. 

  9830.                 if (result.Bindings.Count != bindings.Length) return 1;

    9831. 

  9831. 

    9832. 

  9832.                 for (int i = 0; i < bindings.Length; i++)

    9833. 

  9833.                 {

    9834. 

  9834.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    9835. 

  9835.                 }

    9836. 

  9836. 

    9837. 

  9837.                 return 0;

    9838. 

  9838.             }

    9839. 

  9839. 

    9840. 

  9840.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    9841. 

  9841.             {

    9842. 

  9842.                 if (!(result.NodeType == et))

    9843. 

  9843.                 {

    9844. 

  9844.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9845. 

  9845.                     return 1;

    9846. 

  9846.                 }

    9847. 

  9847.                 if (!(result.Type == type))

    9848. 

  9848.                 {

    9849. 

  9849.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9850. 

  9850.                     return 1;

    9851. 

  9851.                 }

    9852. 

  9852.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    9853. 

  9853.                 if (!(result.ToString() == str)) return 1;

    9854. 

  9854. 

    9855. 

  9855.                 if (result.Bindings.Count != bindings.Length) return 1;

    9856. 

  9856. 

    9857. 

  9857.                 for (int i = 0; i < bindings.Length; i++)

    9858. 

  9858.                 {

    9859. 

  9859.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    9860. 

  9860.                 }

    9861. 

  9861. 

    9862. 

  9862.                 return 0;

    9863. 

  9863.             }

    9864. 

  9864. 

    9865. 

  9865.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    9866. 

  9866.             {

    9867. 

  9867.                 if (!(result.NodeType == et))

    9868. 

  9868.                 {

    9869. 

  9869.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9870. 

  9870.                     return 1;

    9871. 

  9871.                 }

    9872. 

  9872.                 if (!(result.Type == type))

    9873. 

  9873.                 {

    9874. 

  9874.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9875. 

  9875.                     return 1;

    9876. 

  9876.                 }

    9877. 

  9877. 

    9878. 

  9878.                 if (result.Expressions.Count != expr.Length) return 1;

    9879. 

  9879. 

    9880. 

  9880.                 for (int i = 0; i < expr.Length; i++)

    9881. 

  9881.                 {

    9882. 

  9882.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    9883. 

  9883.                 }

    9884. 

  9884.                 if (!(result.ToString() == str))

    9885. 

  9885.                 {

    9886. 

  9886.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9887. 

  9887.                     return 1;

    9888. 

  9888.                 }

    9889. 

  9889. 

    9890. 

  9890.                 return 0;

    9891. 

  9891.             }

    9892. 

  9892. 

    9893. 

  9893.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    9894. 

  9894.             {

    9895. 

  9895.                 if (!(result.NodeType == et))

    9896. 

  9896.                 {

    9897. 

  9897.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9898. 

  9898.                     return 1;

    9899. 

  9899.                 }

    9900. 

  9900.                 if (!(result.Type == type))

    9901. 

  9901.                 {

    9902. 

  9902.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9903. 

  9903.                     return 1;

    9904. 

  9904.                 }

    9905. 

  9905.                 if (!(result.Name == name)) return 1;

    9906. 

  9906. 

    9907. 

  9907.                 if (!(result.ToString() == str))

    9908. 

  9908.                 {

    9909. 

  9909.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9910. 

  9910.                     return 1;

    9911. 

  9911.                 }

    9912. 

  9912. 

    9913. 

  9913.                 return 0;

    9914. 

  9914.             }

    9915. 

  9915. 

    9916. 

  9916.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    9917. 

  9917.             {

    9918. 

  9918.                 if (!(result.NodeType == et))

    9919. 

  9919.                 {

    9920. 

  9920.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9921. 

  9921.                     return 1;

    9922. 

  9922.                 }

    9923. 

  9923.                 if (!(result.Type == type))

    9924. 

  9924.                 {

    9925. 

  9925.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9926. 

  9926.                     return 1;

    9927. 

  9927.                 }

    9928. 

  9928. 

    9929. 

  9929.                 if (expr == null)

    9930. 

  9930.                 {

    9931. 

  9931.                     if (result.Body != null) return 1;

    9932. 

  9932.                 }

    9933. 

  9933.                 else

    9934. 

  9934.                 {

    9935. 

  9935.                     if (!(result.Body.Equals(expr))) return 1;

    9936. 

  9936.                 }

    9937. 

  9937. 

    9938. 

  9938.                 if (result.Parameters.Count != parms.Length) return 1;

    9939. 

  9939. 

    9940. 

  9940.                 for (int i = 0; i < parms.Length; i++)

    9941. 

  9941.                 {

    9942. 

  9942.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    9943. 

  9943.                 }

    9944. 

  9944. 

    9945. 

  9945.                 if (!(result.ToString() == str))

    9946. 

  9946.                 {

    9947. 

  9947.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    9948. 

  9948.                     return 1;

    9949. 

  9949.                 }

    9950. 

  9950. 

    9951. 

  9951.                 return 0;

    9952. 

  9952.             }

    9953. 

  9953. 

    9954. 

  9954.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    9955. 

  9955.             {

    9956. 

  9956.                 if (!(result.NodeType == et))

    9957. 

  9957.                 {

    9958. 

  9958.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    9959. 

  9959.                     return 1;

    9960. 

  9960.                 }

    9961. 

  9961.                 if (!(result.Type == type))

    9962. 

  9962.                 {

    9963. 

  9963.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    9964. 

  9964.                     return 1;

    9965. 

  9965.                 }

    9966. 

  9966. 

    9967. 

  9967.                 if (expr == null)

    9968. 

  9968.                 {

    9969. 

  9969.                     if (result.Expression != null) return 1;

    9970. 

  9970.                 }

    9971. 

  9971.                 else

    9972. 

  9972.                 {

    9973. 

  9973.                     if (!(result.Expression.Equals(expr))) return 1;

    9974. 

  9974.                 }

    9975. 

  9975. 

    9976. 

  9976.                 if (result.Arguments.Count != args.Length) return 1;

    9977. 

  9977. 

    9978. 

  9978.                 for (int i = 0; i < args.Length; i++)

    9979. 

  9979.                 {

    9980. 

  9980.                     if (!(result.Arguments[i].Equals(args[i])))

    9981. 

  9981.                     {

    9982. 

  9982.                         return 1;

    9983. 

  9983.                     }

    9984. 

  9984.                 }

    9985. 

  9985. 

    9986. 

  9986.                 if (result.ToString() != str)

    9987. 

  9987.                 {

    9988. 

  9988.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    9989. 

  9989.                     return 1;

    9990. 

  9990.                 }

    9991. 

  9991. 

    9992. 

  9992.                 return 0;

    9993. 

  9993.             }

    9994. 

  9994.         }

    9995. 

  9995. 

    9996. 

  9996. 

    9997. 

  9997. 

    9998. 

  9998.         namespace Not

    9999. 

  9999.         {

    10000. 

  10000.             // Declaring user-defined types for testing

    10001. 

  10001.             struct TC1

    10002. 

  10002.             {

    10003. 

  10003.                 public static TC1 operator !(TC1 c)

    10004. 

  10004.                 {

    10005. 

  10005.                     return new TC1();

    10006. 

  10006.                 }

    10007. 

  10007. 

    10008. 

  10008.                 public static TC1 operator ~(TC1 c)

    10009. 

  10009.                 {

    10010. 

  10010.                     return new TC1();

    10011. 

  10011.                 }

    10012. 

  10012.             }

    10013. 

  10013. 

    10014. 

  10014.             struct TC2

    10015. 

  10015.             {

    10016. 

  10016.                 public static TC2 operator ~(TC2 c)

    10017. 

  10017.                 {

    10018. 

  10018.                     return new TC2();

    10019. 

  10019.                 }

    10020. 

  10020.             }

    10021. 

  10021. 

    10022. 

  10022.             struct TC3

    10023. 

  10023.             {

    10024. 

  10024.                 public static TC3 Meth1(TC3 c)

    10025. 

  10025.                 {

    10026. 

  10026.                     return new TC3();

    10027. 

  10027.                 }

    10028. 

  10028.             }

    10029. 

  10029.         }

    10030. 

  10030. 

    10031. 

  10031.     }

    10032. 

  10032. 

    10033. 

  10033.     //-------- Scenario 794

    10034. 

  10034.     namespace Scenario794

    10035. 

  10035.     {

    10036. 

  10036. 

    10037. 

  10037.         namespace Not

    10038. 

  10038.         {

    10039. 

  10039.             public class Test

    10040. 

  10040.             {

    10041. 

  10041.                 // Overload-2: Passing null methodinfo

    10042. 

  10042.                 public static int Test13a()

    10043. 

  10043.                 {

    10044. 

  10044.                     TC3 ctest = new TC3();

    10045. 

  10045.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC3));

    10046. 

  10046. 

    10047. 

  10047.                     try

    10048. 

  10048.                     {

    10049. 

  10049.                         UnaryExpression result = Expression.Not(ce, null);

    10050. 

  10050.                         return 1;

    10051. 

  10051.                     }

    10052. 

  10052.                     catch (InvalidOperationException)

    10053. 

  10053.                     {

    10054. 

  10054.                         return 0;

    10055. 

  10055.                     }

    10056. 

  10056.                 }

    10057. 

  10057. 

    10058. 

  10058. 

    10059. 

  10059.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not13a__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    10060. 

  10060.                 public static Expression Not13a__()

    10061. 

  10061.                 {

    10062. 

  10062.                     if (Main() != 0)

    10063. 

  10063.                     {

    10064. 

  10064.                         throw new Exception();

    10065. 

  10065.                     }

    10066. 

  10066.                     else

    10067. 

  10067.                     {

    10068. 

  10068.                         return Expression.Constant(0);

    10069. 

  10069.                     }

    10070. 

  10070.                 }

    10071. 

  10071.                 public static int Main()

    10072. 

  10072.                 {

    10073. 

  10073.                     return Test13a();

    10074. 

  10074.                 }

    10075. 

  10075.             }

    10076. 

  10076.         }

    10077. 

  10077. 

    10078. 

  10078. 

    10079. 

  10079.         public static class Extension

    10080. 

  10080.         {

    10081. 

  10081.             public static bool CompareParamName(this ArgumentException ex, string expected)

    10082. 

  10082.             {

    10083. 

  10083. #if SILVERLIGHT

    10084. 

  10084. #if SLRESOURCES

    10085. 

  10085. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    10086. 

  10086. #else

    10087. 

  10087. 				        return true;

    10088. 

  10088. #endif

    10089. 

  10089. #else

    10090. 

  10090.                 return ex.ParamName == expected;

    10091. 

  10091. #endif

    10092. 

  10092.             }

    10093. 

  10093. 

    10094. 

  10094.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    10095. 

  10095.             {

    10096. 

  10096. #if SILVERLIGHT

    10097. 

  10097. #if SLRESOURCES

    10098. 

  10098. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    10099. 

  10099. #else

    10100. 

  10100. 				        return true;

    10101. 

  10101. #endif

    10102. 

  10102. #else

    10103. 

  10103.                 return ex.ParamName == expected;

    10104. 

  10104. #endif

    10105. 

  10105.             }

    10106. 

  10106.         }

    10107. 

  10107. 

    10108. 

  10108.         public static class Verification

    10109. 

  10109.         {

    10110. 

  10110.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    10111. 

  10111.             {

    10112. 

  10112.                 if (!(result.NodeType == et))

    10113. 

  10113.                 {

    10114. 

  10114.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10115. 

  10115.                     return 1;

    10116. 

  10116.                 }

    10117. 

  10117.                 if (!(result.Type == type))

    10118. 

  10118.                 {

    10119. 

  10119.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10120. 

  10120.                     return 1;

    10121. 

  10121.                 }

    10122. 

  10122.                 if (val == null)

    10123. 

  10123.                 {

    10124. 

  10124.                     if (result.Value != null) return 1;

    10125. 

  10125.                 }

    10126. 

  10126.                 else

    10127. 

  10127.                 {

    10128. 

  10128.                     if (!(result.Value.Equals(val))) return 1;

    10129. 

  10129.                 }

    10130. 

  10130.                 if (!(result.ToString() == str)) return 1;

    10131. 

  10131.                 return 0;

    10132. 

  10132.             }

    10133. 

  10133. 

    10134. 

  10134.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    10135. 

  10135.             {

    10136. 

  10136.                 if (!(result.NodeType == et))

    10137. 

  10137.                 {

    10138. 

  10138.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10139. 

  10139.                     return 1;

    10140. 

  10140.                 }

    10141. 

  10141.                 if (!(result.Type == type))

    10142. 

  10142.                 {

    10143. 

  10143.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10144. 

  10144.                     return 1;

    10145. 

  10145.                 }

    10146. 

  10146.                 if (operand == null)

    10147. 

  10147.                 {

    10148. 

  10148.                     if (result.Operand != null) return 1;

    10149. 

  10149.                 }

    10150. 

  10150.                 else

    10151. 

  10151.                 {

    10152. 

  10152.                     if (!(result.Operand.Equals(operand))) return 1;

    10153. 

  10153.                 }

    10154. 

  10154.                 if (!(result.ToString() == str))

    10155. 

  10155.                 {

    10156. 

  10156.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    10157. 

  10157.                     return 1;

    10158. 

  10158.                 }

    10159. 

  10159. 

    10160. 

  10160.                 if (result.Method != mi) return 1;

    10161. 

  10161.                 if (result.IsLifted != islifted) return 1;

    10162. 

  10162.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    10163. 

  10163. 

    10164. 

  10164.                 return 0;

    10165. 

  10165.             }

    10166. 

  10166. 

    10167. 

  10167.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    10168. 

  10168.             {

    10169. 

  10169.                 if (!(result.NodeType == et))

    10170. 

  10170.                 {

    10171. 

  10171.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10172. 

  10172.                     return 1;

    10173. 

  10173.                 }

    10174. 

  10174.                 if (!(result.Type == type))

    10175. 

  10175.                 {

    10176. 

  10176.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10177. 

  10177.                     return 1;

    10178. 

  10178.                 }

    10179. 

  10179. 

    10180. 

  10180.                 if (left == null)

    10181. 

  10181.                 {

    10182. 

  10182.                     if (result.Left != null)

    10183. 

  10183.                     {

    10184. 

  10184.                         Console.WriteLine("left was null");

    10185. 

  10185.                         return 1;

    10186. 

  10186.                     }

    10187. 

  10187.                 }

    10188. 

  10188.                 else

    10189. 

  10189.                 {

    10190. 

  10190.                     if (!(result.Left.Equals(left)))

    10191. 

  10191.                     {

    10192. 

  10192.                         Console.WriteLine("left was different");

    10193. 

  10193.                         return 1;

    10194. 

  10194.                     }

    10195. 

  10195.                 }

    10196. 

  10196. 

    10197. 

  10197.                 if (right == null)

    10198. 

  10198.                 {

    10199. 

  10199.                     if (result.Right != null) return 1;

    10200. 

  10200.                 }

    10201. 

  10201.                 else

    10202. 

  10202.                 {

    10203. 

  10203.                     if (!(result.Right.Equals(right))) return 1;

    10204. 

  10204.                 }

    10205. 

  10205. 

    10206. 

  10206.                 if (!(result.ToString() == str))

    10207. 

  10207.                 {

    10208. 

  10208.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    10209. 

  10209.                     return 1;

    10210. 

  10210.                 }

    10211. 

  10211. 

    10212. 

  10212.                 if (result.Method != mi) return 1;

    10213. 

  10213.                 if (result.IsLifted != islifted) return 1;

    10214. 

  10214.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    10215. 

  10215. 

    10216. 

  10216.                 if (result.Conversion != null) return 1;

    10217. 

  10217. 

    10218. 

  10218.                 return 0;

    10219. 

  10219.             }

    10220. 

  10220. 

    10221. 

  10221.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    10222. 

  10222.             {

    10223. 

  10223.                 if (!(result.NodeType == et))

    10224. 

  10224.                 {

    10225. 

  10225.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10226. 

  10226.                     return 1;

    10227. 

  10227.                 }

    10228. 

  10228.                 if (!(result.Type == type))

    10229. 

  10229.                 {

    10230. 

  10230.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10231. 

  10231.                     return 1;

    10232. 

  10232.                 }

    10233. 

  10233. 

    10234. 

  10234.                 if (left == null)

    10235. 

  10235.                 {

    10236. 

  10236.                     if (result.Left != null) return 1;

    10237. 

  10237.                 }

    10238. 

  10238.                 else

    10239. 

  10239.                 {

    10240. 

  10240.                     if (!(result.Left.Equals(left))) return 1;

    10241. 

  10241.                 }

    10242. 

  10242. 

    10243. 

  10243.                 if (right == null)

    10244. 

  10244.                 {

    10245. 

  10245.                     if (result.Right != null) return 1;

    10246. 

  10246.                 }

    10247. 

  10247.                 else

    10248. 

  10248.                 {

    10249. 

  10249.                     if (!(result.Right.Equals(right))) return 1;

    10250. 

  10250.                 }

    10251. 

  10251. 

    10252. 

  10252.                 if (!(result.ToString() == str)) return 1;

    10253. 

  10253. 

    10254. 

  10254.                 if (result.Method != mi) return 1;

    10255. 

  10255.                 if (result.IsLifted != islifted) return 1;

    10256. 

  10256.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    10257. 

  10257. 

    10258. 

  10258.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    10259. 

  10259. 

    10260. 

  10260.                 return 0;

    10261. 

  10261.             }

    10262. 

  10262. 

    10263. 

  10263.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    10264. 

  10264.             {

    10265. 

  10265.                 if (!(result.NodeType == et))

    10266. 

  10266.                 {

    10267. 

  10267.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10268. 

  10268.                     return 1;

    10269. 

  10269.                 }

    10270. 

  10270.                 if (!(result.Type == type))

    10271. 

  10271.                 {

    10272. 

  10272.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10273. 

  10273.                     return 1;

    10274. 

  10274.                 }

    10275. 

  10275. 

    10276. 

  10276.                 if (!(result.Method == method)) return 1;

    10277. 

  10277. 

    10278. 

  10278.                 if (obj == null)

    10279. 

  10279.                 {

    10280. 

  10280.                     if (result.Object != null)

    10281. 

  10281.                     {

    10282. 

  10282.                         Console.WriteLine("Expected object to be null.");

    10283. 

  10283.                         return 1;

    10284. 

  10284.                     }

    10285. 

  10285.                 }

    10286. 

  10286.                 else

    10287. 

  10287.                 {

    10288. 

  10288.                     if (!(result.Object.Equals(obj)))

    10289. 

  10289.                     {

    10290. 

  10290.                         Console.WriteLine("Object on which call is made is different from the result.");

    10291. 

  10291.                         return 1;

    10292. 

  10292.                     }

    10293. 

  10293.                 }

    10294. 

  10294. 

    10295. 

  10295.                 if (!(result.ToString() == str))

    10296. 

  10296.                 {

    10297. 

  10297.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    10298. 

  10298.                     return 1;

    10299. 

  10299.                 }

    10300. 

  10300. 

    10301. 

  10301.                 if (result.Arguments.Count != arguments.Length) return 1;

    10302. 

  10302. 

    10303. 

  10303.                 for (int i = 0; i < arguments.Length; i++)

    10304. 

  10304.                 {

    10305. 

  10305.                     if (result.Arguments[i] != arguments[i]) return 1;

    10306. 

  10306.                 }

    10307. 

  10307. 

    10308. 

  10308.                 return 0;

    10309. 

  10309.             }

    10310. 

  10310. 

    10311. 

  10311.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    10312. 

  10312.             {

    10313. 

  10313.                 if (!(result.NodeType == et))

    10314. 

  10314.                 {

    10315. 

  10315.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10316. 

  10316.                     return 1;

    10317. 

  10317.                 }

    10318. 

  10318.                 if (!(result.Type == type))

    10319. 

  10319.                 {

    10320. 

  10320.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10321. 

  10321.                     return 1;

    10322. 

  10322.                 }

    10323. 

  10323. 

    10324. 

  10324.                 if (expr == null)

    10325. 

  10325.                 {

    10326. 

  10326.                     Console.WriteLine("expr was null.");

    10327. 

  10327.                     if (result.Expression != null) return 1;

    10328. 

  10328.                 }

    10329. 

  10329.                 else

    10330. 

  10330.                 {

    10331. 

  10331.                     if (!(result.Expression.Equals(expr)))

    10332. 

  10332.                     {

    10333. 

  10333.                         return 1;

    10334. 

  10334.                     }

    10335. 

  10335.                 }

    10336. 

  10336. 

    10337. 

  10337.                 if (!(result.TypeOperand == typeop)) return 1;

    10338. 

  10338. 

    10339. 

  10339.                 if (!(result.ToString() == str))

    10340. 

  10340.                 {

    10341. 

  10341.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    10342. 

  10342.                     return 1;

    10343. 

  10343.                 }

    10344. 

  10344. 

    10345. 

  10345.                 return 0;

    10346. 

  10346.             }

    10347. 

  10347. 

    10348. 

  10348.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    10349. 

  10349.             {

    10350. 

  10350.                 if (!(result.NodeType == et))

    10351. 

  10351.                 {

    10352. 

  10352.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10353. 

  10353.                     return 1;

    10354. 

  10354.                 }

    10355. 

  10355.                 if (!(result.Type == type))

    10356. 

  10356.                 {

    10357. 

  10357.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10358. 

  10358.                     return 1;

    10359. 

  10359.                 }

    10360. 

  10360. 

    10361. 

  10361.                 if (test == null)

    10362. 

  10362.                 {

    10363. 

  10363.                     if (result.Test != null) return 1;

    10364. 

  10364.                 }

    10365. 

  10365.                 else

    10366. 

  10366.                 {

    10367. 

  10367.                     if (!(result.Test.Equals(test))) return 1;

    10368. 

  10368.                 }

    10369. 

  10369. 

    10370. 

  10370.                 if (ifTrue == null)

    10371. 

  10371.                 {

    10372. 

  10372.                     if (result.IfTrue != null) return 1;

    10373. 

  10373.                 }

    10374. 

  10374.                 else

    10375. 

  10375.                 {

    10376. 

  10376.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    10377. 

  10377.                 }

    10378. 

  10378. 

    10379. 

  10379.                 if (ifFalse == null)

    10380. 

  10380.                 {

    10381. 

  10381.                     if (result.IfFalse != null) return 1;

    10382. 

  10382.                 }

    10383. 

  10383.                 else

    10384. 

  10384.                 {

    10385. 

  10385.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    10386. 

  10386.                 }

    10387. 

  10387. 

    10388. 

  10388.                 if (!(result.ToString() == str)) return 1;

    10389. 

  10389. 

    10390. 

  10390.                 return 0;

    10391. 

  10391.             }

    10392. 

  10392. 

    10393. 

  10393.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    10394. 

  10394.             {

    10395. 

  10395.                 if (!(result.NodeType == et))

    10396. 

  10396.                 {

    10397. 

  10397.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10398. 

  10398.                     return 1;

    10399. 

  10399.                 }

    10400. 

  10400.                 if (!(result.Type == type))

    10401. 

  10401.                 {

    10402. 

  10402.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10403. 

  10403.                     return 1;

    10404. 

  10404.                 }

    10405. 

  10405. 

    10406. 

  10406.                 if (exp_expr == null)

    10407. 

  10407.                 {

    10408. 

  10408.                     if (result.Expression != null)

    10409. 

  10409.                     {

    10410. 

  10410.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    10411. 

  10411.                         return 1;

    10412. 

  10412.                     }

    10413. 

  10413.                 }

    10414. 

  10414.                 else

    10415. 

  10415.                 {

    10416. 

  10416.                     if (!(result.Expression.Equals(exp_expr)))

    10417. 

  10417.                     {

    10418. 

  10418.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    10419. 

  10419.                         return 1;

    10420. 

  10420.                     }

    10421. 

  10421.                 }

    10422. 

  10422. 

    10423. 

  10423.                 if (!(result.Member == exp_member))

    10424. 

  10424.                 {

    10425. 

  10425.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    10426. 

  10426.                     return 1;

    10427. 

  10427.                 }

    10428. 

  10428. 

    10429. 

  10429.                 if (!(result.ToString() == str))

    10430. 

  10430.                 {

    10431. 

  10431.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10432. 

  10432.                     return 1;

    10433. 

  10433.                 }

    10434. 

  10434. 

    10435. 

  10435.                 return 0;

    10436. 

  10436.             }

    10437. 

  10437. 

    10438. 

  10438.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    10439. 

  10439.             {

    10440. 

  10440.                 if (!(result.NodeType == et))

    10441. 

  10441.                 {

    10442. 

  10442.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10443. 

  10443.                     return 1;

    10444. 

  10444.                 }

    10445. 

  10445.                 if (!(result.Type == type))

    10446. 

  10446.                 {

    10447. 

  10447.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10448. 

  10448.                     return 1;

    10449. 

  10449.                 }

    10450. 

  10450. 

    10451. 

  10451.                 if (!(result.Constructor == constructor))

    10452. 

  10452.                 {

    10453. 

  10453.                     Console.WriteLine("Unexpected constructor");

    10454. 

  10454.                     return 1;

    10455. 

  10455.                 }

    10456. 

  10456. 

    10457. 

  10457.                 if (!(result.ToString() == str))

    10458. 

  10458.                 {

    10459. 

  10459.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10460. 

  10460.                     return 1;

    10461. 

  10461.                 }

    10462. 

  10462. 

    10463. 

  10463.                 if (arguments == null)

    10464. 

  10464.                 {

    10465. 

  10465.                     if (result.Arguments.Count != 0)

    10466. 

  10466.                     {

    10467. 

  10467.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    10468. 

  10468.                         return 1;

    10469. 

  10469.                     }

    10470. 

  10470.                 }

    10471. 

  10471.                 else

    10472. 

  10472.                 {

    10473. 

  10473.                     if (result.Arguments.Count != arguments.Length)

    10474. 

  10474.                     {

    10475. 

  10475.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    10476. 

  10476.                         return 1;

    10477. 

  10477.                     }

    10478. 

  10478.                     for (int i = 0; i < arguments.Length; i++)

    10479. 

  10479.                     {

    10480. 

  10480.                         if (result.Arguments[i] != arguments[i])

    10481. 

  10481.                         {

    10482. 

  10482.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    10483. 

  10483.                             return 1;

    10484. 

  10484.                         }

    10485. 

  10485.                     }

    10486. 

  10486.                 }

    10487. 

  10487. 

    10488. 

  10488.                 if (result.Members == null)

    10489. 

  10489.                 {

    10490. 

  10490.                     Console.WriteLine("result.Members was null");

    10491. 

  10491.                     return 1;

    10492. 

  10492.                 }

    10493. 

  10493. 

    10494. 

  10494.                 if (members == null)

    10495. 

  10495.                 {

    10496. 

  10496.                     if (result.Members.Count != 0)

    10497. 

  10497.                     {

    10498. 

  10498.                         Console.WriteLine("Got more than zero members");

    10499. 

  10499.                         return 1;

    10500. 

  10500.                     }

    10501. 

  10501.                 }

    10502. 

  10502.                 else

    10503. 

  10503.                 {

    10504. 

  10504.                     if (result.Members.Count != members.Length)

    10505. 

  10505.                     {

    10506. 

  10506.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    10507. 

  10507.                         return 1;

    10508. 

  10508.                     }

    10509. 

  10509. 

    10510. 

  10510.                     for (int i = 0; i < members.Length; i++)

    10511. 

  10511.                     {

    10512. 

  10512.                         if (result.Members[i] != members[i])

    10513. 

  10513.                         {

    10514. 

  10514.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    10515. 

  10515.                             return 1;

    10516. 

  10516.                         }

    10517. 

  10517.                     }

    10518. 

  10518.                 }

    10519. 

  10519. 

    10520. 

  10520.                 return 0;

    10521. 

  10521.             }

    10522. 

  10522. 

    10523. 

  10523.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    10524. 

  10524.             {

    10525. 

  10525.                 if (!(result.NodeType == et))

    10526. 

  10526.                 {

    10527. 

  10527.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10528. 

  10528.                     return 1;

    10529. 

  10529.                 }

    10530. 

  10530.                 if (!(result.Type == type))

    10531. 

  10531.                 {

    10532. 

  10532.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10533. 

  10533.                     return 1;

    10534. 

  10534.                 }

    10535. 

  10535. 

    10536. 

  10536.                 if (!(result.Constructor == constructor))

    10537. 

  10537.                 {

    10538. 

  10538.                     Console.WriteLine("Constructor is different from expected.");

    10539. 

  10539.                     return 1;

    10540. 

  10540.                 }

    10541. 

  10541. 

    10542. 

  10542.                 if (!(result.ToString() == str))

    10543. 

  10543.                 {

    10544. 

  10544.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10545. 

  10545.                     return 1;

    10546. 

  10546.                 }

    10547. 

  10547. 

    10548. 

  10548.                 if (result.Arguments.Count != arguments.Length)

    10549. 

  10549.                 {

    10550. 

  10550.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    10551. 

  10551.                     return 1;

    10552. 

  10552.                 }

    10553. 

  10553. 

    10554. 

  10554.                 for (int i = 0; i < arguments.Length; i++)

    10555. 

  10555.                 {

    10556. 

  10556.                     if (result.Arguments[i] != arguments[i])

    10557. 

  10557.                     {

    10558. 

  10558.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    10559. 

  10559.                         return 1;

    10560. 

  10560.                     }

    10561. 

  10561.                 }

    10562. 

  10562. 

    10563. 

  10563.                 if (result.Members != null)

    10564. 

  10564.                 {

    10565. 

  10565.                     Console.WriteLine("result.Members isn't null");

    10566. 

  10566.                     return 1;

    10567. 

  10567.                 }

    10568. 

  10568. 

    10569. 

  10569.                 return 0;

    10570. 

  10570.             }

    10571. 

  10571. 

    10572. 

  10572.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    10573. 

  10573.             {

    10574. 

  10574.                 if (!(result.NodeType == et))

    10575. 

  10575.                 {

    10576. 

  10576.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10577. 

  10577.                     return 1;

    10578. 

  10578.                 }

    10579. 

  10579.                 if (!(result.Type == type))

    10580. 

  10580.                 {

    10581. 

  10581.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10582. 

  10582.                     return 1;

    10583. 

  10583.                 }

    10584. 

  10584. 

    10585. 

  10585.                 if (!(result.NewExpression == newExpression)) return 1;

    10586. 

  10586. 

    10587. 

  10587.                 if (!(result.ToString() == str))

    10588. 

  10588.                 {

    10589. 

  10589.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10590. 

  10590.                     return 1;

    10591. 

  10591.                 }

    10592. 

  10592. 

    10593. 

  10593.                 if (result.Initializers.Count != initializers.Length) return 1;

    10594. 

  10594. 

    10595. 

  10595.                 for (int i = 0; i < initializers.Length; i++)

    10596. 

  10596.                 {

    10597. 

  10597.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    10598. 

  10598. 

    10599. 

  10599.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    10600. 

  10600. 

    10601. 

  10601.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    10602. 

  10602.                     {

    10603. 

  10603.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    10604. 

  10604.                     }

    10605. 

  10605.                 }

    10606. 

  10606. 

    10607. 

  10607.                 return 0;

    10608. 

  10608.             }

    10609. 

  10609. 

    10610. 

  10610.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    10611. 

  10611.             {

    10612. 

  10612.                 if (result.AddMethod != exp_mi) return 1;

    10613. 

  10613.                 if (!(result.ToString() == str))

    10614. 

  10614.                 {

    10615. 

  10615.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10616. 

  10616.                     return 1;

    10617. 

  10617.                 }

    10618. 

  10618. 

    10619. 

  10619.                 if (result.Arguments.Count != args.Length) return 1;

    10620. 

  10620. 

    10621. 

  10621.                 for (int i = 0; i < args.Length; i++)

    10622. 

  10622.                 {

    10623. 

  10623.                     if (result.Arguments[i] != args[i]) return 1;

    10624. 

  10624.                 }

    10625. 

  10625. 

    10626. 

  10626.                 return 0;

    10627. 

  10627.             }

    10628. 

  10628. 

    10629. 

  10629.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    10630. 

  10630.             {

    10631. 

  10631.                 if (!(result.BindingType == bt)) return 1;

    10632. 

  10632.                 if (!(result.Expression == expr)) return 1;

    10633. 

  10633.                 if (!(result.Member.Equals(member))) return 1;

    10634. 

  10634.                 if (!(result.ToString() == str))

    10635. 

  10635.                 {

    10636. 

  10636.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10637. 

  10637.                     return 1;

    10638. 

  10638.                 }

    10639. 

  10639. 

    10640. 

  10640.                 return 0;

    10641. 

  10641.             }

    10642. 

  10642. 

    10643. 

  10643.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    10644. 

  10644.             {

    10645. 

  10645.                 if (!(result.BindingType == bt)) return 1;

    10646. 

  10646. 

    10647. 

  10647.                 if (!(result.Member.Equals(member))) return 1;

    10648. 

  10648.                 if (!(result.ToString() == str))

    10649. 

  10649.                 {

    10650. 

  10650.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10651. 

  10651.                     return 1;

    10652. 

  10652.                 }

    10653. 

  10653. 

    10654. 

  10654.                 if (result.Initializers.Count != initializers.Length) return 1;

    10655. 

  10655. 

    10656. 

  10656.                 for (int i = 0; i < initializers.Length; i++)

    10657. 

  10657.                 {

    10658. 

  10658.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    10659. 

  10659. 

    10660. 

  10660.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    10661. 

  10661. 

    10662. 

  10662.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    10663. 

  10663.                     {

    10664. 

  10664.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    10665. 

  10665.                     }

    10666. 

  10666.                 }

    10667. 

  10667. 

    10668. 

  10668. 

    10669. 

  10669.                 return 0;

    10670. 

  10670.             }

    10671. 

  10671. 

    10672. 

  10672.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    10673. 

  10673.             {

    10674. 

  10674.                 if (!(result.BindingType == bt)) return 1;

    10675. 

  10675. 

    10676. 

  10676.                 if (!(result.Member.Equals(member))) return 1;

    10677. 

  10677.                 if (!(result.ToString() == str))

    10678. 

  10678.                 {

    10679. 

  10679.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10680. 

  10680.                     return 1;

    10681. 

  10681.                 }

    10682. 

  10682. 

    10683. 

  10683.                 if (result.Bindings.Count != bindings.Length) return 1;

    10684. 

  10684. 

    10685. 

  10685.                 for (int i = 0; i < bindings.Length; i++)

    10686. 

  10686.                 {

    10687. 

  10687.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    10688. 

  10688.                 }

    10689. 

  10689. 

    10690. 

  10690.                 return 0;

    10691. 

  10691.             }

    10692. 

  10692. 

    10693. 

  10693.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    10694. 

  10694.             {

    10695. 

  10695.                 if (!(result.NodeType == et))

    10696. 

  10696.                 {

    10697. 

  10697.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10698. 

  10698.                     return 1;

    10699. 

  10699.                 }

    10700. 

  10700.                 if (!(result.Type == type))

    10701. 

  10701.                 {

    10702. 

  10702.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10703. 

  10703.                     return 1;

    10704. 

  10704.                 }

    10705. 

  10705.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    10706. 

  10706.                 if (!(result.ToString() == str)) return 1;

    10707. 

  10707. 

    10708. 

  10708.                 if (result.Bindings.Count != bindings.Length) return 1;

    10709. 

  10709. 

    10710. 

  10710.                 for (int i = 0; i < bindings.Length; i++)

    10711. 

  10711.                 {

    10712. 

  10712.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    10713. 

  10713.                 }

    10714. 

  10714. 

    10715. 

  10715.                 return 0;

    10716. 

  10716.             }

    10717. 

  10717. 

    10718. 

  10718.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    10719. 

  10719.             {

    10720. 

  10720.                 if (!(result.NodeType == et))

    10721. 

  10721.                 {

    10722. 

  10722.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10723. 

  10723.                     return 1;

    10724. 

  10724.                 }

    10725. 

  10725.                 if (!(result.Type == type))

    10726. 

  10726.                 {

    10727. 

  10727.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10728. 

  10728.                     return 1;

    10729. 

  10729.                 }

    10730. 

  10730. 

    10731. 

  10731.                 if (result.Expressions.Count != expr.Length) return 1;

    10732. 

  10732. 

    10733. 

  10733.                 for (int i = 0; i < expr.Length; i++)

    10734. 

  10734.                 {

    10735. 

  10735.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    10736. 

  10736.                 }

    10737. 

  10737.                 if (!(result.ToString() == str))

    10738. 

  10738.                 {

    10739. 

  10739.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10740. 

  10740.                     return 1;

    10741. 

  10741.                 }

    10742. 

  10742. 

    10743. 

  10743.                 return 0;

    10744. 

  10744.             }

    10745. 

  10745. 

    10746. 

  10746.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    10747. 

  10747.             {

    10748. 

  10748.                 if (!(result.NodeType == et))

    10749. 

  10749.                 {

    10750. 

  10750.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10751. 

  10751.                     return 1;

    10752. 

  10752.                 }

    10753. 

  10753.                 if (!(result.Type == type))

    10754. 

  10754.                 {

    10755. 

  10755.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10756. 

  10756.                     return 1;

    10757. 

  10757.                 }

    10758. 

  10758.                 if (!(result.Name == name)) return 1;

    10759. 

  10759. 

    10760. 

  10760.                 if (!(result.ToString() == str))

    10761. 

  10761.                 {

    10762. 

  10762.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10763. 

  10763.                     return 1;

    10764. 

  10764.                 }

    10765. 

  10765. 

    10766. 

  10766.                 return 0;

    10767. 

  10767.             }

    10768. 

  10768. 

    10769. 

  10769.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    10770. 

  10770.             {

    10771. 

  10771.                 if (!(result.NodeType == et))

    10772. 

  10772.                 {

    10773. 

  10773.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10774. 

  10774.                     return 1;

    10775. 

  10775.                 }

    10776. 

  10776.                 if (!(result.Type == type))

    10777. 

  10777.                 {

    10778. 

  10778.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10779. 

  10779.                     return 1;

    10780. 

  10780.                 }

    10781. 

  10781. 

    10782. 

  10782.                 if (expr == null)

    10783. 

  10783.                 {

    10784. 

  10784.                     if (result.Body != null) return 1;

    10785. 

  10785.                 }

    10786. 

  10786.                 else

    10787. 

  10787.                 {

    10788. 

  10788.                     if (!(result.Body.Equals(expr))) return 1;

    10789. 

  10789.                 }

    10790. 

  10790. 

    10791. 

  10791.                 if (result.Parameters.Count != parms.Length) return 1;

    10792. 

  10792. 

    10793. 

  10793.                 for (int i = 0; i < parms.Length; i++)

    10794. 

  10794.                 {

    10795. 

  10795.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    10796. 

  10796.                 }

    10797. 

  10797. 

    10798. 

  10798.                 if (!(result.ToString() == str))

    10799. 

  10799.                 {

    10800. 

  10800.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    10801. 

  10801.                     return 1;

    10802. 

  10802.                 }

    10803. 

  10803. 

    10804. 

  10804.                 return 0;

    10805. 

  10805.             }

    10806. 

  10806. 

    10807. 

  10807.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    10808. 

  10808.             {

    10809. 

  10809.                 if (!(result.NodeType == et))

    10810. 

  10810.                 {

    10811. 

  10811.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10812. 

  10812.                     return 1;

    10813. 

  10813.                 }

    10814. 

  10814.                 if (!(result.Type == type))

    10815. 

  10815.                 {

    10816. 

  10816.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10817. 

  10817.                     return 1;

    10818. 

  10818.                 }

    10819. 

  10819. 

    10820. 

  10820.                 if (expr == null)

    10821. 

  10821.                 {

    10822. 

  10822.                     if (result.Expression != null) return 1;

    10823. 

  10823.                 }

    10824. 

  10824.                 else

    10825. 

  10825.                 {

    10826. 

  10826.                     if (!(result.Expression.Equals(expr))) return 1;

    10827. 

  10827.                 }

    10828. 

  10828. 

    10829. 

  10829.                 if (result.Arguments.Count != args.Length) return 1;

    10830. 

  10830. 

    10831. 

  10831.                 for (int i = 0; i < args.Length; i++)

    10832. 

  10832.                 {

    10833. 

  10833.                     if (!(result.Arguments[i].Equals(args[i])))

    10834. 

  10834.                     {

    10835. 

  10835.                         return 1;

    10836. 

  10836.                     }

    10837. 

  10837.                 }

    10838. 

  10838. 

    10839. 

  10839.                 if (result.ToString() != str)

    10840. 

  10840.                 {

    10841. 

  10841.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    10842. 

  10842.                     return 1;

    10843. 

  10843.                 }

    10844. 

  10844. 

    10845. 

  10845.                 return 0;

    10846. 

  10846.             }

    10847. 

  10847.         }

    10848. 

  10848. 

    10849. 

  10849. 

    10850. 

  10850. 

    10851. 

  10851.         namespace Not

    10852. 

  10852.         {

    10853. 

  10853.             // Declaring user-defined types for testing

    10854. 

  10854.             struct TC1

    10855. 

  10855.             {

    10856. 

  10856.                 public static TC1 operator !(TC1 c)

    10857. 

  10857.                 {

    10858. 

  10858.                     return new TC1();

    10859. 

  10859.                 }

    10860. 

  10860. 

    10861. 

  10861.                 public static TC1 operator ~(TC1 c)

    10862. 

  10862.                 {

    10863. 

  10863.                     return new TC1();

    10864. 

  10864.                 }

    10865. 

  10865.             }

    10866. 

  10866. 

    10867. 

  10867.             struct TC2

    10868. 

  10868.             {

    10869. 

  10869.                 public static TC2 operator ~(TC2 c)

    10870. 

  10870.                 {

    10871. 

  10871.                     return new TC2();

    10872. 

  10872.                 }

    10873. 

  10873.             }

    10874. 

  10874. 

    10875. 

  10875.             struct TC3

    10876. 

  10876.             {

    10877. 

  10877.                 public static TC3 Meth1(TC3 c)

    10878. 

  10878.                 {

    10879. 

  10879.                     return new TC3();

    10880. 

  10880.                 }

    10881. 

  10881.             }

    10882. 

  10882.         }

    10883. 

  10883. 

    10884. 

  10884.     }

    10885. 

  10885. 

    10886. 

  10886.     //-------- Scenario 795

    10887. 

  10887.     namespace Scenario795

    10888. 

  10888.     {

    10889. 

  10889. 

    10890. 

  10890.         namespace Not

    10891. 

  10891.         {

    10892. 

  10892.             public class Test

    10893. 

  10893.             {

    10894. 

  10894.                 // Overload-2: Expression is null and MethodInfo is non-null

    10895. 

  10895.                 public static int Test13b()

    10896. 

  10896.                 {

    10897. 

  10897.                     TC3 ctest = new TC3();

    10898. 

  10898.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC3));

    10899. 

  10899.                     MethodInfo exp_mi = typeof(TC3).GetMethod("Meth1");

    10900. 

  10900. 

    10901. 

  10901.                     try

    10902. 

  10902.                     {

    10903. 

  10903.                         ce = null;

    10904. 

  10904.                         UnaryExpression result = Expression.Not(ce, exp_mi);

    10905. 

  10905.                         return 1;

    10906. 

  10906.                     }

    10907. 

  10907.                     catch (ArgumentNullException ane)

    10908. 

  10908.                     {

    10909. 

  10909.                         if (!ane.CompareParamName("expression")) return 1;

    10910. 

  10910.                         return 0;

    10911. 

  10911.                     }

    10912. 

  10912.                 }

    10913. 

  10913. 

    10914. 

  10914. 

    10915. 

  10915.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not13b__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    10916. 

  10916.                 public static Expression Not13b__()

    10917. 

  10917.                 {

    10918. 

  10918.                     if (Main() != 0)

    10919. 

  10919.                     {

    10920. 

  10920.                         throw new Exception();

    10921. 

  10921.                     }

    10922. 

  10922.                     else

    10923. 

  10923.                     {

    10924. 

  10924.                         return Expression.Constant(0);

    10925. 

  10925.                     }

    10926. 

  10926.                 }

    10927. 

  10927.                 public static int Main()

    10928. 

  10928.                 {

    10929. 

  10929.                     return Test13b();

    10930. 

  10930.                 }

    10931. 

  10931.             }

    10932. 

  10932.         }

    10933. 

  10933. 

    10934. 

  10934. 

    10935. 

  10935. 

    10936. 

  10936.         public static class Extension

    10937. 

  10937.         {

    10938. 

  10938.             public static bool CompareParamName(this ArgumentException ex, string expected)

    10939. 

  10939.             {

    10940. 

  10940. #if SILVERLIGHT

    10941. 

  10941. #if SLRESOURCES

    10942. 

  10942. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    10943. 

  10943. #else

    10944. 

  10944. 				        return true;

    10945. 

  10945. #endif

    10946. 

  10946. #else

    10947. 

  10947.                 return ex.ParamName == expected;

    10948. 

  10948. #endif

    10949. 

  10949.             }

    10950. 

  10950. 

    10951. 

  10951.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    10952. 

  10952.             {

    10953. 

  10953. #if SILVERLIGHT

    10954. 

  10954. #if SLRESOURCES

    10955. 

  10955. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    10956. 

  10956. #else

    10957. 

  10957. 				        return true;

    10958. 

  10958. #endif

    10959. 

  10959. #else

    10960. 

  10960.                 return ex.ParamName == expected;

    10961. 

  10961. #endif

    10962. 

  10962.             }

    10963. 

  10963.         }

    10964. 

  10964. 

    10965. 

  10965.         public static class Verification

    10966. 

  10966.         {

    10967. 

  10967.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    10968. 

  10968.             {

    10969. 

  10969.                 if (!(result.NodeType == et))

    10970. 

  10970.                 {

    10971. 

  10971.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10972. 

  10972.                     return 1;

    10973. 

  10973.                 }

    10974. 

  10974.                 if (!(result.Type == type))

    10975. 

  10975.                 {

    10976. 

  10976.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    10977. 

  10977.                     return 1;

    10978. 

  10978.                 }

    10979. 

  10979.                 if (val == null)

    10980. 

  10980.                 {

    10981. 

  10981.                     if (result.Value != null) return 1;

    10982. 

  10982.                 }

    10983. 

  10983.                 else

    10984. 

  10984.                 {

    10985. 

  10985.                     if (!(result.Value.Equals(val))) return 1;

    10986. 

  10986.                 }

    10987. 

  10987.                 if (!(result.ToString() == str)) return 1;

    10988. 

  10988.                 return 0;

    10989. 

  10989.             }

    10990. 

  10990. 

    10991. 

  10991.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    10992. 

  10992.             {

    10993. 

  10993.                 if (!(result.NodeType == et))

    10994. 

  10994.                 {

    10995. 

  10995.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    10996. 

  10996.                     return 1;

    10997. 

  10997.                 }

    10998. 

  10998.                 if (!(result.Type == type))

    10999. 

  10999.                 {

    11000. 

  11000.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11001. 

  11001.                     return 1;

    11002. 

  11002.                 }

    11003. 

  11003.                 if (operand == null)

    11004. 

  11004.                 {

    11005. 

  11005.                     if (result.Operand != null) return 1;

    11006. 

  11006.                 }

    11007. 

  11007.                 else

    11008. 

  11008.                 {

    11009. 

  11009.                     if (!(result.Operand.Equals(operand))) return 1;

    11010. 

  11010.                 }

    11011. 

  11011.                 if (!(result.ToString() == str))

    11012. 

  11012.                 {

    11013. 

  11013.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11014. 

  11014.                     return 1;

    11015. 

  11015.                 }

    11016. 

  11016. 

    11017. 

  11017.                 if (result.Method != mi) return 1;

    11018. 

  11018.                 if (result.IsLifted != islifted) return 1;

    11019. 

  11019.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11020. 

  11020. 

    11021. 

  11021.                 return 0;

    11022. 

  11022.             }

    11023. 

  11023. 

    11024. 

  11024.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    11025. 

  11025.             {

    11026. 

  11026.                 if (!(result.NodeType == et))

    11027. 

  11027.                 {

    11028. 

  11028.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11029. 

  11029.                     return 1;

    11030. 

  11030.                 }

    11031. 

  11031.                 if (!(result.Type == type))

    11032. 

  11032.                 {

    11033. 

  11033.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11034. 

  11034.                     return 1;

    11035. 

  11035.                 }

    11036. 

  11036. 

    11037. 

  11037.                 if (left == null)

    11038. 

  11038.                 {

    11039. 

  11039.                     if (result.Left != null)

    11040. 

  11040.                     {

    11041. 

  11041.                         Console.WriteLine("left was null");

    11042. 

  11042.                         return 1;

    11043. 

  11043.                     }

    11044. 

  11044.                 }

    11045. 

  11045.                 else

    11046. 

  11046.                 {

    11047. 

  11047.                     if (!(result.Left.Equals(left)))

    11048. 

  11048.                     {

    11049. 

  11049.                         Console.WriteLine("left was different");

    11050. 

  11050.                         return 1;

    11051. 

  11051.                     }

    11052. 

  11052.                 }

    11053. 

  11053. 

    11054. 

  11054.                 if (right == null)

    11055. 

  11055.                 {

    11056. 

  11056.                     if (result.Right != null) return 1;

    11057. 

  11057.                 }

    11058. 

  11058.                 else

    11059. 

  11059.                 {

    11060. 

  11060.                     if (!(result.Right.Equals(right))) return 1;

    11061. 

  11061.                 }

    11062. 

  11062. 

    11063. 

  11063.                 if (!(result.ToString() == str))

    11064. 

  11064.                 {

    11065. 

  11065.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11066. 

  11066.                     return 1;

    11067. 

  11067.                 }

    11068. 

  11068. 

    11069. 

  11069.                 if (result.Method != mi) return 1;

    11070. 

  11070.                 if (result.IsLifted != islifted) return 1;

    11071. 

  11071.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11072. 

  11072. 

    11073. 

  11073.                 if (result.Conversion != null) return 1;

    11074. 

  11074. 

    11075. 

  11075.                 return 0;

    11076. 

  11076.             }

    11077. 

  11077. 

    11078. 

  11078.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    11079. 

  11079.             {

    11080. 

  11080.                 if (!(result.NodeType == et))

    11081. 

  11081.                 {

    11082. 

  11082.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11083. 

  11083.                     return 1;

    11084. 

  11084.                 }

    11085. 

  11085.                 if (!(result.Type == type))

    11086. 

  11086.                 {

    11087. 

  11087.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11088. 

  11088.                     return 1;

    11089. 

  11089.                 }

    11090. 

  11090. 

    11091. 

  11091.                 if (left == null)

    11092. 

  11092.                 {

    11093. 

  11093.                     if (result.Left != null) return 1;

    11094. 

  11094.                 }

    11095. 

  11095.                 else

    11096. 

  11096.                 {

    11097. 

  11097.                     if (!(result.Left.Equals(left))) return 1;

    11098. 

  11098.                 }

    11099. 

  11099. 

    11100. 

  11100.                 if (right == null)

    11101. 

  11101.                 {

    11102. 

  11102.                     if (result.Right != null) return 1;

    11103. 

  11103.                 }

    11104. 

  11104.                 else

    11105. 

  11105.                 {

    11106. 

  11106.                     if (!(result.Right.Equals(right))) return 1;

    11107. 

  11107.                 }

    11108. 

  11108. 

    11109. 

  11109.                 if (!(result.ToString() == str)) return 1;

    11110. 

  11110. 

    11111. 

  11111.                 if (result.Method != mi) return 1;

    11112. 

  11112.                 if (result.IsLifted != islifted) return 1;

    11113. 

  11113.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11114. 

  11114. 

    11115. 

  11115.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    11116. 

  11116. 

    11117. 

  11117.                 return 0;

    11118. 

  11118.             }

    11119. 

  11119. 

    11120. 

  11120.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    11121. 

  11121.             {

    11122. 

  11122.                 if (!(result.NodeType == et))

    11123. 

  11123.                 {

    11124. 

  11124.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11125. 

  11125.                     return 1;

    11126. 

  11126.                 }

    11127. 

  11127.                 if (!(result.Type == type))

    11128. 

  11128.                 {

    11129. 

  11129.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11130. 

  11130.                     return 1;

    11131. 

  11131.                 }

    11132. 

  11132. 

    11133. 

  11133.                 if (!(result.Method == method)) return 1;

    11134. 

  11134. 

    11135. 

  11135.                 if (obj == null)

    11136. 

  11136.                 {

    11137. 

  11137.                     if (result.Object != null)

    11138. 

  11138.                     {

    11139. 

  11139.                         Console.WriteLine("Expected object to be null.");

    11140. 

  11140.                         return 1;

    11141. 

  11141.                     }

    11142. 

  11142.                 }

    11143. 

  11143.                 else

    11144. 

  11144.                 {

    11145. 

  11145.                     if (!(result.Object.Equals(obj)))

    11146. 

  11146.                     {

    11147. 

  11147.                         Console.WriteLine("Object on which call is made is different from the result.");

    11148. 

  11148.                         return 1;

    11149. 

  11149.                     }

    11150. 

  11150.                 }

    11151. 

  11151. 

    11152. 

  11152.                 if (!(result.ToString() == str))

    11153. 

  11153.                 {

    11154. 

  11154.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11155. 

  11155.                     return 1;

    11156. 

  11156.                 }

    11157. 

  11157. 

    11158. 

  11158.                 if (result.Arguments.Count != arguments.Length) return 1;

    11159. 

  11159. 

    11160. 

  11160.                 for (int i = 0; i < arguments.Length; i++)

    11161. 

  11161.                 {

    11162. 

  11162.                     if (result.Arguments[i] != arguments[i]) return 1;

    11163. 

  11163.                 }

    11164. 

  11164. 

    11165. 

  11165.                 return 0;

    11166. 

  11166.             }

    11167. 

  11167. 

    11168. 

  11168.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    11169. 

  11169.             {

    11170. 

  11170.                 if (!(result.NodeType == et))

    11171. 

  11171.                 {

    11172. 

  11172.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11173. 

  11173.                     return 1;

    11174. 

  11174.                 }

    11175. 

  11175.                 if (!(result.Type == type))

    11176. 

  11176.                 {

    11177. 

  11177.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11178. 

  11178.                     return 1;

    11179. 

  11179.                 }

    11180. 

  11180. 

    11181. 

  11181.                 if (expr == null)

    11182. 

  11182.                 {

    11183. 

  11183.                     Console.WriteLine("expr was null.");

    11184. 

  11184.                     if (result.Expression != null) return 1;

    11185. 

  11185.                 }

    11186. 

  11186.                 else

    11187. 

  11187.                 {

    11188. 

  11188.                     if (!(result.Expression.Equals(expr)))

    11189. 

  11189.                     {

    11190. 

  11190.                         return 1;

    11191. 

  11191.                     }

    11192. 

  11192.                 }

    11193. 

  11193. 

    11194. 

  11194.                 if (!(result.TypeOperand == typeop)) return 1;

    11195. 

  11195. 

    11196. 

  11196.                 if (!(result.ToString() == str))

    11197. 

  11197.                 {

    11198. 

  11198.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11199. 

  11199.                     return 1;

    11200. 

  11200.                 }

    11201. 

  11201. 

    11202. 

  11202.                 return 0;

    11203. 

  11203.             }

    11204. 

  11204. 

    11205. 

  11205.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    11206. 

  11206.             {

    11207. 

  11207.                 if (!(result.NodeType == et))

    11208. 

  11208.                 {

    11209. 

  11209.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11210. 

  11210.                     return 1;

    11211. 

  11211.                 }

    11212. 

  11212.                 if (!(result.Type == type))

    11213. 

  11213.                 {

    11214. 

  11214.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11215. 

  11215.                     return 1;

    11216. 

  11216.                 }

    11217. 

  11217. 

    11218. 

  11218.                 if (test == null)

    11219. 

  11219.                 {

    11220. 

  11220.                     if (result.Test != null) return 1;

    11221. 

  11221.                 }

    11222. 

  11222.                 else

    11223. 

  11223.                 {

    11224. 

  11224.                     if (!(result.Test.Equals(test))) return 1;

    11225. 

  11225.                 }

    11226. 

  11226. 

    11227. 

  11227.                 if (ifTrue == null)

    11228. 

  11228.                 {

    11229. 

  11229.                     if (result.IfTrue != null) return 1;

    11230. 

  11230.                 }

    11231. 

  11231.                 else

    11232. 

  11232.                 {

    11233. 

  11233.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    11234. 

  11234.                 }

    11235. 

  11235. 

    11236. 

  11236.                 if (ifFalse == null)

    11237. 

  11237.                 {

    11238. 

  11238.                     if (result.IfFalse != null) return 1;

    11239. 

  11239.                 }

    11240. 

  11240.                 else

    11241. 

  11241.                 {

    11242. 

  11242.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    11243. 

  11243.                 }

    11244. 

  11244. 

    11245. 

  11245.                 if (!(result.ToString() == str)) return 1;

    11246. 

  11246. 

    11247. 

  11247.                 return 0;

    11248. 

  11248.             }

    11249. 

  11249. 

    11250. 

  11250.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    11251. 

  11251.             {

    11252. 

  11252.                 if (!(result.NodeType == et))

    11253. 

  11253.                 {

    11254. 

  11254.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11255. 

  11255.                     return 1;

    11256. 

  11256.                 }

    11257. 

  11257.                 if (!(result.Type == type))

    11258. 

  11258.                 {

    11259. 

  11259.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11260. 

  11260.                     return 1;

    11261. 

  11261.                 }

    11262. 

  11262. 

    11263. 

  11263.                 if (exp_expr == null)

    11264. 

  11264.                 {

    11265. 

  11265.                     if (result.Expression != null)

    11266. 

  11266.                     {

    11267. 

  11267.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    11268. 

  11268.                         return 1;

    11269. 

  11269.                     }

    11270. 

  11270.                 }

    11271. 

  11271.                 else

    11272. 

  11272.                 {

    11273. 

  11273.                     if (!(result.Expression.Equals(exp_expr)))

    11274. 

  11274.                     {

    11275. 

  11275.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    11276. 

  11276.                         return 1;

    11277. 

  11277.                     }

    11278. 

  11278.                 }

    11279. 

  11279. 

    11280. 

  11280.                 if (!(result.Member == exp_member))

    11281. 

  11281.                 {

    11282. 

  11282.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    11283. 

  11283.                     return 1;

    11284. 

  11284.                 }

    11285. 

  11285. 

    11286. 

  11286.                 if (!(result.ToString() == str))

    11287. 

  11287.                 {

    11288. 

  11288.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11289. 

  11289.                     return 1;

    11290. 

  11290.                 }

    11291. 

  11291. 

    11292. 

  11292.                 return 0;

    11293. 

  11293.             }

    11294. 

  11294. 

    11295. 

  11295.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    11296. 

  11296.             {

    11297. 

  11297.                 if (!(result.NodeType == et))

    11298. 

  11298.                 {

    11299. 

  11299.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11300. 

  11300.                     return 1;

    11301. 

  11301.                 }

    11302. 

  11302.                 if (!(result.Type == type))

    11303. 

  11303.                 {

    11304. 

  11304.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11305. 

  11305.                     return 1;

    11306. 

  11306.                 }

    11307. 

  11307. 

    11308. 

  11308.                 if (!(result.Constructor == constructor))

    11309. 

  11309.                 {

    11310. 

  11310.                     Console.WriteLine("Unexpected constructor");

    11311. 

  11311.                     return 1;

    11312. 

  11312.                 }

    11313. 

  11313. 

    11314. 

  11314.                 if (!(result.ToString() == str))

    11315. 

  11315.                 {

    11316. 

  11316.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11317. 

  11317.                     return 1;

    11318. 

  11318.                 }

    11319. 

  11319. 

    11320. 

  11320.                 if (arguments == null)

    11321. 

  11321.                 {

    11322. 

  11322.                     if (result.Arguments.Count != 0)

    11323. 

  11323.                     {

    11324. 

  11324.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    11325. 

  11325.                         return 1;

    11326. 

  11326.                     }

    11327. 

  11327.                 }

    11328. 

  11328.                 else

    11329. 

  11329.                 {

    11330. 

  11330.                     if (result.Arguments.Count != arguments.Length)

    11331. 

  11331.                     {

    11332. 

  11332.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    11333. 

  11333.                         return 1;

    11334. 

  11334.                     }

    11335. 

  11335.                     for (int i = 0; i < arguments.Length; i++)

    11336. 

  11336.                     {

    11337. 

  11337.                         if (result.Arguments[i] != arguments[i])

    11338. 

  11338.                         {

    11339. 

  11339.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    11340. 

  11340.                             return 1;

    11341. 

  11341.                         }

    11342. 

  11342.                     }

    11343. 

  11343.                 }

    11344. 

  11344. 

    11345. 

  11345.                 if (result.Members == null)

    11346. 

  11346.                 {

    11347. 

  11347.                     Console.WriteLine("result.Members was null");

    11348. 

  11348.                     return 1;

    11349. 

  11349.                 }

    11350. 

  11350. 

    11351. 

  11351.                 if (members == null)

    11352. 

  11352.                 {

    11353. 

  11353.                     if (result.Members.Count != 0)

    11354. 

  11354.                     {

    11355. 

  11355.                         Console.WriteLine("Got more than zero members");

    11356. 

  11356.                         return 1;

    11357. 

  11357.                     }

    11358. 

  11358.                 }

    11359. 

  11359.                 else

    11360. 

  11360.                 {

    11361. 

  11361.                     if (result.Members.Count != members.Length)

    11362. 

  11362.                     {

    11363. 

  11363.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    11364. 

  11364.                         return 1;

    11365. 

  11365.                     }

    11366. 

  11366. 

    11367. 

  11367.                     for (int i = 0; i < members.Length; i++)

    11368. 

  11368.                     {

    11369. 

  11369.                         if (result.Members[i] != members[i])

    11370. 

  11370.                         {

    11371. 

  11371.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    11372. 

  11372.                             return 1;

    11373. 

  11373.                         }

    11374. 

  11374.                     }

    11375. 

  11375.                 }

    11376. 

  11376. 

    11377. 

  11377.                 return 0;

    11378. 

  11378.             }

    11379. 

  11379. 

    11380. 

  11380.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    11381. 

  11381.             {

    11382. 

  11382.                 if (!(result.NodeType == et))

    11383. 

  11383.                 {

    11384. 

  11384.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11385. 

  11385.                     return 1;

    11386. 

  11386.                 }

    11387. 

  11387.                 if (!(result.Type == type))

    11388. 

  11388.                 {

    11389. 

  11389.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11390. 

  11390.                     return 1;

    11391. 

  11391.                 }

    11392. 

  11392. 

    11393. 

  11393.                 if (!(result.Constructor == constructor))

    11394. 

  11394.                 {

    11395. 

  11395.                     Console.WriteLine("Constructor is different from expected.");

    11396. 

  11396.                     return 1;

    11397. 

  11397.                 }

    11398. 

  11398. 

    11399. 

  11399.                 if (!(result.ToString() == str))

    11400. 

  11400.                 {

    11401. 

  11401.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11402. 

  11402.                     return 1;

    11403. 

  11403.                 }

    11404. 

  11404. 

    11405. 

  11405.                 if (result.Arguments.Count != arguments.Length)

    11406. 

  11406.                 {

    11407. 

  11407.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    11408. 

  11408.                     return 1;

    11409. 

  11409.                 }

    11410. 

  11410. 

    11411. 

  11411.                 for (int i = 0; i < arguments.Length; i++)

    11412. 

  11412.                 {

    11413. 

  11413.                     if (result.Arguments[i] != arguments[i])

    11414. 

  11414.                     {

    11415. 

  11415.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    11416. 

  11416.                         return 1;

    11417. 

  11417.                     }

    11418. 

  11418.                 }

    11419. 

  11419. 

    11420. 

  11420.                 if (result.Members != null)

    11421. 

  11421.                 {

    11422. 

  11422.                     Console.WriteLine("result.Members isn't null");

    11423. 

  11423.                     return 1;

    11424. 

  11424.                 }

    11425. 

  11425. 

    11426. 

  11426.                 return 0;

    11427. 

  11427.             }

    11428. 

  11428. 

    11429. 

  11429.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    11430. 

  11430.             {

    11431. 

  11431.                 if (!(result.NodeType == et))

    11432. 

  11432.                 {

    11433. 

  11433.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11434. 

  11434.                     return 1;

    11435. 

  11435.                 }

    11436. 

  11436.                 if (!(result.Type == type))

    11437. 

  11437.                 {

    11438. 

  11438.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11439. 

  11439.                     return 1;

    11440. 

  11440.                 }

    11441. 

  11441. 

    11442. 

  11442.                 if (!(result.NewExpression == newExpression)) return 1;

    11443. 

  11443. 

    11444. 

  11444.                 if (!(result.ToString() == str))

    11445. 

  11445.                 {

    11446. 

  11446.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11447. 

  11447.                     return 1;

    11448. 

  11448.                 }

    11449. 

  11449. 

    11450. 

  11450.                 if (result.Initializers.Count != initializers.Length) return 1;

    11451. 

  11451. 

    11452. 

  11452.                 for (int i = 0; i < initializers.Length; i++)

    11453. 

  11453.                 {

    11454. 

  11454.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    11455. 

  11455. 

    11456. 

  11456.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    11457. 

  11457. 

    11458. 

  11458.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    11459. 

  11459.                     {

    11460. 

  11460.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    11461. 

  11461.                     }

    11462. 

  11462.                 }

    11463. 

  11463. 

    11464. 

  11464.                 return 0;

    11465. 

  11465.             }

    11466. 

  11466. 

    11467. 

  11467.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    11468. 

  11468.             {

    11469. 

  11469.                 if (result.AddMethod != exp_mi) return 1;

    11470. 

  11470.                 if (!(result.ToString() == str))

    11471. 

  11471.                 {

    11472. 

  11472.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11473. 

  11473.                     return 1;

    11474. 

  11474.                 }

    11475. 

  11475. 

    11476. 

  11476.                 if (result.Arguments.Count != args.Length) return 1;

    11477. 

  11477. 

    11478. 

  11478.                 for (int i = 0; i < args.Length; i++)

    11479. 

  11479.                 {

    11480. 

  11480.                     if (result.Arguments[i] != args[i]) return 1;

    11481. 

  11481.                 }

    11482. 

  11482. 

    11483. 

  11483.                 return 0;

    11484. 

  11484.             }

    11485. 

  11485. 

    11486. 

  11486.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    11487. 

  11487.             {

    11488. 

  11488.                 if (!(result.BindingType == bt)) return 1;

    11489. 

  11489.                 if (!(result.Expression == expr)) return 1;

    11490. 

  11490.                 if (!(result.Member.Equals(member))) return 1;

    11491. 

  11491.                 if (!(result.ToString() == str))

    11492. 

  11492.                 {

    11493. 

  11493.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11494. 

  11494.                     return 1;

    11495. 

  11495.                 }

    11496. 

  11496. 

    11497. 

  11497.                 return 0;

    11498. 

  11498.             }

    11499. 

  11499. 

    11500. 

  11500.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    11501. 

  11501.             {

    11502. 

  11502.                 if (!(result.BindingType == bt)) return 1;

    11503. 

  11503. 

    11504. 

  11504.                 if (!(result.Member.Equals(member))) return 1;

    11505. 

  11505.                 if (!(result.ToString() == str))

    11506. 

  11506.                 {

    11507. 

  11507.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11508. 

  11508.                     return 1;

    11509. 

  11509.                 }

    11510. 

  11510. 

    11511. 

  11511.                 if (result.Initializers.Count != initializers.Length) return 1;

    11512. 

  11512. 

    11513. 

  11513.                 for (int i = 0; i < initializers.Length; i++)

    11514. 

  11514.                 {

    11515. 

  11515.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    11516. 

  11516. 

    11517. 

  11517.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    11518. 

  11518. 

    11519. 

  11519.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    11520. 

  11520.                     {

    11521. 

  11521.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    11522. 

  11522.                     }

    11523. 

  11523.                 }

    11524. 

  11524. 

    11525. 

  11525. 

    11526. 

  11526.                 return 0;

    11527. 

  11527.             }

    11528. 

  11528. 

    11529. 

  11529.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    11530. 

  11530.             {

    11531. 

  11531.                 if (!(result.BindingType == bt)) return 1;

    11532. 

  11532. 

    11533. 

  11533.                 if (!(result.Member.Equals(member))) return 1;

    11534. 

  11534.                 if (!(result.ToString() == str))

    11535. 

  11535.                 {

    11536. 

  11536.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11537. 

  11537.                     return 1;

    11538. 

  11538.                 }

    11539. 

  11539. 

    11540. 

  11540.                 if (result.Bindings.Count != bindings.Length) return 1;

    11541. 

  11541. 

    11542. 

  11542.                 for (int i = 0; i < bindings.Length; i++)

    11543. 

  11543.                 {

    11544. 

  11544.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    11545. 

  11545.                 }

    11546. 

  11546. 

    11547. 

  11547.                 return 0;

    11548. 

  11548.             }

    11549. 

  11549. 

    11550. 

  11550.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    11551. 

  11551.             {

    11552. 

  11552.                 if (!(result.NodeType == et))

    11553. 

  11553.                 {

    11554. 

  11554.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11555. 

  11555.                     return 1;

    11556. 

  11556.                 }

    11557. 

  11557.                 if (!(result.Type == type))

    11558. 

  11558.                 {

    11559. 

  11559.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11560. 

  11560.                     return 1;

    11561. 

  11561.                 }

    11562. 

  11562.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    11563. 

  11563.                 if (!(result.ToString() == str)) return 1;

    11564. 

  11564. 

    11565. 

  11565.                 if (result.Bindings.Count != bindings.Length) return 1;

    11566. 

  11566. 

    11567. 

  11567.                 for (int i = 0; i < bindings.Length; i++)

    11568. 

  11568.                 {

    11569. 

  11569.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    11570. 

  11570.                 }

    11571. 

  11571. 

    11572. 

  11572.                 return 0;

    11573. 

  11573.             }

    11574. 

  11574. 

    11575. 

  11575.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    11576. 

  11576.             {

    11577. 

  11577.                 if (!(result.NodeType == et))

    11578. 

  11578.                 {

    11579. 

  11579.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11580. 

  11580.                     return 1;

    11581. 

  11581.                 }

    11582. 

  11582.                 if (!(result.Type == type))

    11583. 

  11583.                 {

    11584. 

  11584.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11585. 

  11585.                     return 1;

    11586. 

  11586.                 }

    11587. 

  11587. 

    11588. 

  11588.                 if (result.Expressions.Count != expr.Length) return 1;

    11589. 

  11589. 

    11590. 

  11590.                 for (int i = 0; i < expr.Length; i++)

    11591. 

  11591.                 {

    11592. 

  11592.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    11593. 

  11593.                 }

    11594. 

  11594.                 if (!(result.ToString() == str))

    11595. 

  11595.                 {

    11596. 

  11596.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11597. 

  11597.                     return 1;

    11598. 

  11598.                 }

    11599. 

  11599. 

    11600. 

  11600.                 return 0;

    11601. 

  11601.             }

    11602. 

  11602. 

    11603. 

  11603.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    11604. 

  11604.             {

    11605. 

  11605.                 if (!(result.NodeType == et))

    11606. 

  11606.                 {

    11607. 

  11607.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11608. 

  11608.                     return 1;

    11609. 

  11609.                 }

    11610. 

  11610.                 if (!(result.Type == type))

    11611. 

  11611.                 {

    11612. 

  11612.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11613. 

  11613.                     return 1;

    11614. 

  11614.                 }

    11615. 

  11615.                 if (!(result.Name == name)) return 1;

    11616. 

  11616. 

    11617. 

  11617.                 if (!(result.ToString() == str))

    11618. 

  11618.                 {

    11619. 

  11619.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11620. 

  11620.                     return 1;

    11621. 

  11621.                 }

    11622. 

  11622. 

    11623. 

  11623.                 return 0;

    11624. 

  11624.             }

    11625. 

  11625. 

    11626. 

  11626.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    11627. 

  11627.             {

    11628. 

  11628.                 if (!(result.NodeType == et))

    11629. 

  11629.                 {

    11630. 

  11630.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11631. 

  11631.                     return 1;

    11632. 

  11632.                 }

    11633. 

  11633.                 if (!(result.Type == type))

    11634. 

  11634.                 {

    11635. 

  11635.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11636. 

  11636.                     return 1;

    11637. 

  11637.                 }

    11638. 

  11638. 

    11639. 

  11639.                 if (expr == null)

    11640. 

  11640.                 {

    11641. 

  11641.                     if (result.Body != null) return 1;

    11642. 

  11642.                 }

    11643. 

  11643.                 else

    11644. 

  11644.                 {

    11645. 

  11645.                     if (!(result.Body.Equals(expr))) return 1;

    11646. 

  11646.                 }

    11647. 

  11647. 

    11648. 

  11648.                 if (result.Parameters.Count != parms.Length) return 1;

    11649. 

  11649. 

    11650. 

  11650.                 for (int i = 0; i < parms.Length; i++)

    11651. 

  11651.                 {

    11652. 

  11652.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    11653. 

  11653.                 }

    11654. 

  11654. 

    11655. 

  11655.                 if (!(result.ToString() == str))

    11656. 

  11656.                 {

    11657. 

  11657.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    11658. 

  11658.                     return 1;

    11659. 

  11659.                 }

    11660. 

  11660. 

    11661. 

  11661.                 return 0;

    11662. 

  11662.             }

    11663. 

  11663. 

    11664. 

  11664.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    11665. 

  11665.             {

    11666. 

  11666.                 if (!(result.NodeType == et))

    11667. 

  11667.                 {

    11668. 

  11668.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11669. 

  11669.                     return 1;

    11670. 

  11670.                 }

    11671. 

  11671.                 if (!(result.Type == type))

    11672. 

  11672.                 {

    11673. 

  11673.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11674. 

  11674.                     return 1;

    11675. 

  11675.                 }

    11676. 

  11676. 

    11677. 

  11677.                 if (expr == null)

    11678. 

  11678.                 {

    11679. 

  11679.                     if (result.Expression != null) return 1;

    11680. 

  11680.                 }

    11681. 

  11681.                 else

    11682. 

  11682.                 {

    11683. 

  11683.                     if (!(result.Expression.Equals(expr))) return 1;

    11684. 

  11684.                 }

    11685. 

  11685. 

    11686. 

  11686.                 if (result.Arguments.Count != args.Length) return 1;

    11687. 

  11687. 

    11688. 

  11688.                 for (int i = 0; i < args.Length; i++)

    11689. 

  11689.                 {

    11690. 

  11690.                     if (!(result.Arguments[i].Equals(args[i])))

    11691. 

  11691.                     {

    11692. 

  11692.                         return 1;

    11693. 

  11693.                     }

    11694. 

  11694.                 }

    11695. 

  11695. 

    11696. 

  11696.                 if (result.ToString() != str)

    11697. 

  11697.                 {

    11698. 

  11698.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11699. 

  11699.                     return 1;

    11700. 

  11700.                 }

    11701. 

  11701. 

    11702. 

  11702.                 return 0;

    11703. 

  11703.             }

    11704. 

  11704.         }

    11705. 

  11705. 

    11706. 

  11706. 

    11707. 

  11707. 

    11708. 

  11708.         namespace Not

    11709. 

  11709.         {

    11710. 

  11710.             // Declaring user-defined types for testing

    11711. 

  11711.             struct TC1

    11712. 

  11712.             {

    11713. 

  11713.                 public static TC1 operator !(TC1 c)

    11714. 

  11714.                 {

    11715. 

  11715.                     return new TC1();

    11716. 

  11716.                 }

    11717. 

  11717. 

    11718. 

  11718.                 public static TC1 operator ~(TC1 c)

    11719. 

  11719.                 {

    11720. 

  11720.                     return new TC1();

    11721. 

  11721.                 }

    11722. 

  11722.             }

    11723. 

  11723. 

    11724. 

  11724.             struct TC2

    11725. 

  11725.             {

    11726. 

  11726.                 public static TC2 operator ~(TC2 c)

    11727. 

  11727.                 {

    11728. 

  11728.                     return new TC2();

    11729. 

  11729.                 }

    11730. 

  11730.             }

    11731. 

  11731. 

    11732. 

  11732.             struct TC3

    11733. 

  11733.             {

    11734. 

  11734.                 public static TC3 Meth1(TC3 c)

    11735. 

  11735.                 {

    11736. 

  11736.                     return new TC3();

    11737. 

  11737.                 }

    11738. 

  11738.             }

    11739. 

  11739.         }

    11740. 

  11740. 

    11741. 

  11741.     }

    11742. 

  11742. 

    11743. 

  11743.     //-------- Scenario 796

    11744. 

  11744.     namespace Scenario796

    11745. 

  11745.     {

    11746. 

  11746. 

    11747. 

  11747.         namespace Not

    11748. 

  11748.         {

    11749. 

  11749.             public class Test

    11750. 

  11750.             {

    11751. 

  11751.                 // Overload-2: Test for functionality: Passing non-null methodinfo without lifting

    11752. 

  11752.                 public static int Test14()

    11753. 

  11753.                 {

    11754. 

  11754.                     TC3 ctest = new TC3();

    11755. 

  11755.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC3));

    11756. 

  11756.                     Type exp_type = typeof(TC3);

    11757. 

  11757.                     ExpressionType exp_et = ExpressionType.Not;

    11758. 

  11758.                     string exp_str = "Not(" + ce.ToString() + ")";

    11759. 

  11759.                     Expression exp_operand = ce;

    11760. 

  11760.                     MethodInfo exp_mi = typeof(TC3).GetMethod("Meth1");

    11761. 

  11761. 

    11762. 

  11762.                     UnaryExpression result = Expression.Not(ce, exp_mi);

    11763. 

  11763. 

    11764. 

  11764.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, false, false);

    11765. 

  11765.                 }

    11766. 

  11766. 

    11767. 

  11767. 

    11768. 

  11768.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not14__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    11769. 

  11769.                 public static Expression Not14__()

    11770. 

  11770.                 {

    11771. 

  11771.                     if (Main() != 0)

    11772. 

  11772.                     {

    11773. 

  11773.                         throw new Exception();

    11774. 

  11774.                     }

    11775. 

  11775.                     else

    11776. 

  11776.                     {

    11777. 

  11777.                         return Expression.Constant(0);

    11778. 

  11778.                     }

    11779. 

  11779.                 }

    11780. 

  11780.                 public static int Main()

    11781. 

  11781.                 {

    11782. 

  11782.                     return Test14();

    11783. 

  11783.                 }

    11784. 

  11784.             }

    11785. 

  11785.         }

    11786. 

  11786. 

    11787. 

  11787. 

    11788. 

  11788.         public static class Extension

    11789. 

  11789.         {

    11790. 

  11790.             public static bool CompareParamName(this ArgumentException ex, string expected)

    11791. 

  11791.             {

    11792. 

  11792. #if SILVERLIGHT

    11793. 

  11793. #if SLRESOURCES

    11794. 

  11794. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    11795. 

  11795. #else

    11796. 

  11796. 				        return true;

    11797. 

  11797. #endif

    11798. 

  11798. #else

    11799. 

  11799.                 return ex.ParamName == expected;

    11800. 

  11800. #endif

    11801. 

  11801.             }

    11802. 

  11802. 

    11803. 

  11803.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    11804. 

  11804.             {

    11805. 

  11805. #if SILVERLIGHT

    11806. 

  11806. #if SLRESOURCES

    11807. 

  11807. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    11808. 

  11808. #else

    11809. 

  11809. 				        return true;

    11810. 

  11810. #endif

    11811. 

  11811. #else

    11812. 

  11812.                 return ex.ParamName == expected;

    11813. 

  11813. #endif

    11814. 

  11814.             }

    11815. 

  11815.         }

    11816. 

  11816. 

    11817. 

  11817.         public static class Verification

    11818. 

  11818.         {

    11819. 

  11819.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    11820. 

  11820.             {

    11821. 

  11821.                 if (!(result.NodeType == et))

    11822. 

  11822.                 {

    11823. 

  11823.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11824. 

  11824.                     return 1;

    11825. 

  11825.                 }

    11826. 

  11826.                 if (!(result.Type == type))

    11827. 

  11827.                 {

    11828. 

  11828.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11829. 

  11829.                     return 1;

    11830. 

  11830.                 }

    11831. 

  11831.                 if (val == null)

    11832. 

  11832.                 {

    11833. 

  11833.                     if (result.Value != null) return 1;

    11834. 

  11834.                 }

    11835. 

  11835.                 else

    11836. 

  11836.                 {

    11837. 

  11837.                     if (!(result.Value.Equals(val))) return 1;

    11838. 

  11838.                 }

    11839. 

  11839.                 if (!(result.ToString() == str)) return 1;

    11840. 

  11840.                 return 0;

    11841. 

  11841.             }

    11842. 

  11842. 

    11843. 

  11843.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    11844. 

  11844.             {

    11845. 

  11845.                 if (!(result.NodeType == et))

    11846. 

  11846.                 {

    11847. 

  11847.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11848. 

  11848.                     return 1;

    11849. 

  11849.                 }

    11850. 

  11850.                 if (!(result.Type == type))

    11851. 

  11851.                 {

    11852. 

  11852.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11853. 

  11853.                     return 1;

    11854. 

  11854.                 }

    11855. 

  11855.                 if (operand == null)

    11856. 

  11856.                 {

    11857. 

  11857.                     if (result.Operand != null) return 1;

    11858. 

  11858.                 }

    11859. 

  11859.                 else

    11860. 

  11860.                 {

    11861. 

  11861.                     if (!(result.Operand.Equals(operand))) return 1;

    11862. 

  11862.                 }

    11863. 

  11863.                 if (!(result.ToString() == str))

    11864. 

  11864.                 {

    11865. 

  11865.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11866. 

  11866.                     return 1;

    11867. 

  11867.                 }

    11868. 

  11868. 

    11869. 

  11869.                 if (result.Method != mi) return 1;

    11870. 

  11870.                 if (result.IsLifted != islifted) return 1;

    11871. 

  11871.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11872. 

  11872. 

    11873. 

  11873.                 return 0;

    11874. 

  11874.             }

    11875. 

  11875. 

    11876. 

  11876.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    11877. 

  11877.             {

    11878. 

  11878.                 if (!(result.NodeType == et))

    11879. 

  11879.                 {

    11880. 

  11880.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11881. 

  11881.                     return 1;

    11882. 

  11882.                 }

    11883. 

  11883.                 if (!(result.Type == type))

    11884. 

  11884.                 {

    11885. 

  11885.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11886. 

  11886.                     return 1;

    11887. 

  11887.                 }

    11888. 

  11888. 

    11889. 

  11889.                 if (left == null)

    11890. 

  11890.                 {

    11891. 

  11891.                     if (result.Left != null)

    11892. 

  11892.                     {

    11893. 

  11893.                         Console.WriteLine("left was null");

    11894. 

  11894.                         return 1;

    11895. 

  11895.                     }

    11896. 

  11896.                 }

    11897. 

  11897.                 else

    11898. 

  11898.                 {

    11899. 

  11899.                     if (!(result.Left.Equals(left)))

    11900. 

  11900.                     {

    11901. 

  11901.                         Console.WriteLine("left was different");

    11902. 

  11902.                         return 1;

    11903. 

  11903.                     }

    11904. 

  11904.                 }

    11905. 

  11905. 

    11906. 

  11906.                 if (right == null)

    11907. 

  11907.                 {

    11908. 

  11908.                     if (result.Right != null) return 1;

    11909. 

  11909.                 }

    11910. 

  11910.                 else

    11911. 

  11911.                 {

    11912. 

  11912.                     if (!(result.Right.Equals(right))) return 1;

    11913. 

  11913.                 }

    11914. 

  11914. 

    11915. 

  11915.                 if (!(result.ToString() == str))

    11916. 

  11916.                 {

    11917. 

  11917.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    11918. 

  11918.                     return 1;

    11919. 

  11919.                 }

    11920. 

  11920. 

    11921. 

  11921.                 if (result.Method != mi) return 1;

    11922. 

  11922.                 if (result.IsLifted != islifted) return 1;

    11923. 

  11923.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11924. 

  11924. 

    11925. 

  11925.                 if (result.Conversion != null) return 1;

    11926. 

  11926. 

    11927. 

  11927.                 return 0;

    11928. 

  11928.             }

    11929. 

  11929. 

    11930. 

  11930.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    11931. 

  11931.             {

    11932. 

  11932.                 if (!(result.NodeType == et))

    11933. 

  11933.                 {

    11934. 

  11934.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11935. 

  11935.                     return 1;

    11936. 

  11936.                 }

    11937. 

  11937.                 if (!(result.Type == type))

    11938. 

  11938.                 {

    11939. 

  11939.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11940. 

  11940.                     return 1;

    11941. 

  11941.                 }

    11942. 

  11942. 

    11943. 

  11943.                 if (left == null)

    11944. 

  11944.                 {

    11945. 

  11945.                     if (result.Left != null) return 1;

    11946. 

  11946.                 }

    11947. 

  11947.                 else

    11948. 

  11948.                 {

    11949. 

  11949.                     if (!(result.Left.Equals(left))) return 1;

    11950. 

  11950.                 }

    11951. 

  11951. 

    11952. 

  11952.                 if (right == null)

    11953. 

  11953.                 {

    11954. 

  11954.                     if (result.Right != null) return 1;

    11955. 

  11955.                 }

    11956. 

  11956.                 else

    11957. 

  11957.                 {

    11958. 

  11958.                     if (!(result.Right.Equals(right))) return 1;

    11959. 

  11959.                 }

    11960. 

  11960. 

    11961. 

  11961.                 if (!(result.ToString() == str)) return 1;

    11962. 

  11962. 

    11963. 

  11963.                 if (result.Method != mi) return 1;

    11964. 

  11964.                 if (result.IsLifted != islifted) return 1;

    11965. 

  11965.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    11966. 

  11966. 

    11967. 

  11967.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    11968. 

  11968. 

    11969. 

  11969.                 return 0;

    11970. 

  11970.             }

    11971. 

  11971. 

    11972. 

  11972.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    11973. 

  11973.             {

    11974. 

  11974.                 if (!(result.NodeType == et))

    11975. 

  11975.                 {

    11976. 

  11976.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    11977. 

  11977.                     return 1;

    11978. 

  11978.                 }

    11979. 

  11979.                 if (!(result.Type == type))

    11980. 

  11980.                 {

    11981. 

  11981.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    11982. 

  11982.                     return 1;

    11983. 

  11983.                 }

    11984. 

  11984. 

    11985. 

  11985.                 if (!(result.Method == method)) return 1;

    11986. 

  11986. 

    11987. 

  11987.                 if (obj == null)

    11988. 

  11988.                 {

    11989. 

  11989.                     if (result.Object != null)

    11990. 

  11990.                     {

    11991. 

  11991.                         Console.WriteLine("Expected object to be null.");

    11992. 

  11992.                         return 1;

    11993. 

  11993.                     }

    11994. 

  11994.                 }

    11995. 

  11995.                 else

    11996. 

  11996.                 {

    11997. 

  11997.                     if (!(result.Object.Equals(obj)))

    11998. 

  11998.                     {

    11999. 

  11999.                         Console.WriteLine("Object on which call is made is different from the result.");

    12000. 

  12000.                         return 1;

    12001. 

  12001.                     }

    12002. 

  12002.                 }

    12003. 

  12003. 

    12004. 

  12004.                 if (!(result.ToString() == str))

    12005. 

  12005.                 {

    12006. 

  12006.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12007. 

  12007.                     return 1;

    12008. 

  12008.                 }

    12009. 

  12009. 

    12010. 

  12010.                 if (result.Arguments.Count != arguments.Length) return 1;

    12011. 

  12011. 

    12012. 

  12012.                 for (int i = 0; i < arguments.Length; i++)

    12013. 

  12013.                 {

    12014. 

  12014.                     if (result.Arguments[i] != arguments[i]) return 1;

    12015. 

  12015.                 }

    12016. 

  12016. 

    12017. 

  12017.                 return 0;

    12018. 

  12018.             }

    12019. 

  12019. 

    12020. 

  12020.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    12021. 

  12021.             {

    12022. 

  12022.                 if (!(result.NodeType == et))

    12023. 

  12023.                 {

    12024. 

  12024.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12025. 

  12025.                     return 1;

    12026. 

  12026.                 }

    12027. 

  12027.                 if (!(result.Type == type))

    12028. 

  12028.                 {

    12029. 

  12029.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12030. 

  12030.                     return 1;

    12031. 

  12031.                 }

    12032. 

  12032. 

    12033. 

  12033.                 if (expr == null)

    12034. 

  12034.                 {

    12035. 

  12035.                     Console.WriteLine("expr was null.");

    12036. 

  12036.                     if (result.Expression != null) return 1;

    12037. 

  12037.                 }

    12038. 

  12038.                 else

    12039. 

  12039.                 {

    12040. 

  12040.                     if (!(result.Expression.Equals(expr)))

    12041. 

  12041.                     {

    12042. 

  12042.                         return 1;

    12043. 

  12043.                     }

    12044. 

  12044.                 }

    12045. 

  12045. 

    12046. 

  12046.                 if (!(result.TypeOperand == typeop)) return 1;

    12047. 

  12047. 

    12048. 

  12048.                 if (!(result.ToString() == str))

    12049. 

  12049.                 {

    12050. 

  12050.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12051. 

  12051.                     return 1;

    12052. 

  12052.                 }

    12053. 

  12053. 

    12054. 

  12054.                 return 0;

    12055. 

  12055.             }

    12056. 

  12056. 

    12057. 

  12057.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    12058. 

  12058.             {

    12059. 

  12059.                 if (!(result.NodeType == et))

    12060. 

  12060.                 {

    12061. 

  12061.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12062. 

  12062.                     return 1;

    12063. 

  12063.                 }

    12064. 

  12064.                 if (!(result.Type == type))

    12065. 

  12065.                 {

    12066. 

  12066.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12067. 

  12067.                     return 1;

    12068. 

  12068.                 }

    12069. 

  12069. 

    12070. 

  12070.                 if (test == null)

    12071. 

  12071.                 {

    12072. 

  12072.                     if (result.Test != null) return 1;

    12073. 

  12073.                 }

    12074. 

  12074.                 else

    12075. 

  12075.                 {

    12076. 

  12076.                     if (!(result.Test.Equals(test))) return 1;

    12077. 

  12077.                 }

    12078. 

  12078. 

    12079. 

  12079.                 if (ifTrue == null)

    12080. 

  12080.                 {

    12081. 

  12081.                     if (result.IfTrue != null) return 1;

    12082. 

  12082.                 }

    12083. 

  12083.                 else

    12084. 

  12084.                 {

    12085. 

  12085.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    12086. 

  12086.                 }

    12087. 

  12087. 

    12088. 

  12088.                 if (ifFalse == null)

    12089. 

  12089.                 {

    12090. 

  12090.                     if (result.IfFalse != null) return 1;

    12091. 

  12091.                 }

    12092. 

  12092.                 else

    12093. 

  12093.                 {

    12094. 

  12094.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    12095. 

  12095.                 }

    12096. 

  12096. 

    12097. 

  12097.                 if (!(result.ToString() == str)) return 1;

    12098. 

  12098. 

    12099. 

  12099.                 return 0;

    12100. 

  12100.             }

    12101. 

  12101. 

    12102. 

  12102.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    12103. 

  12103.             {

    12104. 

  12104.                 if (!(result.NodeType == et))

    12105. 

  12105.                 {

    12106. 

  12106.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12107. 

  12107.                     return 1;

    12108. 

  12108.                 }

    12109. 

  12109.                 if (!(result.Type == type))

    12110. 

  12110.                 {

    12111. 

  12111.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12112. 

  12112.                     return 1;

    12113. 

  12113.                 }

    12114. 

  12114. 

    12115. 

  12115.                 if (exp_expr == null)

    12116. 

  12116.                 {

    12117. 

  12117.                     if (result.Expression != null)

    12118. 

  12118.                     {

    12119. 

  12119.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    12120. 

  12120.                         return 1;

    12121. 

  12121.                     }

    12122. 

  12122.                 }

    12123. 

  12123.                 else

    12124. 

  12124.                 {

    12125. 

  12125.                     if (!(result.Expression.Equals(exp_expr)))

    12126. 

  12126.                     {

    12127. 

  12127.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    12128. 

  12128.                         return 1;

    12129. 

  12129.                     }

    12130. 

  12130.                 }

    12131. 

  12131. 

    12132. 

  12132.                 if (!(result.Member == exp_member))

    12133. 

  12133.                 {

    12134. 

  12134.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    12135. 

  12135.                     return 1;

    12136. 

  12136.                 }

    12137. 

  12137. 

    12138. 

  12138.                 if (!(result.ToString() == str))

    12139. 

  12139.                 {

    12140. 

  12140.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12141. 

  12141.                     return 1;

    12142. 

  12142.                 }

    12143. 

  12143. 

    12144. 

  12144.                 return 0;

    12145. 

  12145.             }

    12146. 

  12146. 

    12147. 

  12147.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    12148. 

  12148.             {

    12149. 

  12149.                 if (!(result.NodeType == et))

    12150. 

  12150.                 {

    12151. 

  12151.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12152. 

  12152.                     return 1;

    12153. 

  12153.                 }

    12154. 

  12154.                 if (!(result.Type == type))

    12155. 

  12155.                 {

    12156. 

  12156.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12157. 

  12157.                     return 1;

    12158. 

  12158.                 }

    12159. 

  12159. 

    12160. 

  12160.                 if (!(result.Constructor == constructor))

    12161. 

  12161.                 {

    12162. 

  12162.                     Console.WriteLine("Unexpected constructor");

    12163. 

  12163.                     return 1;

    12164. 

  12164.                 }

    12165. 

  12165. 

    12166. 

  12166.                 if (!(result.ToString() == str))

    12167. 

  12167.                 {

    12168. 

  12168.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12169. 

  12169.                     return 1;

    12170. 

  12170.                 }

    12171. 

  12171. 

    12172. 

  12172.                 if (arguments == null)

    12173. 

  12173.                 {

    12174. 

  12174.                     if (result.Arguments.Count != 0)

    12175. 

  12175.                     {

    12176. 

  12176.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    12177. 

  12177.                         return 1;

    12178. 

  12178.                     }

    12179. 

  12179.                 }

    12180. 

  12180.                 else

    12181. 

  12181.                 {

    12182. 

  12182.                     if (result.Arguments.Count != arguments.Length)

    12183. 

  12183.                     {

    12184. 

  12184.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    12185. 

  12185.                         return 1;

    12186. 

  12186.                     }

    12187. 

  12187.                     for (int i = 0; i < arguments.Length; i++)

    12188. 

  12188.                     {

    12189. 

  12189.                         if (result.Arguments[i] != arguments[i])

    12190. 

  12190.                         {

    12191. 

  12191.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    12192. 

  12192.                             return 1;

    12193. 

  12193.                         }

    12194. 

  12194.                     }

    12195. 

  12195.                 }

    12196. 

  12196. 

    12197. 

  12197.                 if (result.Members == null)

    12198. 

  12198.                 {

    12199. 

  12199.                     Console.WriteLine("result.Members was null");

    12200. 

  12200.                     return 1;

    12201. 

  12201.                 }

    12202. 

  12202. 

    12203. 

  12203.                 if (members == null)

    12204. 

  12204.                 {

    12205. 

  12205.                     if (result.Members.Count != 0)

    12206. 

  12206.                     {

    12207. 

  12207.                         Console.WriteLine("Got more than zero members");

    12208. 

  12208.                         return 1;

    12209. 

  12209.                     }

    12210. 

  12210.                 }

    12211. 

  12211.                 else

    12212. 

  12212.                 {

    12213. 

  12213.                     if (result.Members.Count != members.Length)

    12214. 

  12214.                     {

    12215. 

  12215.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    12216. 

  12216.                         return 1;

    12217. 

  12217.                     }

    12218. 

  12218. 

    12219. 

  12219.                     for (int i = 0; i < members.Length; i++)

    12220. 

  12220.                     {

    12221. 

  12221.                         if (result.Members[i] != members[i])

    12222. 

  12222.                         {

    12223. 

  12223.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    12224. 

  12224.                             return 1;

    12225. 

  12225.                         }

    12226. 

  12226.                     }

    12227. 

  12227.                 }

    12228. 

  12228. 

    12229. 

  12229.                 return 0;

    12230. 

  12230.             }

    12231. 

  12231. 

    12232. 

  12232.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    12233. 

  12233.             {

    12234. 

  12234.                 if (!(result.NodeType == et))

    12235. 

  12235.                 {

    12236. 

  12236.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12237. 

  12237.                     return 1;

    12238. 

  12238.                 }

    12239. 

  12239.                 if (!(result.Type == type))

    12240. 

  12240.                 {

    12241. 

  12241.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12242. 

  12242.                     return 1;

    12243. 

  12243.                 }

    12244. 

  12244. 

    12245. 

  12245.                 if (!(result.Constructor == constructor))

    12246. 

  12246.                 {

    12247. 

  12247.                     Console.WriteLine("Constructor is different from expected.");

    12248. 

  12248.                     return 1;

    12249. 

  12249.                 }

    12250. 

  12250. 

    12251. 

  12251.                 if (!(result.ToString() == str))

    12252. 

  12252.                 {

    12253. 

  12253.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12254. 

  12254.                     return 1;

    12255. 

  12255.                 }

    12256. 

  12256. 

    12257. 

  12257.                 if (result.Arguments.Count != arguments.Length)

    12258. 

  12258.                 {

    12259. 

  12259.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    12260. 

  12260.                     return 1;

    12261. 

  12261.                 }

    12262. 

  12262. 

    12263. 

  12263.                 for (int i = 0; i < arguments.Length; i++)

    12264. 

  12264.                 {

    12265. 

  12265.                     if (result.Arguments[i] != arguments[i])

    12266. 

  12266.                     {

    12267. 

  12267.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    12268. 

  12268.                         return 1;

    12269. 

  12269.                     }

    12270. 

  12270.                 }

    12271. 

  12271. 

    12272. 

  12272.                 if (result.Members != null)

    12273. 

  12273.                 {

    12274. 

  12274.                     Console.WriteLine("result.Members isn't null");

    12275. 

  12275.                     return 1;

    12276. 

  12276.                 }

    12277. 

  12277. 

    12278. 

  12278.                 return 0;

    12279. 

  12279.             }

    12280. 

  12280. 

    12281. 

  12281.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    12282. 

  12282.             {

    12283. 

  12283.                 if (!(result.NodeType == et))

    12284. 

  12284.                 {

    12285. 

  12285.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12286. 

  12286.                     return 1;

    12287. 

  12287.                 }

    12288. 

  12288.                 if (!(result.Type == type))

    12289. 

  12289.                 {

    12290. 

  12290.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12291. 

  12291.                     return 1;

    12292. 

  12292.                 }

    12293. 

  12293. 

    12294. 

  12294.                 if (!(result.NewExpression == newExpression)) return 1;

    12295. 

  12295. 

    12296. 

  12296.                 if (!(result.ToString() == str))

    12297. 

  12297.                 {

    12298. 

  12298.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12299. 

  12299.                     return 1;

    12300. 

  12300.                 }

    12301. 

  12301. 

    12302. 

  12302.                 if (result.Initializers.Count != initializers.Length) return 1;

    12303. 

  12303. 

    12304. 

  12304.                 for (int i = 0; i < initializers.Length; i++)

    12305. 

  12305.                 {

    12306. 

  12306.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    12307. 

  12307. 

    12308. 

  12308.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    12309. 

  12309. 

    12310. 

  12310.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    12311. 

  12311.                     {

    12312. 

  12312.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    12313. 

  12313.                     }

    12314. 

  12314.                 }

    12315. 

  12315. 

    12316. 

  12316.                 return 0;

    12317. 

  12317.             }

    12318. 

  12318. 

    12319. 

  12319.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    12320. 

  12320.             {

    12321. 

  12321.                 if (result.AddMethod != exp_mi) return 1;

    12322. 

  12322.                 if (!(result.ToString() == str))

    12323. 

  12323.                 {

    12324. 

  12324.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12325. 

  12325.                     return 1;

    12326. 

  12326.                 }

    12327. 

  12327. 

    12328. 

  12328.                 if (result.Arguments.Count != args.Length) return 1;

    12329. 

  12329. 

    12330. 

  12330.                 for (int i = 0; i < args.Length; i++)

    12331. 

  12331.                 {

    12332. 

  12332.                     if (result.Arguments[i] != args[i]) return 1;

    12333. 

  12333.                 }

    12334. 

  12334. 

    12335. 

  12335.                 return 0;

    12336. 

  12336.             }

    12337. 

  12337. 

    12338. 

  12338.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    12339. 

  12339.             {

    12340. 

  12340.                 if (!(result.BindingType == bt)) return 1;

    12341. 

  12341.                 if (!(result.Expression == expr)) return 1;

    12342. 

  12342.                 if (!(result.Member.Equals(member))) return 1;

    12343. 

  12343.                 if (!(result.ToString() == str))

    12344. 

  12344.                 {

    12345. 

  12345.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12346. 

  12346.                     return 1;

    12347. 

  12347.                 }

    12348. 

  12348. 

    12349. 

  12349.                 return 0;

    12350. 

  12350.             }

    12351. 

  12351. 

    12352. 

  12352.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    12353. 

  12353.             {

    12354. 

  12354.                 if (!(result.BindingType == bt)) return 1;

    12355. 

  12355. 

    12356. 

  12356.                 if (!(result.Member.Equals(member))) return 1;

    12357. 

  12357.                 if (!(result.ToString() == str))

    12358. 

  12358.                 {

    12359. 

  12359.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12360. 

  12360.                     return 1;

    12361. 

  12361.                 }

    12362. 

  12362. 

    12363. 

  12363.                 if (result.Initializers.Count != initializers.Length) return 1;

    12364. 

  12364. 

    12365. 

  12365.                 for (int i = 0; i < initializers.Length; i++)

    12366. 

  12366.                 {

    12367. 

  12367.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    12368. 

  12368. 

    12369. 

  12369.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    12370. 

  12370. 

    12371. 

  12371.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    12372. 

  12372.                     {

    12373. 

  12373.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    12374. 

  12374.                     }

    12375. 

  12375.                 }

    12376. 

  12376. 

    12377. 

  12377. 

    12378. 

  12378.                 return 0;

    12379. 

  12379.             }

    12380. 

  12380. 

    12381. 

  12381.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    12382. 

  12382.             {

    12383. 

  12383.                 if (!(result.BindingType == bt)) return 1;

    12384. 

  12384. 

    12385. 

  12385.                 if (!(result.Member.Equals(member))) return 1;

    12386. 

  12386.                 if (!(result.ToString() == str))

    12387. 

  12387.                 {

    12388. 

  12388.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12389. 

  12389.                     return 1;

    12390. 

  12390.                 }

    12391. 

  12391. 

    12392. 

  12392.                 if (result.Bindings.Count != bindings.Length) return 1;

    12393. 

  12393. 

    12394. 

  12394.                 for (int i = 0; i < bindings.Length; i++)

    12395. 

  12395.                 {

    12396. 

  12396.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    12397. 

  12397.                 }

    12398. 

  12398. 

    12399. 

  12399.                 return 0;

    12400. 

  12400.             }

    12401. 

  12401. 

    12402. 

  12402.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    12403. 

  12403.             {

    12404. 

  12404.                 if (!(result.NodeType == et))

    12405. 

  12405.                 {

    12406. 

  12406.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12407. 

  12407.                     return 1;

    12408. 

  12408.                 }

    12409. 

  12409.                 if (!(result.Type == type))

    12410. 

  12410.                 {

    12411. 

  12411.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12412. 

  12412.                     return 1;

    12413. 

  12413.                 }

    12414. 

  12414.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    12415. 

  12415.                 if (!(result.ToString() == str)) return 1;

    12416. 

  12416. 

    12417. 

  12417.                 if (result.Bindings.Count != bindings.Length) return 1;

    12418. 

  12418. 

    12419. 

  12419.                 for (int i = 0; i < bindings.Length; i++)

    12420. 

  12420.                 {

    12421. 

  12421.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    12422. 

  12422.                 }

    12423. 

  12423. 

    12424. 

  12424.                 return 0;

    12425. 

  12425.             }

    12426. 

  12426. 

    12427. 

  12427.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    12428. 

  12428.             {

    12429. 

  12429.                 if (!(result.NodeType == et))

    12430. 

  12430.                 {

    12431. 

  12431.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12432. 

  12432.                     return 1;

    12433. 

  12433.                 }

    12434. 

  12434.                 if (!(result.Type == type))

    12435. 

  12435.                 {

    12436. 

  12436.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12437. 

  12437.                     return 1;

    12438. 

  12438.                 }

    12439. 

  12439. 

    12440. 

  12440.                 if (result.Expressions.Count != expr.Length) return 1;

    12441. 

  12441. 

    12442. 

  12442.                 for (int i = 0; i < expr.Length; i++)

    12443. 

  12443.                 {

    12444. 

  12444.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    12445. 

  12445.                 }

    12446. 

  12446.                 if (!(result.ToString() == str))

    12447. 

  12447.                 {

    12448. 

  12448.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12449. 

  12449.                     return 1;

    12450. 

  12450.                 }

    12451. 

  12451. 

    12452. 

  12452.                 return 0;

    12453. 

  12453.             }

    12454. 

  12454. 

    12455. 

  12455.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    12456. 

  12456.             {

    12457. 

  12457.                 if (!(result.NodeType == et))

    12458. 

  12458.                 {

    12459. 

  12459.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12460. 

  12460.                     return 1;

    12461. 

  12461.                 }

    12462. 

  12462.                 if (!(result.Type == type))

    12463. 

  12463.                 {

    12464. 

  12464.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12465. 

  12465.                     return 1;

    12466. 

  12466.                 }

    12467. 

  12467.                 if (!(result.Name == name)) return 1;

    12468. 

  12468. 

    12469. 

  12469.                 if (!(result.ToString() == str))

    12470. 

  12470.                 {

    12471. 

  12471.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12472. 

  12472.                     return 1;

    12473. 

  12473.                 }

    12474. 

  12474. 

    12475. 

  12475.                 return 0;

    12476. 

  12476.             }

    12477. 

  12477. 

    12478. 

  12478.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    12479. 

  12479.             {

    12480. 

  12480.                 if (!(result.NodeType == et))

    12481. 

  12481.                 {

    12482. 

  12482.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12483. 

  12483.                     return 1;

    12484. 

  12484.                 }

    12485. 

  12485.                 if (!(result.Type == type))

    12486. 

  12486.                 {

    12487. 

  12487.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12488. 

  12488.                     return 1;

    12489. 

  12489.                 }

    12490. 

  12490. 

    12491. 

  12491.                 if (expr == null)

    12492. 

  12492.                 {

    12493. 

  12493.                     if (result.Body != null) return 1;

    12494. 

  12494.                 }

    12495. 

  12495.                 else

    12496. 

  12496.                 {

    12497. 

  12497.                     if (!(result.Body.Equals(expr))) return 1;

    12498. 

  12498.                 }

    12499. 

  12499. 

    12500. 

  12500.                 if (result.Parameters.Count != parms.Length) return 1;

    12501. 

  12501. 

    12502. 

  12502.                 for (int i = 0; i < parms.Length; i++)

    12503. 

  12503.                 {

    12504. 

  12504.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    12505. 

  12505.                 }

    12506. 

  12506. 

    12507. 

  12507.                 if (!(result.ToString() == str))

    12508. 

  12508.                 {

    12509. 

  12509.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12510. 

  12510.                     return 1;

    12511. 

  12511.                 }

    12512. 

  12512. 

    12513. 

  12513.                 return 0;

    12514. 

  12514.             }

    12515. 

  12515. 

    12516. 

  12516.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    12517. 

  12517.             {

    12518. 

  12518.                 if (!(result.NodeType == et))

    12519. 

  12519.                 {

    12520. 

  12520.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12521. 

  12521.                     return 1;

    12522. 

  12522.                 }

    12523. 

  12523.                 if (!(result.Type == type))

    12524. 

  12524.                 {

    12525. 

  12525.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12526. 

  12526.                     return 1;

    12527. 

  12527.                 }

    12528. 

  12528. 

    12529. 

  12529.                 if (expr == null)

    12530. 

  12530.                 {

    12531. 

  12531.                     if (result.Expression != null) return 1;

    12532. 

  12532.                 }

    12533. 

  12533.                 else

    12534. 

  12534.                 {

    12535. 

  12535.                     if (!(result.Expression.Equals(expr))) return 1;

    12536. 

  12536.                 }

    12537. 

  12537. 

    12538. 

  12538.                 if (result.Arguments.Count != args.Length) return 1;

    12539. 

  12539. 

    12540. 

  12540.                 for (int i = 0; i < args.Length; i++)

    12541. 

  12541.                 {

    12542. 

  12542.                     if (!(result.Arguments[i].Equals(args[i])))

    12543. 

  12543.                     {

    12544. 

  12544.                         return 1;

    12545. 

  12545.                     }

    12546. 

  12546.                 }

    12547. 

  12547. 

    12548. 

  12548.                 if (result.ToString() != str)

    12549. 

  12549.                 {

    12550. 

  12550.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12551. 

  12551.                     return 1;

    12552. 

  12552.                 }

    12553. 

  12553. 

    12554. 

  12554.                 return 0;

    12555. 

  12555.             }

    12556. 

  12556.         }

    12557. 

  12557. 

    12558. 

  12558. 

    12559. 

  12559. 

    12560. 

  12560.         namespace Not

    12561. 

  12561.         {

    12562. 

  12562.             // Declaring user-defined types for testing

    12563. 

  12563.             struct TC1

    12564. 

  12564.             {

    12565. 

  12565.                 public static TC1 operator !(TC1 c)

    12566. 

  12566.                 {

    12567. 

  12567.                     return new TC1();

    12568. 

  12568.                 }

    12569. 

  12569. 

    12570. 

  12570.                 public static TC1 operator ~(TC1 c)

    12571. 

  12571.                 {

    12572. 

  12572.                     return new TC1();

    12573. 

  12573.                 }

    12574. 

  12574.             }

    12575. 

  12575. 

    12576. 

  12576.             struct TC2

    12577. 

  12577.             {

    12578. 

  12578.                 public static TC2 operator ~(TC2 c)

    12579. 

  12579.                 {

    12580. 

  12580.                     return new TC2();

    12581. 

  12581.                 }

    12582. 

  12582.             }

    12583. 

  12583. 

    12584. 

  12584.             struct TC3

    12585. 

  12585.             {

    12586. 

  12586.                 public static TC3 Meth1(TC3 c)

    12587. 

  12587.                 {

    12588. 

  12588.                     return new TC3();

    12589. 

  12589.                 }

    12590. 

  12590.             }

    12591. 

  12591.         }

    12592. 

  12592. 

    12593. 

  12593.     }

    12594. 

  12594. 

    12595. 

  12595.     //-------- Scenario 797

    12596. 

  12596.     namespace Scenario797

    12597. 

  12597.     {

    12598. 

  12598. 

    12599. 

  12599.         namespace Not

    12600. 

  12600.         {

    12601. 

  12601.             public class Test

    12602. 

  12602.             {

    12603. 

  12603.                 // Overload-2: Test for functionality: Passing non-null methodinfo with lifting

    12604. 

  12604.                 public static int Test15()

    12605. 

  12605.                 {

    12606. 

  12606.                     TC3? ctest = new TC3?();

    12607. 

  12607.                     ConstantExpression ce = Expression.Constant(ctest, typeof(TC3?));

    12608. 

  12608.                     Type exp_type = typeof(TC3?);

    12609. 

  12609.                     ExpressionType exp_et = ExpressionType.Not;

    12610. 

  12610.                     string exp_str = "Not(" + ce.ToString() + ")";

    12611. 

  12611.                     Expression exp_operand = ce;

    12612. 

  12612.                     MethodInfo exp_mi = typeof(TC3).GetMethod("Meth1");

    12613. 

  12613. 

    12614. 

  12614.                     UnaryExpression result = Expression.Not(ce, exp_mi);

    12615. 

  12615. 

    12616. 

  12616.                     return Verification.VerifyUnaryParms(result, exp_et, exp_type, exp_operand, exp_str, exp_mi, true, true);

    12617. 

  12617.                 }

    12618. 

  12618. 

    12619. 

  12619. 

    12620. 

  12620.                 [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Not15__", new string[] { "positive", "cslinq", "FullTrustOnly", "Pri1" })]

    12621. 

  12621.                 public static Expression Not15__()

    12622. 

  12622.                 {

    12623. 

  12623.                     if (Main() != 0)

    12624. 

  12624.                     {

    12625. 

  12625.                         throw new Exception();

    12626. 

  12626.                     }

    12627. 

  12627.                     else

    12628. 

  12628.                     {

    12629. 

  12629.                         return Expression.Constant(0);

    12630. 

  12630.                     }

    12631. 

  12631.                 }

    12632. 

  12632.                 public static int Main()

    12633. 

  12633.                 {

    12634. 

  12634.                     return Test15();

    12635. 

  12635.                 }

    12636. 

  12636.             }

    12637. 

  12637.         }

    12638. 

  12638. 

    12639. 

  12639. 

    12640. 

  12640.         public static class Extension

    12641. 

  12641.         {

    12642. 

  12642.             public static bool CompareParamName(this ArgumentException ex, string expected)

    12643. 

  12643.             {

    12644. 

  12644. #if SILVERLIGHT

    12645. 

  12645. #if SLRESOURCES

    12646. 

  12646. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    12647. 

  12647. #else

    12648. 

  12648. 				        return true;

    12649. 

  12649. #endif

    12650. 

  12650. #else

    12651. 

  12651.                 return ex.ParamName == expected;

    12652. 

  12652. #endif

    12653. 

  12653.             }

    12654. 

  12654. 

    12655. 

  12655.             public static bool CompareParamName(this ArgumentNullException ex, string expected)

    12656. 

  12656.             {

    12657. 

  12657. #if SILVERLIGHT

    12658. 

  12658. #if SLRESOURCES

    12659. 

  12659. 				        return ex.Message.Substring(ex.Message.LastIndexOf(": ") + 2) == expected;

    12660. 

  12660. #else

    12661. 

  12661. 				        return true;

    12662. 

  12662. #endif

    12663. 

  12663. #else

    12664. 

  12664.                 return ex.ParamName == expected;

    12665. 

  12665. #endif

    12666. 

  12666.             }

    12667. 

  12667.         }

    12668. 

  12668. 

    12669. 

  12669.         public static class Verification

    12670. 

  12670.         {

    12671. 

  12671.             public static int VerifyConstParms(ConstantExpression result, ExpressionType et, Type type, object val, string str)

    12672. 

  12672.             {

    12673. 

  12673.                 if (!(result.NodeType == et))

    12674. 

  12674.                 {

    12675. 

  12675.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12676. 

  12676.                     return 1;

    12677. 

  12677.                 }

    12678. 

  12678.                 if (!(result.Type == type))

    12679. 

  12679.                 {

    12680. 

  12680.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12681. 

  12681.                     return 1;

    12682. 

  12682.                 }

    12683. 

  12683.                 if (val == null)

    12684. 

  12684.                 {

    12685. 

  12685.                     if (result.Value != null) return 1;

    12686. 

  12686.                 }

    12687. 

  12687.                 else

    12688. 

  12688.                 {

    12689. 

  12689.                     if (!(result.Value.Equals(val))) return 1;

    12690. 

  12690.                 }

    12691. 

  12691.                 if (!(result.ToString() == str)) return 1;

    12692. 

  12692.                 return 0;

    12693. 

  12693.             }

    12694. 

  12694. 

    12695. 

  12695.             public static int VerifyUnaryParms(UnaryExpression result, ExpressionType et, Type type, Expression operand, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    12696. 

  12696.             {

    12697. 

  12697.                 if (!(result.NodeType == et))

    12698. 

  12698.                 {

    12699. 

  12699.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12700. 

  12700.                     return 1;

    12701. 

  12701.                 }

    12702. 

  12702.                 if (!(result.Type == type))

    12703. 

  12703.                 {

    12704. 

  12704.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12705. 

  12705.                     return 1;

    12706. 

  12706.                 }

    12707. 

  12707.                 if (operand == null)

    12708. 

  12708.                 {

    12709. 

  12709.                     if (result.Operand != null) return 1;

    12710. 

  12710.                 }

    12711. 

  12711.                 else

    12712. 

  12712.                 {

    12713. 

  12713.                     if (!(result.Operand.Equals(operand))) return 1;

    12714. 

  12714.                 }

    12715. 

  12715.                 if (!(result.ToString() == str))

    12716. 

  12716.                 {

    12717. 

  12717.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12718. 

  12718.                     return 1;

    12719. 

  12719.                 }

    12720. 

  12720. 

    12721. 

  12721.                 if (result.Method != mi) return 1;

    12722. 

  12722.                 if (result.IsLifted != islifted) return 1;

    12723. 

  12723.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    12724. 

  12724. 

    12725. 

  12725.                 return 0;

    12726. 

  12726.             }

    12727. 

  12727. 

    12728. 

  12728.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, bool islifted, bool isliftedtonull)

    12729. 

  12729.             {

    12730. 

  12730.                 if (!(result.NodeType == et))

    12731. 

  12731.                 {

    12732. 

  12732.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12733. 

  12733.                     return 1;

    12734. 

  12734.                 }

    12735. 

  12735.                 if (!(result.Type == type))

    12736. 

  12736.                 {

    12737. 

  12737.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12738. 

  12738.                     return 1;

    12739. 

  12739.                 }

    12740. 

  12740. 

    12741. 

  12741.                 if (left == null)

    12742. 

  12742.                 {

    12743. 

  12743.                     if (result.Left != null)

    12744. 

  12744.                     {

    12745. 

  12745.                         Console.WriteLine("left was null");

    12746. 

  12746.                         return 1;

    12747. 

  12747.                     }

    12748. 

  12748.                 }

    12749. 

  12749.                 else

    12750. 

  12750.                 {

    12751. 

  12751.                     if (!(result.Left.Equals(left)))

    12752. 

  12752.                     {

    12753. 

  12753.                         Console.WriteLine("left was different");

    12754. 

  12754.                         return 1;

    12755. 

  12755.                     }

    12756. 

  12756.                 }

    12757. 

  12757. 

    12758. 

  12758.                 if (right == null)

    12759. 

  12759.                 {

    12760. 

  12760.                     if (result.Right != null) return 1;

    12761. 

  12761.                 }

    12762. 

  12762.                 else

    12763. 

  12763.                 {

    12764. 

  12764.                     if (!(result.Right.Equals(right))) return 1;

    12765. 

  12765.                 }

    12766. 

  12766. 

    12767. 

  12767.                 if (!(result.ToString() == str))

    12768. 

  12768.                 {

    12769. 

  12769.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12770. 

  12770.                     return 1;

    12771. 

  12771.                 }

    12772. 

  12772. 

    12773. 

  12773.                 if (result.Method != mi) return 1;

    12774. 

  12774.                 if (result.IsLifted != islifted) return 1;

    12775. 

  12775.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    12776. 

  12776. 

    12777. 

  12777.                 if (result.Conversion != null) return 1;

    12778. 

  12778. 

    12779. 

  12779.                 return 0;

    12780. 

  12780.             }

    12781. 

  12781. 

    12782. 

  12782.             public static int VerifyBinaryParms(BinaryExpression result, ExpressionType et, Type type, Expression left, Expression right, string str, MethodInfo mi, LambdaExpression conv_expr, bool islifted, bool isliftedtonull)

    12783. 

  12783.             {

    12784. 

  12784.                 if (!(result.NodeType == et))

    12785. 

  12785.                 {

    12786. 

  12786.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12787. 

  12787.                     return 1;

    12788. 

  12788.                 }

    12789. 

  12789.                 if (!(result.Type == type))

    12790. 

  12790.                 {

    12791. 

  12791.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12792. 

  12792.                     return 1;

    12793. 

  12793.                 }

    12794. 

  12794. 

    12795. 

  12795.                 if (left == null)

    12796. 

  12796.                 {

    12797. 

  12797.                     if (result.Left != null) return 1;

    12798. 

  12798.                 }

    12799. 

  12799.                 else

    12800. 

  12800.                 {

    12801. 

  12801.                     if (!(result.Left.Equals(left))) return 1;

    12802. 

  12802.                 }

    12803. 

  12803. 

    12804. 

  12804.                 if (right == null)

    12805. 

  12805.                 {

    12806. 

  12806.                     if (result.Right != null) return 1;

    12807. 

  12807.                 }

    12808. 

  12808.                 else

    12809. 

  12809.                 {

    12810. 

  12810.                     if (!(result.Right.Equals(right))) return 1;

    12811. 

  12811.                 }

    12812. 

  12812. 

    12813. 

  12813.                 if (!(result.ToString() == str)) return 1;

    12814. 

  12814. 

    12815. 

  12815.                 if (result.Method != mi) return 1;

    12816. 

  12816.                 if (result.IsLifted != islifted) return 1;

    12817. 

  12817.                 if (result.IsLiftedToNull != isliftedtonull) return 1;

    12818. 

  12818. 

    12819. 

  12819.                 if (result.Conversion.ToString() != conv_expr.ToString()) return 1;

    12820. 

  12820. 

    12821. 

  12821.                 return 0;

    12822. 

  12822.             }

    12823. 

  12823. 

    12824. 

  12824.             public static int VerifyMethodCallParms(MethodCallExpression result, ExpressionType et, Type type, MethodInfo method, Expression obj, string str, params Expression[] arguments)

    12825. 

  12825.             {

    12826. 

  12826.                 if (!(result.NodeType == et))

    12827. 

  12827.                 {

    12828. 

  12828.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12829. 

  12829.                     return 1;

    12830. 

  12830.                 }

    12831. 

  12831.                 if (!(result.Type == type))

    12832. 

  12832.                 {

    12833. 

  12833.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12834. 

  12834.                     return 1;

    12835. 

  12835.                 }

    12836. 

  12836. 

    12837. 

  12837.                 if (!(result.Method == method)) return 1;

    12838. 

  12838. 

    12839. 

  12839.                 if (obj == null)

    12840. 

  12840.                 {

    12841. 

  12841.                     if (result.Object != null)

    12842. 

  12842.                     {

    12843. 

  12843.                         Console.WriteLine("Expected object to be null.");

    12844. 

  12844.                         return 1;

    12845. 

  12845.                     }

    12846. 

  12846.                 }

    12847. 

  12847.                 else

    12848. 

  12848.                 {

    12849. 

  12849.                     if (!(result.Object.Equals(obj)))

    12850. 

  12850.                     {

    12851. 

  12851.                         Console.WriteLine("Object on which call is made is different from the result.");

    12852. 

  12852.                         return 1;

    12853. 

  12853.                     }

    12854. 

  12854.                 }

    12855. 

  12855. 

    12856. 

  12856.                 if (!(result.ToString() == str))

    12857. 

  12857.                 {

    12858. 

  12858.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12859. 

  12859.                     return 1;

    12860. 

  12860.                 }

    12861. 

  12861. 

    12862. 

  12862.                 if (result.Arguments.Count != arguments.Length) return 1;

    12863. 

  12863. 

    12864. 

  12864.                 for (int i = 0; i < arguments.Length; i++)

    12865. 

  12865.                 {

    12866. 

  12866.                     if (result.Arguments[i] != arguments[i]) return 1;

    12867. 

  12867.                 }

    12868. 

  12868. 

    12869. 

  12869.                 return 0;

    12870. 

  12870.             }

    12871. 

  12871. 

    12872. 

  12872.             public static int VerifyTypeBinaryParms(TypeBinaryExpression result, ExpressionType et, Type type, Expression expr, Type typeop, string str)

    12873. 

  12873.             {

    12874. 

  12874.                 if (!(result.NodeType == et))

    12875. 

  12875.                 {

    12876. 

  12876.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12877. 

  12877.                     return 1;

    12878. 

  12878.                 }

    12879. 

  12879.                 if (!(result.Type == type))

    12880. 

  12880.                 {

    12881. 

  12881.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12882. 

  12882.                     return 1;

    12883. 

  12883.                 }

    12884. 

  12884. 

    12885. 

  12885.                 if (expr == null)

    12886. 

  12886.                 {

    12887. 

  12887.                     Console.WriteLine("expr was null.");

    12888. 

  12888.                     if (result.Expression != null) return 1;

    12889. 

  12889.                 }

    12890. 

  12890.                 else

    12891. 

  12891.                 {

    12892. 

  12892.                     if (!(result.Expression.Equals(expr)))

    12893. 

  12893.                     {

    12894. 

  12894.                         return 1;

    12895. 

  12895.                     }

    12896. 

  12896.                 }

    12897. 

  12897. 

    12898. 

  12898.                 if (!(result.TypeOperand == typeop)) return 1;

    12899. 

  12899. 

    12900. 

  12900.                 if (!(result.ToString() == str))

    12901. 

  12901.                 {

    12902. 

  12902.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    12903. 

  12903.                     return 1;

    12904. 

  12904.                 }

    12905. 

  12905. 

    12906. 

  12906.                 return 0;

    12907. 

  12907.             }

    12908. 

  12908. 

    12909. 

  12909.             public static int VerifyConditionalParms(ConditionalExpression result, ExpressionType et, Type type, Expression test, Expression ifTrue, Expression ifFalse, string str)

    12910. 

  12910.             {

    12911. 

  12911.                 if (!(result.NodeType == et))

    12912. 

  12912.                 {

    12913. 

  12913.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12914. 

  12914.                     return 1;

    12915. 

  12915.                 }

    12916. 

  12916.                 if (!(result.Type == type))

    12917. 

  12917.                 {

    12918. 

  12918.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12919. 

  12919.                     return 1;

    12920. 

  12920.                 }

    12921. 

  12921. 

    12922. 

  12922.                 if (test == null)

    12923. 

  12923.                 {

    12924. 

  12924.                     if (result.Test != null) return 1;

    12925. 

  12925.                 }

    12926. 

  12926.                 else

    12927. 

  12927.                 {

    12928. 

  12928.                     if (!(result.Test.Equals(test))) return 1;

    12929. 

  12929.                 }

    12930. 

  12930. 

    12931. 

  12931.                 if (ifTrue == null)

    12932. 

  12932.                 {

    12933. 

  12933.                     if (result.IfTrue != null) return 1;

    12934. 

  12934.                 }

    12935. 

  12935.                 else

    12936. 

  12936.                 {

    12937. 

  12937.                     if (!(result.IfTrue.Equals(ifTrue))) return 1;

    12938. 

  12938.                 }

    12939. 

  12939. 

    12940. 

  12940.                 if (ifFalse == null)

    12941. 

  12941.                 {

    12942. 

  12942.                     if (result.IfFalse != null) return 1;

    12943. 

  12943.                 }

    12944. 

  12944.                 else

    12945. 

  12945.                 {

    12946. 

  12946.                     if (!(result.IfFalse.Equals(ifFalse))) return 1;

    12947. 

  12947.                 }

    12948. 

  12948. 

    12949. 

  12949.                 if (!(result.ToString() == str)) return 1;

    12950. 

  12950. 

    12951. 

  12951.                 return 0;

    12952. 

  12952.             }

    12953. 

  12953. 

    12954. 

  12954.             public static int VerifyMemberParms(MemberExpression result, ExpressionType et, Type type, Expression exp_expr, MemberInfo exp_member, string str)

    12955. 

  12955.             {

    12956. 

  12956.                 if (!(result.NodeType == et))

    12957. 

  12957.                 {

    12958. 

  12958.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    12959. 

  12959.                     return 1;

    12960. 

  12960.                 }

    12961. 

  12961.                 if (!(result.Type == type))

    12962. 

  12962.                 {

    12963. 

  12963.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    12964. 

  12964.                     return 1;

    12965. 

  12965.                 }

    12966. 

  12966. 

    12967. 

  12967.                 if (exp_expr == null)

    12968. 

  12968.                 {

    12969. 

  12969.                     if (result.Expression != null)

    12970. 

  12970.                     {

    12971. 

  12971.                         Console.WriteLine("Expression is not null: " + result.Expression.ToString());

    12972. 

  12972.                         return 1;

    12973. 

  12973.                     }

    12974. 

  12974.                 }

    12975. 

  12975.                 else

    12976. 

  12976.                 {

    12977. 

  12977.                     if (!(result.Expression.Equals(exp_expr)))

    12978. 

  12978.                     {

    12979. 

  12979.                         Console.WriteLine("Unexpected Expression: " + result.Expression.ToString());

    12980. 

  12980.                         return 1;

    12981. 

  12981.                     }

    12982. 

  12982.                 }

    12983. 

  12983. 

    12984. 

  12984.                 if (!(result.Member == exp_member))

    12985. 

  12985.                 {

    12986. 

  12986.                     Console.WriteLine("Unexpected result member: " + result.Member.ToString());

    12987. 

  12987.                     return 1;

    12988. 

  12988.                 }

    12989. 

  12989. 

    12990. 

  12990.                 if (!(result.ToString() == str))

    12991. 

  12991.                 {

    12992. 

  12992.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    12993. 

  12993.                     return 1;

    12994. 

  12994.                 }

    12995. 

  12995. 

    12996. 

  12996.                 return 0;

    12997. 

  12997.             }

    12998. 

  12998. 

    12999. 

  12999.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments, params MemberInfo[] members)

    13000. 

  13000.             {

    13001. 

  13001.                 if (!(result.NodeType == et))

    13002. 

  13002.                 {

    13003. 

  13003.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13004. 

  13004.                     return 1;

    13005. 

  13005.                 }

    13006. 

  13006.                 if (!(result.Type == type))

    13007. 

  13007.                 {

    13008. 

  13008.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13009. 

  13009.                     return 1;

    13010. 

  13010.                 }

    13011. 

  13011. 

    13012. 

  13012.                 if (!(result.Constructor == constructor))

    13013. 

  13013.                 {

    13014. 

  13014.                     Console.WriteLine("Unexpected constructor");

    13015. 

  13015.                     return 1;

    13016. 

  13016.                 }

    13017. 

  13017. 

    13018. 

  13018.                 if (!(result.ToString() == str))

    13019. 

  13019.                 {

    13020. 

  13020.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13021. 

  13021.                     return 1;

    13022. 

  13022.                 }

    13023. 

  13023. 

    13024. 

  13024.                 if (arguments == null)

    13025. 

  13025.                 {

    13026. 

  13026.                     if (result.Arguments.Count != 0)

    13027. 

  13027.                     {

    13028. 

  13028.                         Console.WriteLine("More than one argument supplied: " + result.Arguments.Count);

    13029. 

  13029.                         return 1;

    13030. 

  13030.                     }

    13031. 

  13031.                 }

    13032. 

  13032.                 else

    13033. 

  13033.                 {

    13034. 

  13034.                     if (result.Arguments.Count != arguments.Length)

    13035. 

  13035.                     {

    13036. 

  13036.                         Console.WriteLine("Different number of arguments obtained: " + result.Arguments.Count);

    13037. 

  13037.                         return 1;

    13038. 

  13038.                     }

    13039. 

  13039.                     for (int i = 0; i < arguments.Length; i++)

    13040. 

  13040.                     {

    13041. 

  13041.                         if (result.Arguments[i] != arguments[i])

    13042. 

  13042.                         {

    13043. 

  13043.                             Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    13044. 

  13044.                             return 1;

    13045. 

  13045.                         }

    13046. 

  13046.                     }

    13047. 

  13047.                 }

    13048. 

  13048. 

    13049. 

  13049.                 if (result.Members == null)

    13050. 

  13050.                 {

    13051. 

  13051.                     Console.WriteLine("result.Members was null");

    13052. 

  13052.                     return 1;

    13053. 

  13053.                 }

    13054. 

  13054. 

    13055. 

  13055.                 if (members == null)

    13056. 

  13056.                 {

    13057. 

  13057.                     if (result.Members.Count != 0)

    13058. 

  13058.                     {

    13059. 

  13059.                         Console.WriteLine("Got more than zero members");

    13060. 

  13060.                         return 1;

    13061. 

  13061.                     }

    13062. 

  13062.                 }

    13063. 

  13063.                 else

    13064. 

  13064.                 {

    13065. 

  13065.                     if (result.Members.Count != members.Length)

    13066. 

  13066.                     {

    13067. 

  13067.                         Console.WriteLine("Got an unexpected number of members: " + result.Members.Count);

    13068. 

  13068.                         return 1;

    13069. 

  13069.                     }

    13070. 

  13070. 

    13071. 

  13071.                     for (int i = 0; i < members.Length; i++)

    13072. 

  13072.                     {

    13073. 

  13073.                         if (result.Members[i] != members[i])

    13074. 

  13074.                         {

    13075. 

  13075.                             Console.WriteLine("Member " + i.ToString() + " is different than expected: Expected " + members[i].ToString() + " and got " + result.Members[i].ToString());

    13076. 

  13076.                             return 1;

    13077. 

  13077.                         }

    13078. 

  13078.                     }

    13079. 

  13079.                 }

    13080. 

  13080. 

    13081. 

  13081.                 return 0;

    13082. 

  13082.             }

    13083. 

  13083. 

    13084. 

  13084.             public static int VerifyNewParms(NewExpression result, ExpressionType et, Type type, ConstructorInfo constructor, string str, Expression[] arguments)

    13085. 

  13085.             {

    13086. 

  13086.                 if (!(result.NodeType == et))

    13087. 

  13087.                 {

    13088. 

  13088.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13089. 

  13089.                     return 1;

    13090. 

  13090.                 }

    13091. 

  13091.                 if (!(result.Type == type))

    13092. 

  13092.                 {

    13093. 

  13093.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13094. 

  13094.                     return 1;

    13095. 

  13095.                 }

    13096. 

  13096. 

    13097. 

  13097.                 if (!(result.Constructor == constructor))

    13098. 

  13098.                 {

    13099. 

  13099.                     Console.WriteLine("Constructor is different from expected.");

    13100. 

  13100.                     return 1;

    13101. 

  13101.                 }

    13102. 

  13102. 

    13103. 

  13103.                 if (!(result.ToString() == str))

    13104. 

  13104.                 {

    13105. 

  13105.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13106. 

  13106.                     return 1;

    13107. 

  13107.                 }

    13108. 

  13108. 

    13109. 

  13109.                 if (result.Arguments.Count != arguments.Length)

    13110. 

  13110.                 {

    13111. 

  13111.                     Console.WriteLine("Different number of arguments: " + result.Arguments.Count);

    13112. 

  13112.                     return 1;

    13113. 

  13113.                 }

    13114. 

  13114. 

    13115. 

  13115.                 for (int i = 0; i < arguments.Length; i++)

    13116. 

  13116.                 {

    13117. 

  13117.                     if (result.Arguments[i] != arguments[i])

    13118. 

  13118.                     {

    13119. 

  13119.                         Console.WriteLine("Argument " + i.ToString() + " is different than expected: Expected " + arguments[i].ToString() + " and got " + result.Arguments[i].ToString());

    13120. 

  13120.                         return 1;

    13121. 

  13121.                     }

    13122. 

  13122.                 }

    13123. 

  13123. 

    13124. 

  13124.                 if (result.Members != null)

    13125. 

  13125.                 {

    13126. 

  13126.                     Console.WriteLine("result.Members isn't null");

    13127. 

  13127.                     return 1;

    13128. 

  13128.                 }

    13129. 

  13129. 

    13130. 

  13130.                 return 0;

    13131. 

  13131.             }

    13132. 

  13132. 

    13133. 

  13133.             public static int VerifyListInitParms(ListInitExpression result, ExpressionType et, Type type, NewExpression newExpression, string str, params ElementInit[] initializers)

    13134. 

  13134.             {

    13135. 

  13135.                 if (!(result.NodeType == et))

    13136. 

  13136.                 {

    13137. 

  13137.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13138. 

  13138.                     return 1;

    13139. 

  13139.                 }

    13140. 

  13140.                 if (!(result.Type == type))

    13141. 

  13141.                 {

    13142. 

  13142.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13143. 

  13143.                     return 1;

    13144. 

  13144.                 }

    13145. 

  13145. 

    13146. 

  13146.                 if (!(result.NewExpression == newExpression)) return 1;

    13147. 

  13147. 

    13148. 

  13148.                 if (!(result.ToString() == str))

    13149. 

  13149.                 {

    13150. 

  13150.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13151. 

  13151.                     return 1;

    13152. 

  13152.                 }

    13153. 

  13153. 

    13154. 

  13154.                 if (result.Initializers.Count != initializers.Length) return 1;

    13155. 

  13155. 

    13156. 

  13156.                 for (int i = 0; i < initializers.Length; i++)

    13157. 

  13157.                 {

    13158. 

  13158.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    13159. 

  13159. 

    13160. 

  13160.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    13161. 

  13161. 

    13162. 

  13162.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    13163. 

  13163.                     {

    13164. 

  13164.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    13165. 

  13165.                     }

    13166. 

  13166.                 }

    13167. 

  13167. 

    13168. 

  13168.                 return 0;

    13169. 

  13169.             }

    13170. 

  13170. 

    13171. 

  13171.             public static int VerifyElementInitParms(ElementInit result, MethodInfo exp_mi, string str, params Expression[] args)

    13172. 

  13172.             {

    13173. 

  13173.                 if (result.AddMethod != exp_mi) return 1;

    13174. 

  13174.                 if (!(result.ToString() == str))

    13175. 

  13175.                 {

    13176. 

  13176.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13177. 

  13177.                     return 1;

    13178. 

  13178.                 }

    13179. 

  13179. 

    13180. 

  13180.                 if (result.Arguments.Count != args.Length) return 1;

    13181. 

  13181. 

    13182. 

  13182.                 for (int i = 0; i < args.Length; i++)

    13183. 

  13183.                 {

    13184. 

  13184.                     if (result.Arguments[i] != args[i]) return 1;

    13185. 

  13185.                 }

    13186. 

  13186. 

    13187. 

  13187.                 return 0;

    13188. 

  13188.             }

    13189. 

  13189. 

    13190. 

  13190.             public static int VerifyMemberAssignmentParms(MemberAssignment result, MemberBindingType bt, Expression expr, MemberInfo member, string str)

    13191. 

  13191.             {

    13192. 

  13192.                 if (!(result.BindingType == bt)) return 1;

    13193. 

  13193.                 if (!(result.Expression == expr)) return 1;

    13194. 

  13194.                 if (!(result.Member.Equals(member))) return 1;

    13195. 

  13195.                 if (!(result.ToString() == str))

    13196. 

  13196.                 {

    13197. 

  13197.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13198. 

  13198.                     return 1;

    13199. 

  13199.                 }

    13200. 

  13200. 

    13201. 

  13201.                 return 0;

    13202. 

  13202.             }

    13203. 

  13203. 

    13204. 

  13204.             public static int VerifyMemberListBindParms(MemberListBinding result, MemberBindingType bt, ElementInit[] initializers, MemberInfo member, string str)

    13205. 

  13205.             {

    13206. 

  13206.                 if (!(result.BindingType == bt)) return 1;

    13207. 

  13207. 

    13208. 

  13208.                 if (!(result.Member.Equals(member))) return 1;

    13209. 

  13209.                 if (!(result.ToString() == str))

    13210. 

  13210.                 {

    13211. 

  13211.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13212. 

  13212.                     return 1;

    13213. 

  13213.                 }

    13214. 

  13214. 

    13215. 

  13215.                 if (result.Initializers.Count != initializers.Length) return 1;

    13216. 

  13216. 

    13217. 

  13217.                 for (int i = 0; i < initializers.Length; i++)

    13218. 

  13218.                 {

    13219. 

  13219.                     if (result.Initializers[i].AddMethod != initializers[i].AddMethod) return 1;

    13220. 

  13220. 

    13221. 

  13221.                     if (result.Initializers[i].Arguments.Count != initializers[i].Arguments.Count) return 1;

    13222. 

  13222. 

    13223. 

  13223.                     for (int j = 0; j < result.Initializers[i].Arguments.Count; j++)

    13224. 

  13224.                     {

    13225. 

  13225.                         if (result.Initializers[i].Arguments[j] != initializers[i].Arguments[j]) return 1;

    13226. 

  13226.                     }

    13227. 

  13227.                 }

    13228. 

  13228. 

    13229. 

  13229. 

    13230. 

  13230.                 return 0;

    13231. 

  13231.             }

    13232. 

  13232. 

    13233. 

  13233.             public static int VerifyMemberMemberBindParms(MemberMemberBinding result, MemberBindingType bt, MemberBinding[] bindings, MemberInfo member, string str)

    13234. 

  13234.             {

    13235. 

  13235.                 if (!(result.BindingType == bt)) return 1;

    13236. 

  13236. 

    13237. 

  13237.                 if (!(result.Member.Equals(member))) return 1;

    13238. 

  13238.                 if (!(result.ToString() == str))

    13239. 

  13239.                 {

    13240. 

  13240.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13241. 

  13241.                     return 1;

    13242. 

  13242.                 }

    13243. 

  13243. 

    13244. 

  13244.                 if (result.Bindings.Count != bindings.Length) return 1;

    13245. 

  13245. 

    13246. 

  13246.                 for (int i = 0; i < bindings.Length; i++)

    13247. 

  13247.                 {

    13248. 

  13248.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    13249. 

  13249.                 }

    13250. 

  13250. 

    13251. 

  13251.                 return 0;

    13252. 

  13252.             }

    13253. 

  13253. 

    13254. 

  13254.             public static int VerifyMemberInitParms(MemberInitExpression result, ExpressionType et, Type type, NewExpression newExpr, MemberBinding[] bindings, string str)

    13255. 

  13255.             {

    13256. 

  13256.                 if (!(result.NodeType == et))

    13257. 

  13257.                 {

    13258. 

  13258.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13259. 

  13259.                     return 1;

    13260. 

  13260.                 }

    13261. 

  13261.                 if (!(result.Type == type))

    13262. 

  13262.                 {

    13263. 

  13263.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13264. 

  13264.                     return 1;

    13265. 

  13265.                 }

    13266. 

  13266.                 if (!(result.NewExpression.Equals(newExpr))) return 1;

    13267. 

  13267.                 if (!(result.ToString() == str)) return 1;

    13268. 

  13268. 

    13269. 

  13269.                 if (result.Bindings.Count != bindings.Length) return 1;

    13270. 

  13270. 

    13271. 

  13271.                 for (int i = 0; i < bindings.Length; i++)

    13272. 

  13272.                 {

    13273. 

  13273.                     if (!(result.Bindings[i].Equals(bindings[i]))) return 1;

    13274. 

  13274.                 }

    13275. 

  13275. 

    13276. 

  13276.                 return 0;

    13277. 

  13277.             }

    13278. 

  13278. 

    13279. 

  13279.             public static int VerifyNewArrayParms(NewArrayExpression result, ExpressionType et, Type type, Expression[] expr, string str)

    13280. 

  13280.             {

    13281. 

  13281.                 if (!(result.NodeType == et))

    13282. 

  13282.                 {

    13283. 

  13283.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13284. 

  13284.                     return 1;

    13285. 

  13285.                 }

    13286. 

  13286.                 if (!(result.Type == type))

    13287. 

  13287.                 {

    13288. 

  13288.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13289. 

  13289.                     return 1;

    13290. 

  13290.                 }

    13291. 

  13291. 

    13292. 

  13292.                 if (result.Expressions.Count != expr.Length) return 1;

    13293. 

  13293. 

    13294. 

  13294.                 for (int i = 0; i < expr.Length; i++)

    13295. 

  13295.                 {

    13296. 

  13296.                     if (!(result.Expressions[i].Equals(expr[i]))) return 1;

    13297. 

  13297.                 }

    13298. 

  13298.                 if (!(result.ToString() == str))

    13299. 

  13299.                 {

    13300. 

  13300.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13301. 

  13301.                     return 1;

    13302. 

  13302.                 }

    13303. 

  13303. 

    13304. 

  13304.                 return 0;

    13305. 

  13305.             }

    13306. 

  13306. 

    13307. 

  13307.             public static int VerifyParameterParms(ParameterExpression result, ExpressionType et, Type type, string name, string str)

    13308. 

  13308.             {

    13309. 

  13309.                 if (!(result.NodeType == et))

    13310. 

  13310.                 {

    13311. 

  13311.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13312. 

  13312.                     return 1;

    13313. 

  13313.                 }

    13314. 

  13314.                 if (!(result.Type == type))

    13315. 

  13315.                 {

    13316. 

  13316.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13317. 

  13317.                     return 1;

    13318. 

  13318.                 }

    13319. 

  13319.                 if (!(result.Name == name)) return 1;

    13320. 

  13320. 

    13321. 

  13321.                 if (!(result.ToString() == str))

    13322. 

  13322.                 {

    13323. 

  13323.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13324. 

  13324.                     return 1;

    13325. 

  13325.                 }

    13326. 

  13326. 

    13327. 

  13327.                 return 0;

    13328. 

  13328.             }

    13329. 

  13329. 

    13330. 

  13330.             public static int VerifyLambdaParms(LambdaExpression result, ExpressionType et, Type type, Expression expr, ParameterExpression[] parms, string str)

    13331. 

  13331.             {

    13332. 

  13332.                 if (!(result.NodeType == et))

    13333. 

  13333.                 {

    13334. 

  13334.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13335. 

  13335.                     return 1;

    13336. 

  13336.                 }

    13337. 

  13337.                 if (!(result.Type == type))

    13338. 

  13338.                 {

    13339. 

  13339.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13340. 

  13340.                     return 1;

    13341. 

  13341.                 }

    13342. 

  13342. 

    13343. 

  13343.                 if (expr == null)

    13344. 

  13344.                 {

    13345. 

  13345.                     if (result.Body != null) return 1;

    13346. 

  13346.                 }

    13347. 

  13347.                 else

    13348. 

  13348.                 {

    13349. 

  13349.                     if (!(result.Body.Equals(expr))) return 1;

    13350. 

  13350.                 }

    13351. 

  13351. 

    13352. 

  13352.                 if (result.Parameters.Count != parms.Length) return 1;

    13353. 

  13353. 

    13354. 

  13354.                 for (int i = 0; i < parms.Length; i++)

    13355. 

  13355.                 {

    13356. 

  13356.                     if (!(result.Parameters[i].Equals(parms[i]))) return 1;

    13357. 

  13357.                 }

    13358. 

  13358. 

    13359. 

  13359.                 if (!(result.ToString() == str))

    13360. 

  13360.                 {

    13361. 

  13361.                     Console.WriteLine("Unexpected result: " + result.ToString() + " - Expected: " + str);

    13362. 

  13362.                     return 1;

    13363. 

  13363.                 }

    13364. 

  13364. 

    13365. 

  13365.                 return 0;

    13366. 

  13366.             }

    13367. 

  13367. 

    13368. 

  13368.             public static int VerifyInvokeParms(InvocationExpression result, ExpressionType et, Type type, Expression expr, Expression[] args, string str)

    13369. 

  13369.             {

    13370. 

  13370.                 if (!(result.NodeType == et))

    13371. 

  13371.                 {

    13372. 

  13372.                     Console.WriteLine("Unexpected result node type: " + result.NodeType.ToString());

    13373. 

  13373.                     return 1;

    13374. 

  13374.                 }

    13375. 

  13375.                 if (!(result.Type == type))

    13376. 

  13376.                 {

    13377. 

  13377.                     Console.WriteLine("Unexpected result type: " + result.Type.ToString());

    13378. 

  13378.                     return 1;

    13379. 

  13379.                 }

    13380. 

  13380. 

    13381. 

  13381.                 if (expr == null)

    13382. 

  13382.                 {

    13383. 

  13383.                     if (result.Expression != null) return 1;

    13384. 

  13384.                 }

    13385. 

  13385.                 else

    13386. 

  13386.                 {

    13387. 

  13387.                     if (!(result.Expression.Equals(expr))) return 1;

    13388. 

  13388.                 }

    13389. 

  13389. 

    13390. 

  13390.                 if (result.Arguments.Count != args.Length) return 1;

    13391. 

  13391. 

    13392. 

  13392.                 for (int i = 0; i < args.Length; i++)

    13393. 

  13393.                 {

    13394. 

  13394.                     if (!(result.Arguments[i].Equals(args[i])))

    13395. 

  13395.                     {

    13396. 

  13396.                         return 1;

    13397. 

  13397.                     }

    13398. 

  13398.                 }

    13399. 

  13399. 

    13400. 

  13400.                 if (result.ToString() != str)

    13401. 

  13401.                 {

    13402. 

  13402.                     Console.WriteLine("Expected: " + str + " Actual: " + result.ToString());

    13403. 

  13403.                     return 1;

    13404. 

  13404.                 }

    13405. 

  13405. 

    13406. 

  13406.                 return 0;

    13407. 

  13407.             }

    13408. 

  13408.         }

    13409. 

  13409. 

    13410. 

  13410. 

    13411. 

  13411. 

    13412. 

  13412.         namespace Not

    13413. 

  13413.         {

    13414. 

  13414.             // Declaring user-defined types for testing

    13415. 

  13415.             struct TC1

    13416. 

  13416.             {

    13417. 

  13417.                 public static TC1 operator !(TC1 c)

    13418. 

  13418.                 {

    13419. 

  13419.                     return new TC1();

    13420. 

  13420.                 }

    13421. 

  13421. 

    13422. 

  13422.                 public static TC1 operator ~(TC1 c)

    13423. 

  13423.                 {

    13424. 

  13424.                     return new TC1();

    13425. 

  13425.                 }

    13426. 

  13426.             }

    13427. 

  13427. 

    13428. 

  13428.             struct TC2

    13429. 

  13429.             {

    13430. 

  13430.                 public static TC2 operator ~(TC2 c)

    13431. 

  13431.                 {

    13432. 

  13432.                     return new TC2();

    13433. 

  13433.                 }

    13434. 

  13434.             }

    13435. 

  13435. 

    13436. 

  13436.             struct TC3

    13437. 

  13437.             {

    13438. 

  13438.                 public static TC3 Meth1(TC3 c)

    13439. 

  13439.                 {

    13440. 

  13440.                     return new TC3();

    13441. 

  13441.                 }

    13442. 

  13442.             }

    13443. 

  13443.         }

    13444. 

  13444. 

    13445. 

  13445.     }

    13446. 

  13446. 

    13447. 

  13447. }

    13448. 

  13448.