PageRenderTime 65ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 2ms

/IronPython_Main/Runtime/Tests/ETScenariosCSLinq/CSLinq/ExpressionCompiler/constant_BackSl_test0.cs

#
C# | 17067 lines | 13916 code | 2661 blank | 490 comment | 1717 complexity | 22396c4bece7d3cee26efab926f9d6e0 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;

    10. 

  10. namespace ExpressionCompiler { 

    11. 

  11. 	

    12. 

  12. 			

    13. 

  13. 			//-------- Scenario 1706

    14. 

  14. 			namespace Scenario1706{

    15. 

  15. 				

    16. 

  16. 				public class Test

    17. 

  17. 				{

    18. 

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

    19. 

  19. 			    public static Expression check0__() {

    20. 

  20. 			       if(Main() != 0 ) {

    21. 

  21. 			           throw new Exception();

    22. 

  22. 			       } else { 

    23. 

  23. 			           return Expression.Constant(0);

    24. 

  24. 			       }

    25. 

  25. 			    }

    26. 

  26. 				public     static int Main()

    27. 

  27. 				    {

    28. 

  28. 				        Ext.StartCapture();

    29. 

  29. 				        bool success = false;

    30. 

  30. 				        try

    31. 

  31. 				        {

    32. 

  32. 				            success = check0();

    33. 

  33. 				        }

    34. 

  34. 				        finally

    35. 

  35. 				        {

    36. 

  36. 				            Ext.StopCapture();

    37. 

  37. 				        }

    38. 

  38. 				        return success ? 0 : 1;

    39. 

  39. 				    }

    40. 

  40. 				

    41. 

  41. 				    static bool check0() {

    42. 

  42. 				        foreach (byte val in new byte[] { 0, 1, byte.MaxValue }) {

    43. 

  43. 				            if (!check0(val)) {

    44. 

  44. 				                return false;

    45. 

  45. 				            }

    46. 

  46. 				        }

    47. 

  47. 				        return true;

    48. 

  48. 				    }

    49. 

  49. 				

    50. 

  50. 				    static bool check0(byte val) {

    51. 

  51. 				        Expression<Func<byte>> e =

    52. 

  52. 				            Expression.Lambda<Func<byte>>(

    53. 

  53. 				                Expression.Constant(val, typeof(byte)),

    54. 

  54. 				                new System.Collections.Generic.List<ParameterExpression>());

    55. 

  55. 				        Func<byte> f = e.Compile();

    56. 

  56. 				        return object.Equals(f(), val);

    57. 

  57. 				    }

    58. 

  58. 				}

    59. 

  59. 			

    60. 

  60. 			

    61. 

  61. 			public  static class Ext {

    62. 

  62. 			    public static void StartCapture() {

    63. 

  63. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    64. 

  64. 			//        m.Invoke(null, new object[] { "test.dll" });

    65. 

  65. 			    }

    66. 

  66. 			

    67. 

  67. 			    public static void StopCapture() {

    68. 

  68. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    69. 

  69. 			//        m.Invoke(null, new object[0]);

    70. 

  70. 			    }

    71. 

  71. 			

    72. 

  72. 			    public static bool IsIntegralOrEnum(Type type) {

    73. 

  73. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    74. 

  74. 			            case TypeCode.Byte:

    75. 

  75. 			            case TypeCode.SByte:

    76. 

  76. 			            case TypeCode.Int16:

    77. 

  77. 			            case TypeCode.Int32:

    78. 

  78. 			            case TypeCode.Int64:

    79. 

  79. 			            case TypeCode.UInt16:

    80. 

  80. 			            case TypeCode.UInt32:

    81. 

  81. 			            case TypeCode.UInt64:

    82. 

  82. 			                return true;

    83. 

  83. 			            default:

    84. 

  84. 			                return false;

    85. 

  85. 			        }

    86. 

  86. 			    }

    87. 

  87. 			

    88. 

  88. 			    public static bool IsFloating(Type type) {

    89. 

  89. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    90. 

  90. 			            case TypeCode.Single:

    91. 

  91. 			            case TypeCode.Double:

    92. 

  92. 			                return true;

    93. 

  93. 			            default:

    94. 

  94. 			                return false;

    95. 

  95. 			        }

    96. 

  96. 			    }

    97. 

  97. 			

    98. 

  98. 			    public static Type GetNonNullableType(Type type) {

    99. 

  99. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    100. 

  100. 			                type.GetGenericArguments()[0] :

    101. 

  101. 			                type;

    102. 

  102. 			    }

    103. 

  103. 			}

    104. 

  104. 			

    105. 

  105. 		

    106. 

  106. 	}

    107. 

  107. 			

    108. 

  108. 			//-------- Scenario 1707

    109. 

  109. 			namespace Scenario1707{

    110. 

  110. 				

    111. 

  111. 				public class Test

    112. 

  112. 				{

    113. 

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

    114. 

  114. 			    public static Expression check1__() {

    115. 

  115. 			       if(Main() != 0 ) {

    116. 

  116. 			           throw new Exception();

    117. 

  117. 			       } else { 

    118. 

  118. 			           return Expression.Constant(0);

    119. 

  119. 			       }

    120. 

  120. 			    }

    121. 

  121. 				public     static int Main()

    122. 

  122. 				    {

    123. 

  123. 				        Ext.StartCapture();

    124. 

  124. 				        bool success = false;

    125. 

  125. 				        try

    126. 

  126. 				        {

    127. 

  127. 				            success = check1();

    128. 

  128. 				        }

    129. 

  129. 				        finally

    130. 

  130. 				        {

    131. 

  131. 				            Ext.StopCapture();

    132. 

  132. 				        }

    133. 

  133. 				        return success ? 0 : 1;

    134. 

  134. 				    }

    135. 

  135. 				

    136. 

  136. 				    static bool check1() {

    137. 

  137. 				        foreach (ushort val in new ushort[] { 0, 1, ushort.MaxValue }) {

    138. 

  138. 				            if (!check1(val)) {

    139. 

  139. 				                return false;

    140. 

  140. 				            }

    141. 

  141. 				        }

    142. 

  142. 				        return true;

    143. 

  143. 				    }

    144. 

  144. 				

    145. 

  145. 				    static bool check1(ushort val) {

    146. 

  146. 				        Expression<Func<ushort>> e =

    147. 

  147. 				            Expression.Lambda<Func<ushort>>(

    148. 

  148. 				                Expression.Constant(val, typeof(ushort)),

    149. 

  149. 				                new System.Collections.Generic.List<ParameterExpression>());

    150. 

  150. 				        Func<ushort> f = e.Compile();

    151. 

  151. 				        return object.Equals(f(), val);

    152. 

  152. 				    }

    153. 

  153. 				}

    154. 

  154. 			

    155. 

  155. 			

    156. 

  156. 			public  static class Ext {

    157. 

  157. 			    public static void StartCapture() {

    158. 

  158. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    159. 

  159. 			//        m.Invoke(null, new object[] { "test.dll" });

    160. 

  160. 			    }

    161. 

  161. 			

    162. 

  162. 			    public static void StopCapture() {

    163. 

  163. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    164. 

  164. 			//        m.Invoke(null, new object[0]);

    165. 

  165. 			    }

    166. 

  166. 			

    167. 

  167. 			    public static bool IsIntegralOrEnum(Type type) {

    168. 

  168. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    169. 

  169. 			            case TypeCode.Byte:

    170. 

  170. 			            case TypeCode.SByte:

    171. 

  171. 			            case TypeCode.Int16:

    172. 

  172. 			            case TypeCode.Int32:

    173. 

  173. 			            case TypeCode.Int64:

    174. 

  174. 			            case TypeCode.UInt16:

    175. 

  175. 			            case TypeCode.UInt32:

    176. 

  176. 			            case TypeCode.UInt64:

    177. 

  177. 			                return true;

    178. 

  178. 			            default:

    179. 

  179. 			                return false;

    180. 

  180. 			        }

    181. 

  181. 			    }

    182. 

  182. 			

    183. 

  183. 			    public static bool IsFloating(Type type) {

    184. 

  184. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    185. 

  185. 			            case TypeCode.Single:

    186. 

  186. 			            case TypeCode.Double:

    187. 

  187. 			                return true;

    188. 

  188. 			            default:

    189. 

  189. 			                return false;

    190. 

  190. 			        }

    191. 

  191. 			    }

    192. 

  192. 			

    193. 

  193. 			    public static Type GetNonNullableType(Type type) {

    194. 

  194. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    195. 

  195. 			                type.GetGenericArguments()[0] :

    196. 

  196. 			                type;

    197. 

  197. 			    }

    198. 

  198. 			}

    199. 

  199. 			

    200. 

  200. 		

    201. 

  201. 	}

    202. 

  202. 			

    203. 

  203. 			//-------- Scenario 1708

    204. 

  204. 			namespace Scenario1708{

    205. 

  205. 				

    206. 

  206. 				public class Test

    207. 

  207. 				{

    208. 

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

    209. 

  209. 			    public static Expression check2__() {

    210. 

  210. 			       if(Main() != 0 ) {

    211. 

  211. 			           throw new Exception();

    212. 

  212. 			       } else { 

    213. 

  213. 			           return Expression.Constant(0);

    214. 

  214. 			       }

    215. 

  215. 			    }

    216. 

  216. 				public     static int Main()

    217. 

  217. 				    {

    218. 

  218. 				        Ext.StartCapture();

    219. 

  219. 				        bool success = false;

    220. 

  220. 				        try

    221. 

  221. 				        {

    222. 

  222. 				            success = check2();

    223. 

  223. 				        }

    224. 

  224. 				        finally

    225. 

  225. 				        {

    226. 

  226. 				            Ext.StopCapture();

    227. 

  227. 				        }

    228. 

  228. 				        return success ? 0 : 1;

    229. 

  229. 				    }

    230. 

  230. 				

    231. 

  231. 				    static bool check2() {

    232. 

  232. 				        foreach (uint val in new uint[] { 0, 1, uint.MaxValue }) {

    233. 

  233. 				            if (!check2(val)) {

    234. 

  234. 				                return false;

    235. 

  235. 				            }

    236. 

  236. 				        }

    237. 

  237. 				        return true;

    238. 

  238. 				    }

    239. 

  239. 				

    240. 

  240. 				    static bool check2(uint val) {

    241. 

  241. 				        Expression<Func<uint>> e =

    242. 

  242. 				            Expression.Lambda<Func<uint>>(

    243. 

  243. 				                Expression.Constant(val, typeof(uint)),

    244. 

  244. 				                new System.Collections.Generic.List<ParameterExpression>());

    245. 

  245. 				        Func<uint> f = e.Compile();

    246. 

  246. 				        return object.Equals(f(), val);

    247. 

  247. 				    }

    248. 

  248. 				}

    249. 

  249. 			

    250. 

  250. 			

    251. 

  251. 			public  static class Ext {

    252. 

  252. 			    public static void StartCapture() {

    253. 

  253. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    254. 

  254. 			//        m.Invoke(null, new object[] { "test.dll" });

    255. 

  255. 			    }

    256. 

  256. 			

    257. 

  257. 			    public static void StopCapture() {

    258. 

  258. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    259. 

  259. 			//        m.Invoke(null, new object[0]);

    260. 

  260. 			    }

    261. 

  261. 			

    262. 

  262. 			    public static bool IsIntegralOrEnum(Type type) {

    263. 

  263. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    264. 

  264. 			            case TypeCode.Byte:

    265. 

  265. 			            case TypeCode.SByte:

    266. 

  266. 			            case TypeCode.Int16:

    267. 

  267. 			            case TypeCode.Int32:

    268. 

  268. 			            case TypeCode.Int64:

    269. 

  269. 			            case TypeCode.UInt16:

    270. 

  270. 			            case TypeCode.UInt32:

    271. 

  271. 			            case TypeCode.UInt64:

    272. 

  272. 			                return true;

    273. 

  273. 			            default:

    274. 

  274. 			                return false;

    275. 

  275. 			        }

    276. 

  276. 			    }

    277. 

  277. 			

    278. 

  278. 			    public static bool IsFloating(Type type) {

    279. 

  279. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    280. 

  280. 			            case TypeCode.Single:

    281. 

  281. 			            case TypeCode.Double:

    282. 

  282. 			                return true;

    283. 

  283. 			            default:

    284. 

  284. 			                return false;

    285. 

  285. 			        }

    286. 

  286. 			    }

    287. 

  287. 			

    288. 

  288. 			    public static Type GetNonNullableType(Type type) {

    289. 

  289. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    290. 

  290. 			                type.GetGenericArguments()[0] :

    291. 

  291. 			                type;

    292. 

  292. 			    }

    293. 

  293. 			}

    294. 

  294. 			

    295. 

  295. 		

    296. 

  296. 	}

    297. 

  297. 			

    298. 

  298. 			//-------- Scenario 1709

    299. 

  299. 			namespace Scenario1709{

    300. 

  300. 				

    301. 

  301. 				public class Test

    302. 

  302. 				{

    303. 

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

    304. 

  304. 			    public static Expression check3__() {

    305. 

  305. 			       if(Main() != 0 ) {

    306. 

  306. 			           throw new Exception();

    307. 

  307. 			       } else { 

    308. 

  308. 			           return Expression.Constant(0);

    309. 

  309. 			       }

    310. 

  310. 			    }

    311. 

  311. 				public     static int Main()

    312. 

  312. 				    {

    313. 

  313. 				        Ext.StartCapture();

    314. 

  314. 				        bool success = false;

    315. 

  315. 				        try

    316. 

  316. 				        {

    317. 

  317. 				            success = check3();

    318. 

  318. 				        }

    319. 

  319. 				        finally

    320. 

  320. 				        {

    321. 

  321. 				            Ext.StopCapture();

    322. 

  322. 				        }

    323. 

  323. 				        return success ? 0 : 1;

    324. 

  324. 				    }

    325. 

  325. 				

    326. 

  326. 				    static bool check3() {

    327. 

  327. 				        foreach (ulong val in new ulong[] { 0, 1, ulong.MaxValue }) {

    328. 

  328. 				            if (!check3(val)) {

    329. 

  329. 				                return false;

    330. 

  330. 				            }

    331. 

  331. 				        }

    332. 

  332. 				        return true;

    333. 

  333. 				    }

    334. 

  334. 				

    335. 

  335. 				    static bool check3(ulong val) {

    336. 

  336. 				        Expression<Func<ulong>> e =

    337. 

  337. 				            Expression.Lambda<Func<ulong>>(

    338. 

  338. 				                Expression.Constant(val, typeof(ulong)),

    339. 

  339. 				                new System.Collections.Generic.List<ParameterExpression>());

    340. 

  340. 				        Func<ulong> f = e.Compile();

    341. 

  341. 				        return object.Equals(f(), val);

    342. 

  342. 				    }

    343. 

  343. 				}

    344. 

  344. 			

    345. 

  345. 			

    346. 

  346. 			public  static class Ext {

    347. 

  347. 			    public static void StartCapture() {

    348. 

  348. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    349. 

  349. 			//        m.Invoke(null, new object[] { "test.dll" });

    350. 

  350. 			    }

    351. 

  351. 			

    352. 

  352. 			    public static void StopCapture() {

    353. 

  353. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    354. 

  354. 			//        m.Invoke(null, new object[0]);

    355. 

  355. 			    }

    356. 

  356. 			

    357. 

  357. 			    public static bool IsIntegralOrEnum(Type type) {

    358. 

  358. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    359. 

  359. 			            case TypeCode.Byte:

    360. 

  360. 			            case TypeCode.SByte:

    361. 

  361. 			            case TypeCode.Int16:

    362. 

  362. 			            case TypeCode.Int32:

    363. 

  363. 			            case TypeCode.Int64:

    364. 

  364. 			            case TypeCode.UInt16:

    365. 

  365. 			            case TypeCode.UInt32:

    366. 

  366. 			            case TypeCode.UInt64:

    367. 

  367. 			                return true;

    368. 

  368. 			            default:

    369. 

  369. 			                return false;

    370. 

  370. 			        }

    371. 

  371. 			    }

    372. 

  372. 			

    373. 

  373. 			    public static bool IsFloating(Type type) {

    374. 

  374. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    375. 

  375. 			            case TypeCode.Single:

    376. 

  376. 			            case TypeCode.Double:

    377. 

  377. 			                return true;

    378. 

  378. 			            default:

    379. 

  379. 			                return false;

    380. 

  380. 			        }

    381. 

  381. 			    }

    382. 

  382. 			

    383. 

  383. 			    public static Type GetNonNullableType(Type type) {

    384. 

  384. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    385. 

  385. 			                type.GetGenericArguments()[0] :

    386. 

  386. 			                type;

    387. 

  387. 			    }

    388. 

  388. 			}

    389. 

  389. 			

    390. 

  390. 		

    391. 

  391. 	}

    392. 

  392. 			

    393. 

  393. 			//-------- Scenario 1710

    394. 

  394. 			namespace Scenario1710{

    395. 

  395. 				

    396. 

  396. 				public class Test

    397. 

  397. 				{

    398. 

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

    399. 

  399. 			    public static Expression check4__() {

    400. 

  400. 			       if(Main() != 0 ) {

    401. 

  401. 			           throw new Exception();

    402. 

  402. 			       } else { 

    403. 

  403. 			           return Expression.Constant(0);

    404. 

  404. 			       }

    405. 

  405. 			    }

    406. 

  406. 				public     static int Main()

    407. 

  407. 				    {

    408. 

  408. 				        Ext.StartCapture();

    409. 

  409. 				        bool success = false;

    410. 

  410. 				        try

    411. 

  411. 				        {

    412. 

  412. 				            success = check4();

    413. 

  413. 				        }

    414. 

  414. 				        finally

    415. 

  415. 				        {

    416. 

  416. 				            Ext.StopCapture();

    417. 

  417. 				        }

    418. 

  418. 				        return success ? 0 : 1;

    419. 

  419. 				    }

    420. 

  420. 				

    421. 

  421. 				    static bool check4() {

    422. 

  422. 				        foreach (sbyte val in new sbyte[] { 0, 1, -1, sbyte.MinValue, sbyte.MaxValue }) {

    423. 

  423. 				            if (!check4(val)) {

    424. 

  424. 				                return false;

    425. 

  425. 				            }

    426. 

  426. 				        }

    427. 

  427. 				        return true;

    428. 

  428. 				    }

    429. 

  429. 				

    430. 

  430. 				    static bool check4(sbyte val) {

    431. 

  431. 				        Expression<Func<sbyte>> e =

    432. 

  432. 				            Expression.Lambda<Func<sbyte>>(

    433. 

  433. 				                Expression.Constant(val, typeof(sbyte)),

    434. 

  434. 				                new System.Collections.Generic.List<ParameterExpression>());

    435. 

  435. 				        Func<sbyte> f = e.Compile();

    436. 

  436. 				        return object.Equals(f(), val);

    437. 

  437. 				    }

    438. 

  438. 				}

    439. 

  439. 			

    440. 

  440. 			

    441. 

  441. 			public  static class Ext {

    442. 

  442. 			    public static void StartCapture() {

    443. 

  443. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    444. 

  444. 			//        m.Invoke(null, new object[] { "test.dll" });

    445. 

  445. 			    }

    446. 

  446. 			

    447. 

  447. 			    public static void StopCapture() {

    448. 

  448. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    449. 

  449. 			//        m.Invoke(null, new object[0]);

    450. 

  450. 			    }

    451. 

  451. 			

    452. 

  452. 			    public static bool IsIntegralOrEnum(Type type) {

    453. 

  453. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    454. 

  454. 			            case TypeCode.Byte:

    455. 

  455. 			            case TypeCode.SByte:

    456. 

  456. 			            case TypeCode.Int16:

    457. 

  457. 			            case TypeCode.Int32:

    458. 

  458. 			            case TypeCode.Int64:

    459. 

  459. 			            case TypeCode.UInt16:

    460. 

  460. 			            case TypeCode.UInt32:

    461. 

  461. 			            case TypeCode.UInt64:

    462. 

  462. 			                return true;

    463. 

  463. 			            default:

    464. 

  464. 			                return false;

    465. 

  465. 			        }

    466. 

  466. 			    }

    467. 

  467. 			

    468. 

  468. 			    public static bool IsFloating(Type type) {

    469. 

  469. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    470. 

  470. 			            case TypeCode.Single:

    471. 

  471. 			            case TypeCode.Double:

    472. 

  472. 			                return true;

    473. 

  473. 			            default:

    474. 

  474. 			                return false;

    475. 

  475. 			        }

    476. 

  476. 			    }

    477. 

  477. 			

    478. 

  478. 			    public static Type GetNonNullableType(Type type) {

    479. 

  479. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    480. 

  480. 			                type.GetGenericArguments()[0] :

    481. 

  481. 			                type;

    482. 

  482. 			    }

    483. 

  483. 			}

    484. 

  484. 			

    485. 

  485. 		

    486. 

  486. 	}

    487. 

  487. 			

    488. 

  488. 			//-------- Scenario 1711

    489. 

  489. 			namespace Scenario1711{

    490. 

  490. 				

    491. 

  491. 				public class Test

    492. 

  492. 				{

    493. 

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

    494. 

  494. 			    public static Expression check5__() {

    495. 

  495. 			       if(Main() != 0 ) {

    496. 

  496. 			           throw new Exception();

    497. 

  497. 			       } else { 

    498. 

  498. 			           return Expression.Constant(0);

    499. 

  499. 			       }

    500. 

  500. 			    }

    501. 

  501. 				public     static int Main()

    502. 

  502. 				    {

    503. 

  503. 				        Ext.StartCapture();

    504. 

  504. 				        bool success = false;

    505. 

  505. 				        try

    506. 

  506. 				        {

    507. 

  507. 				            success = check5();

    508. 

  508. 				        }

    509. 

  509. 				        finally

    510. 

  510. 				        {

    511. 

  511. 				            Ext.StopCapture();

    512. 

  512. 				        }

    513. 

  513. 				        return success ? 0 : 1;

    514. 

  514. 				    }

    515. 

  515. 				

    516. 

  516. 				    static bool check5() {

    517. 

  517. 				        foreach (short val in new short[] { 0, 1, -1, short.MinValue, short.MaxValue }) {

    518. 

  518. 				            if (!check5(val)) {

    519. 

  519. 				                return false;

    520. 

  520. 				            }

    521. 

  521. 				        }

    522. 

  522. 				        return true;

    523. 

  523. 				    }

    524. 

  524. 				

    525. 

  525. 				    static bool check5(short val) {

    526. 

  526. 				        Expression<Func<short>> e =

    527. 

  527. 				            Expression.Lambda<Func<short>>(

    528. 

  528. 				                Expression.Constant(val, typeof(short)),

    529. 

  529. 				                new System.Collections.Generic.List<ParameterExpression>());

    530. 

  530. 				        Func<short> f = e.Compile();

    531. 

  531. 				        return object.Equals(f(), val);

    532. 

  532. 				    }

    533. 

  533. 				}

    534. 

  534. 			

    535. 

  535. 			

    536. 

  536. 			public  static class Ext {

    537. 

  537. 			    public static void StartCapture() {

    538. 

  538. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    539. 

  539. 			//        m.Invoke(null, new object[] { "test.dll" });

    540. 

  540. 			    }

    541. 

  541. 			

    542. 

  542. 			    public static void StopCapture() {

    543. 

  543. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    544. 

  544. 			//        m.Invoke(null, new object[0]);

    545. 

  545. 			    }

    546. 

  546. 			

    547. 

  547. 			    public static bool IsIntegralOrEnum(Type type) {

    548. 

  548. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    549. 

  549. 			            case TypeCode.Byte:

    550. 

  550. 			            case TypeCode.SByte:

    551. 

  551. 			            case TypeCode.Int16:

    552. 

  552. 			            case TypeCode.Int32:

    553. 

  553. 			            case TypeCode.Int64:

    554. 

  554. 			            case TypeCode.UInt16:

    555. 

  555. 			            case TypeCode.UInt32:

    556. 

  556. 			            case TypeCode.UInt64:

    557. 

  557. 			                return true;

    558. 

  558. 			            default:

    559. 

  559. 			                return false;

    560. 

  560. 			        }

    561. 

  561. 			    }

    562. 

  562. 			

    563. 

  563. 			    public static bool IsFloating(Type type) {

    564. 

  564. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    565. 

  565. 			            case TypeCode.Single:

    566. 

  566. 			            case TypeCode.Double:

    567. 

  567. 			                return true;

    568. 

  568. 			            default:

    569. 

  569. 			                return false;

    570. 

  570. 			        }

    571. 

  571. 			    }

    572. 

  572. 			

    573. 

  573. 			    public static Type GetNonNullableType(Type type) {

    574. 

  574. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    575. 

  575. 			                type.GetGenericArguments()[0] :

    576. 

  576. 			                type;

    577. 

  577. 			    }

    578. 

  578. 			}

    579. 

  579. 			

    580. 

  580. 		

    581. 

  581. 	}

    582. 

  582. 			

    583. 

  583. 			//-------- Scenario 1712

    584. 

  584. 			namespace Scenario1712{

    585. 

  585. 				

    586. 

  586. 				public class Test

    587. 

  587. 				{

    588. 

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

    589. 

  589. 			    public static Expression check6__() {

    590. 

  590. 			       if(Main() != 0 ) {

    591. 

  591. 			           throw new Exception();

    592. 

  592. 			       } else { 

    593. 

  593. 			           return Expression.Constant(0);

    594. 

  594. 			       }

    595. 

  595. 			    }

    596. 

  596. 				public     static int Main()

    597. 

  597. 				    {

    598. 

  598. 				        Ext.StartCapture();

    599. 

  599. 				        bool success = false;

    600. 

  600. 				        try

    601. 

  601. 				        {

    602. 

  602. 				            success = check6();

    603. 

  603. 				        }

    604. 

  604. 				        finally

    605. 

  605. 				        {

    606. 

  606. 				            Ext.StopCapture();

    607. 

  607. 				        }

    608. 

  608. 				        return success ? 0 : 1;

    609. 

  609. 				    }

    610. 

  610. 				

    611. 

  611. 				    static bool check6() {

    612. 

  612. 				        foreach (int val in new int[] { 0, 1, -1, int.MinValue, int.MaxValue }) {

    613. 

  613. 				            if (!check6(val)) {

    614. 

  614. 				                return false;

    615. 

  615. 				            }

    616. 

  616. 				        }

    617. 

  617. 				        return true;

    618. 

  618. 				    }

    619. 

  619. 				

    620. 

  620. 				    static bool check6(int val) {

    621. 

  621. 				        Expression<Func<int>> e =

    622. 

  622. 				            Expression.Lambda<Func<int>>(

    623. 

  623. 				                Expression.Constant(val, typeof(int)),

    624. 

  624. 				                new System.Collections.Generic.List<ParameterExpression>());

    625. 

  625. 				        Func<int> f = e.Compile();

    626. 

  626. 				        return object.Equals(f(), val);

    627. 

  627. 				    }

    628. 

  628. 				}

    629. 

  629. 			

    630. 

  630. 			

    631. 

  631. 			public  static class Ext {

    632. 

  632. 			    public static void StartCapture() {

    633. 

  633. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    634. 

  634. 			//        m.Invoke(null, new object[] { "test.dll" });

    635. 

  635. 			    }

    636. 

  636. 			

    637. 

  637. 			    public static void StopCapture() {

    638. 

  638. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    639. 

  639. 			//        m.Invoke(null, new object[0]);

    640. 

  640. 			    }

    641. 

  641. 			

    642. 

  642. 			    public static bool IsIntegralOrEnum(Type type) {

    643. 

  643. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    644. 

  644. 			            case TypeCode.Byte:

    645. 

  645. 			            case TypeCode.SByte:

    646. 

  646. 			            case TypeCode.Int16:

    647. 

  647. 			            case TypeCode.Int32:

    648. 

  648. 			            case TypeCode.Int64:

    649. 

  649. 			            case TypeCode.UInt16:

    650. 

  650. 			            case TypeCode.UInt32:

    651. 

  651. 			            case TypeCode.UInt64:

    652. 

  652. 			                return true;

    653. 

  653. 			            default:

    654. 

  654. 			                return false;

    655. 

  655. 			        }

    656. 

  656. 			    }

    657. 

  657. 			

    658. 

  658. 			    public static bool IsFloating(Type type) {

    659. 

  659. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    660. 

  660. 			            case TypeCode.Single:

    661. 

  661. 			            case TypeCode.Double:

    662. 

  662. 			                return true;

    663. 

  663. 			            default:

    664. 

  664. 			                return false;

    665. 

  665. 			        }

    666. 

  666. 			    }

    667. 

  667. 			

    668. 

  668. 			    public static Type GetNonNullableType(Type type) {

    669. 

  669. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    670. 

  670. 			                type.GetGenericArguments()[0] :

    671. 

  671. 			                type;

    672. 

  672. 			    }

    673. 

  673. 			}

    674. 

  674. 			

    675. 

  675. 		

    676. 

  676. 	}

    677. 

  677. 			

    678. 

  678. 			//-------- Scenario 1713

    679. 

  679. 			namespace Scenario1713{

    680. 

  680. 				

    681. 

  681. 				public class Test

    682. 

  682. 				{

    683. 

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

    684. 

  684. 			    public static Expression check7__() {

    685. 

  685. 			       if(Main() != 0 ) {

    686. 

  686. 			           throw new Exception();

    687. 

  687. 			       } else { 

    688. 

  688. 			           return Expression.Constant(0);

    689. 

  689. 			       }

    690. 

  690. 			    }

    691. 

  691. 				public     static int Main()

    692. 

  692. 				    {

    693. 

  693. 				        Ext.StartCapture();

    694. 

  694. 				        bool success = false;

    695. 

  695. 				        try

    696. 

  696. 				        {

    697. 

  697. 				            success = check7();

    698. 

  698. 				        }

    699. 

  699. 				        finally

    700. 

  700. 				        {

    701. 

  701. 				            Ext.StopCapture();

    702. 

  702. 				        }

    703. 

  703. 				        return success ? 0 : 1;

    704. 

  704. 				    }

    705. 

  705. 				

    706. 

  706. 				    static bool check7() {

    707. 

  707. 				        foreach (long val in new long[] { 0, 1, -1, long.MinValue, long.MaxValue }) {

    708. 

  708. 				            if (!check7(val)) {

    709. 

  709. 				                return false;

    710. 

  710. 				            }

    711. 

  711. 				        }

    712. 

  712. 				        return true;

    713. 

  713. 				    }

    714. 

  714. 				

    715. 

  715. 				    static bool check7(long val) {

    716. 

  716. 				        Expression<Func<long>> e =

    717. 

  717. 				            Expression.Lambda<Func<long>>(

    718. 

  718. 				                Expression.Constant(val, typeof(long)),

    719. 

  719. 				                new System.Collections.Generic.List<ParameterExpression>());

    720. 

  720. 				        Func<long> f = e.Compile();

    721. 

  721. 				        return object.Equals(f(), val);

    722. 

  722. 				    }

    723. 

  723. 				}

    724. 

  724. 			

    725. 

  725. 			

    726. 

  726. 			public  static class Ext {

    727. 

  727. 			    public static void StartCapture() {

    728. 

  728. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    729. 

  729. 			//        m.Invoke(null, new object[] { "test.dll" });

    730. 

  730. 			    }

    731. 

  731. 			

    732. 

  732. 			    public static void StopCapture() {

    733. 

  733. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    734. 

  734. 			//        m.Invoke(null, new object[0]);

    735. 

  735. 			    }

    736. 

  736. 			

    737. 

  737. 			    public static bool IsIntegralOrEnum(Type type) {

    738. 

  738. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    739. 

  739. 			            case TypeCode.Byte:

    740. 

  740. 			            case TypeCode.SByte:

    741. 

  741. 			            case TypeCode.Int16:

    742. 

  742. 			            case TypeCode.Int32:

    743. 

  743. 			            case TypeCode.Int64:

    744. 

  744. 			            case TypeCode.UInt16:

    745. 

  745. 			            case TypeCode.UInt32:

    746. 

  746. 			            case TypeCode.UInt64:

    747. 

  747. 			                return true;

    748. 

  748. 			            default:

    749. 

  749. 			                return false;

    750. 

  750. 			        }

    751. 

  751. 			    }

    752. 

  752. 			

    753. 

  753. 			    public static bool IsFloating(Type type) {

    754. 

  754. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    755. 

  755. 			            case TypeCode.Single:

    756. 

  756. 			            case TypeCode.Double:

    757. 

  757. 			                return true;

    758. 

  758. 			            default:

    759. 

  759. 			                return false;

    760. 

  760. 			        }

    761. 

  761. 			    }

    762. 

  762. 			

    763. 

  763. 			    public static Type GetNonNullableType(Type type) {

    764. 

  764. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    765. 

  765. 			                type.GetGenericArguments()[0] :

    766. 

  766. 			                type;

    767. 

  767. 			    }

    768. 

  768. 			}

    769. 

  769. 			

    770. 

  770. 		

    771. 

  771. 	}

    772. 

  772. 			

    773. 

  773. 			//-------- Scenario 1714

    774. 

  774. 			namespace Scenario1714{

    775. 

  775. 				

    776. 

  776. 				public class Test

    777. 

  777. 				{

    778. 

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

    779. 

  779. 			    public static Expression check8__() {

    780. 

  780. 			       if(Main() != 0 ) {

    781. 

  781. 			           throw new Exception();

    782. 

  782. 			       } else { 

    783. 

  783. 			           return Expression.Constant(0);

    784. 

  784. 			       }

    785. 

  785. 			    }

    786. 

  786. 				public     static int Main()

    787. 

  787. 				    {

    788. 

  788. 				        Ext.StartCapture();

    789. 

  789. 				        bool success = false;

    790. 

  790. 				        try

    791. 

  791. 				        {

    792. 

  792. 				            success = check8();

    793. 

  793. 				        }

    794. 

  794. 				        finally

    795. 

  795. 				        {

    796. 

  796. 				            Ext.StopCapture();

    797. 

  797. 				        }

    798. 

  798. 				        return success ? 0 : 1;

    799. 

  799. 				    }

    800. 

  800. 				

    801. 

  801. 				    static bool check8() {

    802. 

  802. 				        foreach (float val in new float[] { 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN }) {

    803. 

  803. 				            if (!check8(val)) {

    804. 

  804. 				                return false;

    805. 

  805. 				            }

    806. 

  806. 				        }

    807. 

  807. 				        return true;

    808. 

  808. 				    }

    809. 

  809. 				

    810. 

  810. 				    static bool check8(float val) {

    811. 

  811. 				        Expression<Func<float>> e =

    812. 

  812. 				            Expression.Lambda<Func<float>>(

    813. 

  813. 				                Expression.Constant(val, typeof(float)),

    814. 

  814. 				                new System.Collections.Generic.List<ParameterExpression>());

    815. 

  815. 				        Func<float> f = e.Compile();

    816. 

  816. 				        return object.Equals(f(), val);

    817. 

  817. 				    }

    818. 

  818. 				}

    819. 

  819. 			

    820. 

  820. 			

    821. 

  821. 			public  static class Ext {

    822. 

  822. 			    public static void StartCapture() {

    823. 

  823. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    824. 

  824. 			//        m.Invoke(null, new object[] { "test.dll" });

    825. 

  825. 			    }

    826. 

  826. 			

    827. 

  827. 			    public static void StopCapture() {

    828. 

  828. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    829. 

  829. 			//        m.Invoke(null, new object[0]);

    830. 

  830. 			    }

    831. 

  831. 			

    832. 

  832. 			    public static bool IsIntegralOrEnum(Type type) {

    833. 

  833. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    834. 

  834. 			            case TypeCode.Byte:

    835. 

  835. 			            case TypeCode.SByte:

    836. 

  836. 			            case TypeCode.Int16:

    837. 

  837. 			            case TypeCode.Int32:

    838. 

  838. 			            case TypeCode.Int64:

    839. 

  839. 			            case TypeCode.UInt16:

    840. 

  840. 			            case TypeCode.UInt32:

    841. 

  841. 			            case TypeCode.UInt64:

    842. 

  842. 			                return true;

    843. 

  843. 			            default:

    844. 

  844. 			                return false;

    845. 

  845. 			        }

    846. 

  846. 			    }

    847. 

  847. 			

    848. 

  848. 			    public static bool IsFloating(Type type) {

    849. 

  849. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    850. 

  850. 			            case TypeCode.Single:

    851. 

  851. 			            case TypeCode.Double:

    852. 

  852. 			                return true;

    853. 

  853. 			            default:

    854. 

  854. 			                return false;

    855. 

  855. 			        }

    856. 

  856. 			    }

    857. 

  857. 			

    858. 

  858. 			    public static Type GetNonNullableType(Type type) {

    859. 

  859. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    860. 

  860. 			                type.GetGenericArguments()[0] :

    861. 

  861. 			                type;

    862. 

  862. 			    }

    863. 

  863. 			}

    864. 

  864. 			

    865. 

  865. 		

    866. 

  866. 	}

    867. 

  867. 			

    868. 

  868. 			//-------- Scenario 1715

    869. 

  869. 			namespace Scenario1715{

    870. 

  870. 				

    871. 

  871. 				public class Test

    872. 

  872. 				{

    873. 

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

    874. 

  874. 			    public static Expression check9__() {

    875. 

  875. 			       if(Main() != 0 ) {

    876. 

  876. 			           throw new Exception();

    877. 

  877. 			       } else { 

    878. 

  878. 			           return Expression.Constant(0);

    879. 

  879. 			       }

    880. 

  880. 			    }

    881. 

  881. 				public     static int Main()

    882. 

  882. 				    {

    883. 

  883. 				        Ext.StartCapture();

    884. 

  884. 				        bool success = false;

    885. 

  885. 				        try

    886. 

  886. 				        {

    887. 

  887. 				            success = check9();

    888. 

  888. 				        }

    889. 

  889. 				        finally

    890. 

  890. 				        {

    891. 

  891. 				            Ext.StopCapture();

    892. 

  892. 				        }

    893. 

  893. 				        return success ? 0 : 1;

    894. 

  894. 				    }

    895. 

  895. 				

    896. 

  896. 				    static bool check9() {

    897. 

  897. 				        foreach (double val in new double[] { 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN }) {

    898. 

  898. 				            if (!check9(val)) {

    899. 

  899. 				                return false;

    900. 

  900. 				            }

    901. 

  901. 				        }

    902. 

  902. 				        return true;

    903. 

  903. 				    }

    904. 

  904. 				

    905. 

  905. 				    static bool check9(double val) {

    906. 

  906. 				        Expression<Func<double>> e =

    907. 

  907. 				            Expression.Lambda<Func<double>>(

    908. 

  908. 				                Expression.Constant(val, typeof(double)),

    909. 

  909. 				                new System.Collections.Generic.List<ParameterExpression>());

    910. 

  910. 				        Func<double> f = e.Compile();

    911. 

  911. 				        return object.Equals(f(), val);

    912. 

  912. 				    }

    913. 

  913. 				}

    914. 

  914. 			

    915. 

  915. 			

    916. 

  916. 			public  static class Ext {

    917. 

  917. 			    public static void StartCapture() {

    918. 

  918. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    919. 

  919. 			//        m.Invoke(null, new object[] { "test.dll" });

    920. 

  920. 			    }

    921. 

  921. 			

    922. 

  922. 			    public static void StopCapture() {

    923. 

  923. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    924. 

  924. 			//        m.Invoke(null, new object[0]);

    925. 

  925. 			    }

    926. 

  926. 			

    927. 

  927. 			    public static bool IsIntegralOrEnum(Type type) {

    928. 

  928. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    929. 

  929. 			            case TypeCode.Byte:

    930. 

  930. 			            case TypeCode.SByte:

    931. 

  931. 			            case TypeCode.Int16:

    932. 

  932. 			            case TypeCode.Int32:

    933. 

  933. 			            case TypeCode.Int64:

    934. 

  934. 			            case TypeCode.UInt16:

    935. 

  935. 			            case TypeCode.UInt32:

    936. 

  936. 			            case TypeCode.UInt64:

    937. 

  937. 			                return true;

    938. 

  938. 			            default:

    939. 

  939. 			                return false;

    940. 

  940. 			        }

    941. 

  941. 			    }

    942. 

  942. 			

    943. 

  943. 			    public static bool IsFloating(Type type) {

    944. 

  944. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    945. 

  945. 			            case TypeCode.Single:

    946. 

  946. 			            case TypeCode.Double:

    947. 

  947. 			                return true;

    948. 

  948. 			            default:

    949. 

  949. 			                return false;

    950. 

  950. 			        }

    951. 

  951. 			    }

    952. 

  952. 			

    953. 

  953. 			    public static Type GetNonNullableType(Type type) {

    954. 

  954. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    955. 

  955. 			                type.GetGenericArguments()[0] :

    956. 

  956. 			                type;

    957. 

  957. 			    }

    958. 

  958. 			}

    959. 

  959. 			

    960. 

  960. 		

    961. 

  961. 	}

    962. 

  962. 			

    963. 

  963. 			//-------- Scenario 1716

    964. 

  964. 			namespace Scenario1716{

    965. 

  965. 				

    966. 

  966. 				public class Test

    967. 

  967. 				{

    968. 

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

    969. 

  969. 			    public static Expression check10__() {

    970. 

  970. 			       if(Main() != 0 ) {

    971. 

  971. 			           throw new Exception();

    972. 

  972. 			       } else { 

    973. 

  973. 			           return Expression.Constant(0);

    974. 

  974. 			       }

    975. 

  975. 			    }

    976. 

  976. 				public     static int Main()

    977. 

  977. 				    {

    978. 

  978. 				        Ext.StartCapture();

    979. 

  979. 				        bool success = false;

    980. 

  980. 				        try

    981. 

  981. 				        {

    982. 

  982. 				            success = check10();

    983. 

  983. 				        }

    984. 

  984. 				        finally

    985. 

  985. 				        {

    986. 

  986. 				            Ext.StopCapture();

    987. 

  987. 				        }

    988. 

  988. 				        return success ? 0 : 1;

    989. 

  989. 				    }

    990. 

  990. 				

    991. 

  991. 				    static bool check10() {

    992. 

  992. 				        foreach (decimal val in new decimal[] { decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue }) {

    993. 

  993. 				            if (!check10(val)) {

    994. 

  994. 				                return false;

    995. 

  995. 				            }

    996. 

  996. 				        }

    997. 

  997. 				        return true;

    998. 

  998. 				    }

    999. 

  999. 				

    1000. 

  1000. 				    static bool check10(decimal val) {

    1001. 

  1001. 				        Expression<Func<decimal>> e =

    1002. 

  1002. 				            Expression.Lambda<Func<decimal>>(

    1003. 

  1003. 				                Expression.Constant(val, typeof(decimal)),

    1004. 

  1004. 				                new System.Collections.Generic.List<ParameterExpression>());

    1005. 

  1005. 				        Func<decimal> f = e.Compile();

    1006. 

  1006. 				        return object.Equals(f(), val);

    1007. 

  1007. 				    }

    1008. 

  1008. 				}

    1009. 

  1009. 			

    1010. 

  1010. 			

    1011. 

  1011. 			public  static class Ext {

    1012. 

  1012. 			    public static void StartCapture() {

    1013. 

  1013. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1014. 

  1014. 			//        m.Invoke(null, new object[] { "test.dll" });

    1015. 

  1015. 			    }

    1016. 

  1016. 			

    1017. 

  1017. 			    public static void StopCapture() {

    1018. 

  1018. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1019. 

  1019. 			//        m.Invoke(null, new object[0]);

    1020. 

  1020. 			    }

    1021. 

  1021. 			

    1022. 

  1022. 			    public static bool IsIntegralOrEnum(Type type) {

    1023. 

  1023. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1024. 

  1024. 			            case TypeCode.Byte:

    1025. 

  1025. 			            case TypeCode.SByte:

    1026. 

  1026. 			            case TypeCode.Int16:

    1027. 

  1027. 			            case TypeCode.Int32:

    1028. 

  1028. 			            case TypeCode.Int64:

    1029. 

  1029. 			            case TypeCode.UInt16:

    1030. 

  1030. 			            case TypeCode.UInt32:

    1031. 

  1031. 			            case TypeCode.UInt64:

    1032. 

  1032. 			                return true;

    1033. 

  1033. 			            default:

    1034. 

  1034. 			                return false;

    1035. 

  1035. 			        }

    1036. 

  1036. 			    }

    1037. 

  1037. 			

    1038. 

  1038. 			    public static bool IsFloating(Type type) {

    1039. 

  1039. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1040. 

  1040. 			            case TypeCode.Single:

    1041. 

  1041. 			            case TypeCode.Double:

    1042. 

  1042. 			                return true;

    1043. 

  1043. 			            default:

    1044. 

  1044. 			                return false;

    1045. 

  1045. 			        }

    1046. 

  1046. 			    }

    1047. 

  1047. 			

    1048. 

  1048. 			    public static Type GetNonNullableType(Type type) {

    1049. 

  1049. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1050. 

  1050. 			                type.GetGenericArguments()[0] :

    1051. 

  1051. 			                type;

    1052. 

  1052. 			    }

    1053. 

  1053. 			}

    1054. 

  1054. 			

    1055. 

  1055. 		

    1056. 

  1056. 	}

    1057. 

  1057. 			

    1058. 

  1058. 			//-------- Scenario 1717

    1059. 

  1059. 			namespace Scenario1717{

    1060. 

  1060. 				

    1061. 

  1061. 				public class Test

    1062. 

  1062. 				{

    1063. 

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

    1064. 

  1064. 			    public static Expression check11__() {

    1065. 

  1065. 			       if(Main() != 0 ) {

    1066. 

  1066. 			           throw new Exception();

    1067. 

  1067. 			       } else { 

    1068. 

  1068. 			           return Expression.Constant(0);

    1069. 

  1069. 			       }

    1070. 

  1070. 			    }

    1071. 

  1071. 				public     static int Main()

    1072. 

  1072. 				    {

    1073. 

  1073. 				        Ext.StartCapture();

    1074. 

  1074. 				        bool success = false;

    1075. 

  1075. 				        try

    1076. 

  1076. 				        {

    1077. 

  1077. 				            success = check11();

    1078. 

  1078. 				        }

    1079. 

  1079. 				        finally

    1080. 

  1080. 				        {

    1081. 

  1081. 				            Ext.StopCapture();

    1082. 

  1082. 				        }

    1083. 

  1083. 				        return success ? 0 : 1;

    1084. 

  1084. 				    }

    1085. 

  1085. 				

    1086. 

  1086. 				    static bool check11() {

    1087. 

  1087. 				        foreach (char val in new char[] { '\0', '\b', 'A', '\uffff' }) {

    1088. 

  1088. 				            if (!check11(val)) {

    1089. 

  1089. 				                return false;

    1090. 

  1090. 				            }

    1091. 

  1091. 				        }

    1092. 

  1092. 				        return true;

    1093. 

  1093. 				    }

    1094. 

  1094. 				

    1095. 

  1095. 				    static bool check11(char val) {

    1096. 

  1096. 				        Expression<Func<char>> e =

    1097. 

  1097. 				            Expression.Lambda<Func<char>>(

    1098. 

  1098. 				                Expression.Constant(val, typeof(char)),

    1099. 

  1099. 				                new System.Collections.Generic.List<ParameterExpression>());

    1100. 

  1100. 				        Func<char> f = e.Compile();

    1101. 

  1101. 				        return object.Equals(f(), val);

    1102. 

  1102. 				    }

    1103. 

  1103. 				}

    1104. 

  1104. 			

    1105. 

  1105. 			

    1106. 

  1106. 			public  static class Ext {

    1107. 

  1107. 			    public static void StartCapture() {

    1108. 

  1108. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1109. 

  1109. 			//        m.Invoke(null, new object[] { "test.dll" });

    1110. 

  1110. 			    }

    1111. 

  1111. 			

    1112. 

  1112. 			    public static void StopCapture() {

    1113. 

  1113. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1114. 

  1114. 			//        m.Invoke(null, new object[0]);

    1115. 

  1115. 			    }

    1116. 

  1116. 			

    1117. 

  1117. 			    public static bool IsIntegralOrEnum(Type type) {

    1118. 

  1118. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1119. 

  1119. 			            case TypeCode.Byte:

    1120. 

  1120. 			            case TypeCode.SByte:

    1121. 

  1121. 			            case TypeCode.Int16:

    1122. 

  1122. 			            case TypeCode.Int32:

    1123. 

  1123. 			            case TypeCode.Int64:

    1124. 

  1124. 			            case TypeCode.UInt16:

    1125. 

  1125. 			            case TypeCode.UInt32:

    1126. 

  1126. 			            case TypeCode.UInt64:

    1127. 

  1127. 			                return true;

    1128. 

  1128. 			            default:

    1129. 

  1129. 			                return false;

    1130. 

  1130. 			        }

    1131. 

  1131. 			    }

    1132. 

  1132. 			

    1133. 

  1133. 			    public static bool IsFloating(Type type) {

    1134. 

  1134. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1135. 

  1135. 			            case TypeCode.Single:

    1136. 

  1136. 			            case TypeCode.Double:

    1137. 

  1137. 			                return true;

    1138. 

  1138. 			            default:

    1139. 

  1139. 			                return false;

    1140. 

  1140. 			        }

    1141. 

  1141. 			    }

    1142. 

  1142. 			

    1143. 

  1143. 			    public static Type GetNonNullableType(Type type) {

    1144. 

  1144. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1145. 

  1145. 			                type.GetGenericArguments()[0] :

    1146. 

  1146. 			                type;

    1147. 

  1147. 			    }

    1148. 

  1148. 			}

    1149. 

  1149. 			

    1150. 

  1150. 		

    1151. 

  1151. 	}

    1152. 

  1152. 			

    1153. 

  1153. 			//-------- Scenario 1718

    1154. 

  1154. 			namespace Scenario1718{

    1155. 

  1155. 				

    1156. 

  1156. 				public class Test

    1157. 

  1157. 				{

    1158. 

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

    1159. 

  1159. 			    public static Expression check12__() {

    1160. 

  1160. 			       if(Main() != 0 ) {

    1161. 

  1161. 			           throw new Exception();

    1162. 

  1162. 			       } else { 

    1163. 

  1163. 			           return Expression.Constant(0);

    1164. 

  1164. 			       }

    1165. 

  1165. 			    }

    1166. 

  1166. 				public     static int Main()

    1167. 

  1167. 				    {

    1168. 

  1168. 				        Ext.StartCapture();

    1169. 

  1169. 				        bool success = false;

    1170. 

  1170. 				        try

    1171. 

  1171. 				        {

    1172. 

  1172. 				            success = check12();

    1173. 

  1173. 				        }

    1174. 

  1174. 				        finally

    1175. 

  1175. 				        {

    1176. 

  1176. 				            Ext.StopCapture();

    1177. 

  1177. 				        }

    1178. 

  1178. 				        return success ? 0 : 1;

    1179. 

  1179. 				    }

    1180. 

  1180. 				

    1181. 

  1181. 				    static bool check12() {

    1182. 

  1182. 				        foreach (bool val in new bool[] { true, false }) {

    1183. 

  1183. 				            if (!check12(val)) {

    1184. 

  1184. 				                return false;

    1185. 

  1185. 				            }

    1186. 

  1186. 				        }

    1187. 

  1187. 				        return true;

    1188. 

  1188. 				    }

    1189. 

  1189. 				

    1190. 

  1190. 				    static bool check12(bool val) {

    1191. 

  1191. 				        Expression<Func<bool>> e =

    1192. 

  1192. 				            Expression.Lambda<Func<bool>>(

    1193. 

  1193. 				                Expression.Constant(val, typeof(bool)),

    1194. 

  1194. 				                new System.Collections.Generic.List<ParameterExpression>());

    1195. 

  1195. 				        Func<bool> f = e.Compile();

    1196. 

  1196. 				        return object.Equals(f(), val);

    1197. 

  1197. 				    }

    1198. 

  1198. 				}

    1199. 

  1199. 			

    1200. 

  1200. 			

    1201. 

  1201. 			public  static class Ext {

    1202. 

  1202. 			    public static void StartCapture() {

    1203. 

  1203. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1204. 

  1204. 			//        m.Invoke(null, new object[] { "test.dll" });

    1205. 

  1205. 			    }

    1206. 

  1206. 			

    1207. 

  1207. 			    public static void StopCapture() {

    1208. 

  1208. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1209. 

  1209. 			//        m.Invoke(null, new object[0]);

    1210. 

  1210. 			    }

    1211. 

  1211. 			

    1212. 

  1212. 			    public static bool IsIntegralOrEnum(Type type) {

    1213. 

  1213. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1214. 

  1214. 			            case TypeCode.Byte:

    1215. 

  1215. 			            case TypeCode.SByte:

    1216. 

  1216. 			            case TypeCode.Int16:

    1217. 

  1217. 			            case TypeCode.Int32:

    1218. 

  1218. 			            case TypeCode.Int64:

    1219. 

  1219. 			            case TypeCode.UInt16:

    1220. 

  1220. 			            case TypeCode.UInt32:

    1221. 

  1221. 			            case TypeCode.UInt64:

    1222. 

  1222. 			                return true;

    1223. 

  1223. 			            default:

    1224. 

  1224. 			                return false;

    1225. 

  1225. 			        }

    1226. 

  1226. 			    }

    1227. 

  1227. 			

    1228. 

  1228. 			    public static bool IsFloating(Type type) {

    1229. 

  1229. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1230. 

  1230. 			            case TypeCode.Single:

    1231. 

  1231. 			            case TypeCode.Double:

    1232. 

  1232. 			                return true;

    1233. 

  1233. 			            default:

    1234. 

  1234. 			                return false;

    1235. 

  1235. 			        }

    1236. 

  1236. 			    }

    1237. 

  1237. 			

    1238. 

  1238. 			    public static Type GetNonNullableType(Type type) {

    1239. 

  1239. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1240. 

  1240. 			                type.GetGenericArguments()[0] :

    1241. 

  1241. 			                type;

    1242. 

  1242. 			    }

    1243. 

  1243. 			}

    1244. 

  1244. 			

    1245. 

  1245. 		

    1246. 

  1246. 	}

    1247. 

  1247. 				

    1248. 

  1248. 				//-------- Scenario 1719

    1249. 

  1249. 				namespace Scenario1719{

    1250. 

  1250. 					

    1251. 

  1251. 					public class Test

    1252. 

  1252. 					{

    1253. 

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

    1254. 

  1254. 				    public static Expression check13__() {

    1255. 

  1255. 				       if(Main() != 0 ) {

    1256. 

  1256. 				           throw new Exception();

    1257. 

  1257. 				       } else { 

    1258. 

  1258. 				           return Expression.Constant(0);

    1259. 

  1259. 				       }

    1260. 

  1260. 				    }

    1261. 

  1261. 					public     static int Main()

    1262. 

  1262. 					    {

    1263. 

  1263. 					        Ext.StartCapture();

    1264. 

  1264. 					        bool success = false;

    1265. 

  1265. 					        try

    1266. 

  1266. 					        {

    1267. 

  1267. 					            success = check13();

    1268. 

  1268. 					        }

    1269. 

  1269. 					        finally

    1270. 

  1270. 					        {

    1271. 

  1271. 					            Ext.StopCapture();

    1272. 

  1272. 					        }

    1273. 

  1273. 					        return success ? 0 : 1;

    1274. 

  1274. 					    }

    1275. 

  1275. 					

    1276. 

  1276. 					    static bool check13() {

    1277. 

  1277. 					        foreach (S val in new S[] { default(S), new S() }) {

    1278. 

  1278. 					            if (!check13(val)) {

    1279. 

  1279. 					                return false;

    1280. 

  1280. 					            }

    1281. 

  1281. 					        }

    1282. 

  1282. 					        return true;

    1283. 

  1283. 					    }

    1284. 

  1284. 					

    1285. 

  1285. 					    static bool check13(S val) {

    1286. 

  1286. 					        Expression<Func<S>> e =

    1287. 

  1287. 					            Expression.Lambda<Func<S>>(

    1288. 

  1288. 					                Expression.Constant(val, typeof(S)),

    1289. 

  1289. 					                new System.Collections.Generic.List<ParameterExpression>());

    1290. 

  1290. 					        Func<S> f = e.Compile();

    1291. 

  1291. 					        return object.Equals(f(), val);

    1292. 

  1292. 					    }

    1293. 

  1293. 					}

    1294. 

  1294. 				

    1295. 

  1295. 				

    1296. 

  1296. 				public  static class Ext {

    1297. 

  1297. 				    public static void StartCapture() {

    1298. 

  1298. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1299. 

  1299. 				//        m.Invoke(null, new object[] { "test.dll" });

    1300. 

  1300. 				    }

    1301. 

  1301. 				

    1302. 

  1302. 				    public static void StopCapture() {

    1303. 

  1303. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1304. 

  1304. 				//        m.Invoke(null, new object[0]);

    1305. 

  1305. 				    }

    1306. 

  1306. 				

    1307. 

  1307. 				    public static bool IsIntegralOrEnum(Type type) {

    1308. 

  1308. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1309. 

  1309. 				            case TypeCode.Byte:

    1310. 

  1310. 				            case TypeCode.SByte:

    1311. 

  1311. 				            case TypeCode.Int16:

    1312. 

  1312. 				            case TypeCode.Int32:

    1313. 

  1313. 				            case TypeCode.Int64:

    1314. 

  1314. 				            case TypeCode.UInt16:

    1315. 

  1315. 				            case TypeCode.UInt32:

    1316. 

  1316. 				            case TypeCode.UInt64:

    1317. 

  1317. 				                return true;

    1318. 

  1318. 				            default:

    1319. 

  1319. 				                return false;

    1320. 

  1320. 				        }

    1321. 

  1321. 				    }

    1322. 

  1322. 				

    1323. 

  1323. 				    public static bool IsFloating(Type type) {

    1324. 

  1324. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1325. 

  1325. 				            case TypeCode.Single:

    1326. 

  1326. 				            case TypeCode.Double:

    1327. 

  1327. 				                return true;

    1328. 

  1328. 				            default:

    1329. 

  1329. 				                return false;

    1330. 

  1330. 				        }

    1331. 

  1331. 				    }

    1332. 

  1332. 				

    1333. 

  1333. 				    public static Type GetNonNullableType(Type type) {

    1334. 

  1334. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1335. 

  1335. 				                type.GetGenericArguments()[0] :

    1336. 

  1336. 				                type;

    1337. 

  1337. 				    }

    1338. 

  1338. 				}

    1339. 

  1339. 				

    1340. 

  1340. 			

    1341. 

  1341. 			

    1342. 

  1342. 			

    1343. 

  1343. 			public interface I {

    1344. 

  1344. 			  void M();

    1345. 

  1345. 			}

    1346. 

  1346. 			

    1347. 

  1347. 			public  class C : IEquatable<C>, I {

    1348. 

  1348. 			    void I.M() {

    1349. 

  1349. 			    }

    1350. 

  1350. 			

    1351. 

  1351. 			    public override bool Equals(object o) {

    1352. 

  1352. 			        return o is C && Equals((C) o);

    1353. 

  1353. 			    }

    1354. 

  1354. 			

    1355. 

  1355. 			    public bool Equals(C c) {

    1356. 

  1356. 			        return c != null;

    1357. 

  1357. 			    }

    1358. 

  1358. 			

    1359. 

  1359. 			    public override int GetHashCode() {

    1360. 

  1360. 			        return 0;

    1361. 

  1361. 			    }

    1362. 

  1362. 			}

    1363. 

  1363. 			

    1364. 

  1364. 			public  class D : C, IEquatable<D> {

    1365. 

  1365. 			    public int Val;

    1366. 

  1366. 			    public D() {

    1367. 

  1367. 			    }

    1368. 

  1368. 			    public D(int val) {

    1369. 

  1369. 			        Val = val;

    1370. 

  1370. 			    }

    1371. 

  1371. 			

    1372. 

  1372. 			    public override bool Equals(object o) {

    1373. 

  1373. 			        return o is D && Equals((D) o);

    1374. 

  1374. 			    }

    1375. 

  1375. 			

    1376. 

  1376. 			    public bool Equals(D d) {

    1377. 

  1377. 			        return d != null && d.Val == Val;

    1378. 

  1378. 			    }

    1379. 

  1379. 			

    1380. 

  1380. 			    public override int GetHashCode() {

    1381. 

  1381. 			        return Val;

    1382. 

  1382. 			    }

    1383. 

  1383. 			}

    1384. 

  1384. 			

    1385. 

  1385. 			public enum E {

    1386. 

  1386. 			  A=1, B=2

    1387. 

  1387. 			}

    1388. 

  1388. 			

    1389. 

  1389. 			public enum El : long {

    1390. 

  1390. 			  A, B, C

    1391. 

  1391. 			}

    1392. 

  1392. 			

    1393. 

  1393. 			public struct S : IEquatable<S> {

    1394. 

  1394. 			    public override bool Equals(object o) {

    1395. 

  1395. 			        return (o is S) && Equals((S) o);

    1396. 

  1396. 			    }

    1397. 

  1397. 			    public bool Equals(S other) {

    1398. 

  1398. 			        return true;

    1399. 

  1399. 			    }

    1400. 

  1400. 			    public override int GetHashCode() {

    1401. 

  1401. 			        return 0;

    1402. 

  1402. 			    }

    1403. 

  1403. 			}

    1404. 

  1404. 			

    1405. 

  1405. 			public struct Sp : IEquatable<Sp> {

    1406. 

  1406. 			    public Sp(int i, double d) {

    1407. 

  1407. 			        I = i;

    1408. 

  1408. 			        D = d;

    1409. 

  1409. 			    }

    1410. 

  1410. 			

    1411. 

  1411. 			    public int I;

    1412. 

  1412. 			    public double D;

    1413. 

  1413. 			

    1414. 

  1414. 			    public override bool Equals(object o) {

    1415. 

  1415. 			        return (o is Sp) && Equals((Sp) o);

    1416. 

  1416. 			    }

    1417. 

  1417. 			    public bool Equals(Sp other) {

    1418. 

  1418. 			        return other.I == I && other.D == D;

    1419. 

  1419. 			    }

    1420. 

  1420. 			    public override int GetHashCode() {

    1421. 

  1421. 			        return I.GetHashCode() ^ D.GetHashCode();

    1422. 

  1422. 			    }

    1423. 

  1423. 			}

    1424. 

  1424. 			

    1425. 

  1425. 			public struct Ss : IEquatable<Ss> {

    1426. 

  1426. 			    public Ss(S s) {

    1427. 

  1427. 			        Val = s;

    1428. 

  1428. 			    }

    1429. 

  1429. 			

    1430. 

  1430. 			    public S Val;

    1431. 

  1431. 			

    1432. 

  1432. 			    public override bool Equals(object o) {

    1433. 

  1433. 			        return (o is Ss) && Equals((Ss) o);

    1434. 

  1434. 			    }

    1435. 

  1435. 			    public bool Equals(Ss other) {

    1436. 

  1436. 			        return other.Val.Equals(Val);

    1437. 

  1437. 			    }

    1438. 

  1438. 			    public override int GetHashCode() {

    1439. 

  1439. 			        return Val.GetHashCode();

    1440. 

  1440. 			    }

    1441. 

  1441. 			}

    1442. 

  1442. 			

    1443. 

  1443. 			public struct Sc : IEquatable<Sc> {

    1444. 

  1444. 			    public Sc(string s) {

    1445. 

  1445. 			        S = s;

    1446. 

  1446. 			    }

    1447. 

  1447. 			

    1448. 

  1448. 			    public string S;

    1449. 

  1449. 			

    1450. 

  1450. 			    public override bool Equals(object o) {

    1451. 

  1451. 			        return (o is Sc) && Equals((Sc) o);

    1452. 

  1452. 			    }

    1453. 

  1453. 			    public bool Equals(Sc other) {

    1454. 

  1454. 			        return other.S == S;

    1455. 

  1455. 			    }

    1456. 

  1456. 			    public override int GetHashCode() {

    1457. 

  1457. 			        return S.GetHashCode();

    1458. 

  1458. 			    }

    1459. 

  1459. 			}

    1460. 

  1460. 			

    1461. 

  1461. 			public struct Scs : IEquatable<Scs> {

    1462. 

  1462. 			    public Scs(string s, S val) {

    1463. 

  1463. 			        S = s;

    1464. 

  1464. 			        Val = val;

    1465. 

  1465. 			    }

    1466. 

  1466. 			

    1467. 

  1467. 			    public string S;

    1468. 

  1468. 			    public S Val;

    1469. 

  1469. 			

    1470. 

  1470. 			    public override bool Equals(object o) {

    1471. 

  1471. 			        return (o is Scs) && Equals((Scs) o);

    1472. 

  1472. 			    }

    1473. 

  1473. 			    public bool Equals(Scs other) {

    1474. 

  1474. 			        return other.S == S && other.Val.Equals(Val);

    1475. 

  1475. 			    }

    1476. 

  1476. 			    public override int GetHashCode() {

    1477. 

  1477. 			        return S.GetHashCode() ^ Val.GetHashCode();

    1478. 

  1478. 			    }

    1479. 

  1479. 			}

    1480. 

  1480. 			

    1481. 

  1481. 		

    1482. 

  1482. 	}

    1483. 

  1483. 				

    1484. 

  1484. 				//-------- Scenario 1720

    1485. 

  1485. 				namespace Scenario1720{

    1486. 

  1486. 					

    1487. 

  1487. 					public class Test

    1488. 

  1488. 					{

    1489. 

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

    1490. 

  1490. 				    public static Expression check14__() {

    1491. 

  1491. 				       if(Main() != 0 ) {

    1492. 

  1492. 				           throw new Exception();

    1493. 

  1493. 				       } else { 

    1494. 

  1494. 				           return Expression.Constant(0);

    1495. 

  1495. 				       }

    1496. 

  1496. 				    }

    1497. 

  1497. 					public     static int Main()

    1498. 

  1498. 					    {

    1499. 

  1499. 					        Ext.StartCapture();

    1500. 

  1500. 					        bool success = false;

    1501. 

  1501. 					        try

    1502. 

  1502. 					        {

    1503. 

  1503. 					            success = check14();

    1504. 

  1504. 					        }

    1505. 

  1505. 					        finally

    1506. 

  1506. 					        {

    1507. 

  1507. 					            Ext.StopCapture();

    1508. 

  1508. 					        }

    1509. 

  1509. 					        return success ? 0 : 1;

    1510. 

  1510. 					    }

    1511. 

  1511. 					

    1512. 

  1512. 					    static bool check14() {

    1513. 

  1513. 					        foreach (Sp val in new Sp[] { default(Sp), new Sp(), new Sp(5,5.0) }) {

    1514. 

  1514. 					            if (!check14(val)) {

    1515. 

  1515. 					                return false;

    1516. 

  1516. 					            }

    1517. 

  1517. 					        }

    1518. 

  1518. 					        return true;

    1519. 

  1519. 					    }

    1520. 

  1520. 					

    1521. 

  1521. 					    static bool check14(Sp val) {

    1522. 

  1522. 					        Expression<Func<Sp>> e =

    1523. 

  1523. 					            Expression.Lambda<Func<Sp>>(

    1524. 

  1524. 					                Expression.Constant(val, typeof(Sp)),

    1525. 

  1525. 					                new System.Collections.Generic.List<ParameterExpression>());

    1526. 

  1526. 					        Func<Sp> f = e.Compile();

    1527. 

  1527. 					        return object.Equals(f(), val);

    1528. 

  1528. 					    }

    1529. 

  1529. 					}

    1530. 

  1530. 				

    1531. 

  1531. 				

    1532. 

  1532. 				public  static class Ext {

    1533. 

  1533. 				    public static void StartCapture() {

    1534. 

  1534. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1535. 

  1535. 				//        m.Invoke(null, new object[] { "test.dll" });

    1536. 

  1536. 				    }

    1537. 

  1537. 				

    1538. 

  1538. 				    public static void StopCapture() {

    1539. 

  1539. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1540. 

  1540. 				//        m.Invoke(null, new object[0]);

    1541. 

  1541. 				    }

    1542. 

  1542. 				

    1543. 

  1543. 				    public static bool IsIntegralOrEnum(Type type) {

    1544. 

  1544. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1545. 

  1545. 				            case TypeCode.Byte:

    1546. 

  1546. 				            case TypeCode.SByte:

    1547. 

  1547. 				            case TypeCode.Int16:

    1548. 

  1548. 				            case TypeCode.Int32:

    1549. 

  1549. 				            case TypeCode.Int64:

    1550. 

  1550. 				            case TypeCode.UInt16:

    1551. 

  1551. 				            case TypeCode.UInt32:

    1552. 

  1552. 				            case TypeCode.UInt64:

    1553. 

  1553. 				                return true;

    1554. 

  1554. 				            default:

    1555. 

  1555. 				                return false;

    1556. 

  1556. 				        }

    1557. 

  1557. 				    }

    1558. 

  1558. 				

    1559. 

  1559. 				    public static bool IsFloating(Type type) {

    1560. 

  1560. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1561. 

  1561. 				            case TypeCode.Single:

    1562. 

  1562. 				            case TypeCode.Double:

    1563. 

  1563. 				                return true;

    1564. 

  1564. 				            default:

    1565. 

  1565. 				                return false;

    1566. 

  1566. 				        }

    1567. 

  1567. 				    }

    1568. 

  1568. 				

    1569. 

  1569. 				    public static Type GetNonNullableType(Type type) {

    1570. 

  1570. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1571. 

  1571. 				                type.GetGenericArguments()[0] :

    1572. 

  1572. 				                type;

    1573. 

  1573. 				    }

    1574. 

  1574. 				}

    1575. 

  1575. 				

    1576. 

  1576. 			

    1577. 

  1577. 			

    1578. 

  1578. 			

    1579. 

  1579. 			public interface I {

    1580. 

  1580. 			  void M();

    1581. 

  1581. 			}

    1582. 

  1582. 			

    1583. 

  1583. 			public  class C : IEquatable<C>, I {

    1584. 

  1584. 			    void I.M() {

    1585. 

  1585. 			    }

    1586. 

  1586. 			

    1587. 

  1587. 			    public override bool Equals(object o) {

    1588. 

  1588. 			        return o is C && Equals((C) o);

    1589. 

  1589. 			    }

    1590. 

  1590. 			

    1591. 

  1591. 			    public bool Equals(C c) {

    1592. 

  1592. 			        return c != null;

    1593. 

  1593. 			    }

    1594. 

  1594. 			

    1595. 

  1595. 			    public override int GetHashCode() {

    1596. 

  1596. 			        return 0;

    1597. 

  1597. 			    }

    1598. 

  1598. 			}

    1599. 

  1599. 			

    1600. 

  1600. 			public  class D : C, IEquatable<D> {

    1601. 

  1601. 			    public int Val;

    1602. 

  1602. 			    public D() {

    1603. 

  1603. 			    }

    1604. 

  1604. 			    public D(int val) {

    1605. 

  1605. 			        Val = val;

    1606. 

  1606. 			    }

    1607. 

  1607. 			

    1608. 

  1608. 			    public override bool Equals(object o) {

    1609. 

  1609. 			        return o is D && Equals((D) o);

    1610. 

  1610. 			    }

    1611. 

  1611. 			

    1612. 

  1612. 			    public bool Equals(D d) {

    1613. 

  1613. 			        return d != null && d.Val == Val;

    1614. 

  1614. 			    }

    1615. 

  1615. 			

    1616. 

  1616. 			    public override int GetHashCode() {

    1617. 

  1617. 			        return Val;

    1618. 

  1618. 			    }

    1619. 

  1619. 			}

    1620. 

  1620. 			

    1621. 

  1621. 			public enum E {

    1622. 

  1622. 			  A=1, B=2

    1623. 

  1623. 			}

    1624. 

  1624. 			

    1625. 

  1625. 			public enum El : long {

    1626. 

  1626. 			  A, B, C

    1627. 

  1627. 			}

    1628. 

  1628. 			

    1629. 

  1629. 			public struct S : IEquatable<S> {

    1630. 

  1630. 			    public override bool Equals(object o) {

    1631. 

  1631. 			        return (o is S) && Equals((S) o);

    1632. 

  1632. 			    }

    1633. 

  1633. 			    public bool Equals(S other) {

    1634. 

  1634. 			        return true;

    1635. 

  1635. 			    }

    1636. 

  1636. 			    public override int GetHashCode() {

    1637. 

  1637. 			        return 0;

    1638. 

  1638. 			    }

    1639. 

  1639. 			}

    1640. 

  1640. 			

    1641. 

  1641. 			public struct Sp : IEquatable<Sp> {

    1642. 

  1642. 			    public Sp(int i, double d) {

    1643. 

  1643. 			        I = i;

    1644. 

  1644. 			        D = d;

    1645. 

  1645. 			    }

    1646. 

  1646. 			

    1647. 

  1647. 			    public int I;

    1648. 

  1648. 			    public double D;

    1649. 

  1649. 			

    1650. 

  1650. 			    public override bool Equals(object o) {

    1651. 

  1651. 			        return (o is Sp) && Equals((Sp) o);

    1652. 

  1652. 			    }

    1653. 

  1653. 			    public bool Equals(Sp other) {

    1654. 

  1654. 			        return other.I == I && other.D == D;

    1655. 

  1655. 			    }

    1656. 

  1656. 			    public override int GetHashCode() {

    1657. 

  1657. 			        return I.GetHashCode() ^ D.GetHashCode();

    1658. 

  1658. 			    }

    1659. 

  1659. 			}

    1660. 

  1660. 			

    1661. 

  1661. 			public struct Ss : IEquatable<Ss> {

    1662. 

  1662. 			    public Ss(S s) {

    1663. 

  1663. 			        Val = s;

    1664. 

  1664. 			    }

    1665. 

  1665. 			

    1666. 

  1666. 			    public S Val;

    1667. 

  1667. 			

    1668. 

  1668. 			    public override bool Equals(object o) {

    1669. 

  1669. 			        return (o is Ss) && Equals((Ss) o);

    1670. 

  1670. 			    }

    1671. 

  1671. 			    public bool Equals(Ss other) {

    1672. 

  1672. 			        return other.Val.Equals(Val);

    1673. 

  1673. 			    }

    1674. 

  1674. 			    public override int GetHashCode() {

    1675. 

  1675. 			        return Val.GetHashCode();

    1676. 

  1676. 			    }

    1677. 

  1677. 			}

    1678. 

  1678. 			

    1679. 

  1679. 			public struct Sc : IEquatable<Sc> {

    1680. 

  1680. 			    public Sc(string s) {

    1681. 

  1681. 			        S = s;

    1682. 

  1682. 			    }

    1683. 

  1683. 			

    1684. 

  1684. 			    public string S;

    1685. 

  1685. 			

    1686. 

  1686. 			    public override bool Equals(object o) {

    1687. 

  1687. 			        return (o is Sc) && Equals((Sc) o);

    1688. 

  1688. 			    }

    1689. 

  1689. 			    public bool Equals(Sc other) {

    1690. 

  1690. 			        return other.S == S;

    1691. 

  1691. 			    }

    1692. 

  1692. 			    public override int GetHashCode() {

    1693. 

  1693. 			        return S.GetHashCode();

    1694. 

  1694. 			    }

    1695. 

  1695. 			}

    1696. 

  1696. 			

    1697. 

  1697. 			public struct Scs : IEquatable<Scs> {

    1698. 

  1698. 			    public Scs(string s, S val) {

    1699. 

  1699. 			        S = s;

    1700. 

  1700. 			        Val = val;

    1701. 

  1701. 			    }

    1702. 

  1702. 			

    1703. 

  1703. 			    public string S;

    1704. 

  1704. 			    public S Val;

    1705. 

  1705. 			

    1706. 

  1706. 			    public override bool Equals(object o) {

    1707. 

  1707. 			        return (o is Scs) && Equals((Scs) o);

    1708. 

  1708. 			    }

    1709. 

  1709. 			    public bool Equals(Scs other) {

    1710. 

  1710. 			        return other.S == S && other.Val.Equals(Val);

    1711. 

  1711. 			    }

    1712. 

  1712. 			    public override int GetHashCode() {

    1713. 

  1713. 			        return S.GetHashCode() ^ Val.GetHashCode();

    1714. 

  1714. 			    }

    1715. 

  1715. 			}

    1716. 

  1716. 			

    1717. 

  1717. 		

    1718. 

  1718. 	}

    1719. 

  1719. 				

    1720. 

  1720. 				//-------- Scenario 1721

    1721. 

  1721. 				namespace Scenario1721{

    1722. 

  1722. 					

    1723. 

  1723. 					public class Test

    1724. 

  1724. 					{

    1725. 

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

    1726. 

  1726. 				    public static Expression check15__() {

    1727. 

  1727. 				       if(Main() != 0 ) {

    1728. 

  1728. 				           throw new Exception();

    1729. 

  1729. 				       } else { 

    1730. 

  1730. 				           return Expression.Constant(0);

    1731. 

  1731. 				       }

    1732. 

  1732. 				    }

    1733. 

  1733. 					public     static int Main()

    1734. 

  1734. 					    {

    1735. 

  1735. 					        Ext.StartCapture();

    1736. 

  1736. 					        bool success = false;

    1737. 

  1737. 					        try

    1738. 

  1738. 					        {

    1739. 

  1739. 					            success = check15();

    1740. 

  1740. 					        }

    1741. 

  1741. 					        finally

    1742. 

  1742. 					        {

    1743. 

  1743. 					            Ext.StopCapture();

    1744. 

  1744. 					        }

    1745. 

  1745. 					        return success ? 0 : 1;

    1746. 

  1746. 					    }

    1747. 

  1747. 					

    1748. 

  1748. 					    static bool check15() {

    1749. 

  1749. 					        foreach (Ss val in new Ss[] { default(Ss), new Ss(), new Ss(new S()) }) {

    1750. 

  1750. 					            if (!check15(val)) {

    1751. 

  1751. 					                return false;

    1752. 

  1752. 					            }

    1753. 

  1753. 					        }

    1754. 

  1754. 					        return true;

    1755. 

  1755. 					    }

    1756. 

  1756. 					

    1757. 

  1757. 					    static bool check15(Ss val) {

    1758. 

  1758. 					        Expression<Func<Ss>> e =

    1759. 

  1759. 					            Expression.Lambda<Func<Ss>>(

    1760. 

  1760. 					                Expression.Constant(val, typeof(Ss)),

    1761. 

  1761. 					                new System.Collections.Generic.List<ParameterExpression>());

    1762. 

  1762. 					        Func<Ss> f = e.Compile();

    1763. 

  1763. 					        return object.Equals(f(), val);

    1764. 

  1764. 					    }

    1765. 

  1765. 					}

    1766. 

  1766. 				

    1767. 

  1767. 				

    1768. 

  1768. 				public  static class Ext {

    1769. 

  1769. 				    public static void StartCapture() {

    1770. 

  1770. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1771. 

  1771. 				//        m.Invoke(null, new object[] { "test.dll" });

    1772. 

  1772. 				    }

    1773. 

  1773. 				

    1774. 

  1774. 				    public static void StopCapture() {

    1775. 

  1775. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    1776. 

  1776. 				//        m.Invoke(null, new object[0]);

    1777. 

  1777. 				    }

    1778. 

  1778. 				

    1779. 

  1779. 				    public static bool IsIntegralOrEnum(Type type) {

    1780. 

  1780. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1781. 

  1781. 				            case TypeCode.Byte:

    1782. 

  1782. 				            case TypeCode.SByte:

    1783. 

  1783. 				            case TypeCode.Int16:

    1784. 

  1784. 				            case TypeCode.Int32:

    1785. 

  1785. 				            case TypeCode.Int64:

    1786. 

  1786. 				            case TypeCode.UInt16:

    1787. 

  1787. 				            case TypeCode.UInt32:

    1788. 

  1788. 				            case TypeCode.UInt64:

    1789. 

  1789. 				                return true;

    1790. 

  1790. 				            default:

    1791. 

  1791. 				                return false;

    1792. 

  1792. 				        }

    1793. 

  1793. 				    }

    1794. 

  1794. 				

    1795. 

  1795. 				    public static bool IsFloating(Type type) {

    1796. 

  1796. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    1797. 

  1797. 				            case TypeCode.Single:

    1798. 

  1798. 				            case TypeCode.Double:

    1799. 

  1799. 				                return true;

    1800. 

  1800. 				            default:

    1801. 

  1801. 				                return false;

    1802. 

  1802. 				        }

    1803. 

  1803. 				    }

    1804. 

  1804. 				

    1805. 

  1805. 				    public static Type GetNonNullableType(Type type) {

    1806. 

  1806. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    1807. 

  1807. 				                type.GetGenericArguments()[0] :

    1808. 

  1808. 				                type;

    1809. 

  1809. 				    }

    1810. 

  1810. 				}

    1811. 

  1811. 				

    1812. 

  1812. 			

    1813. 

  1813. 			

    1814. 

  1814. 			

    1815. 

  1815. 			public interface I {

    1816. 

  1816. 			  void M();

    1817. 

  1817. 			}

    1818. 

  1818. 			

    1819. 

  1819. 			public  class C : IEquatable<C>, I {

    1820. 

  1820. 			    void I.M() {

    1821. 

  1821. 			    }

    1822. 

  1822. 			

    1823. 

  1823. 			    public override bool Equals(object o) {

    1824. 

  1824. 			        return o is C && Equals((C) o);

    1825. 

  1825. 			    }

    1826. 

  1826. 			

    1827. 

  1827. 			    public bool Equals(C c) {

    1828. 

  1828. 			        return c != null;

    1829. 

  1829. 			    }

    1830. 

  1830. 			

    1831. 

  1831. 			    public override int GetHashCode() {

    1832. 

  1832. 			        return 0;

    1833. 

  1833. 			    }

    1834. 

  1834. 			}

    1835. 

  1835. 			

    1836. 

  1836. 			public  class D : C, IEquatable<D> {

    1837. 

  1837. 			    public int Val;

    1838. 

  1838. 			    public D() {

    1839. 

  1839. 			    }

    1840. 

  1840. 			    public D(int val) {

    1841. 

  1841. 			        Val = val;

    1842. 

  1842. 			    }

    1843. 

  1843. 			

    1844. 

  1844. 			    public override bool Equals(object o) {

    1845. 

  1845. 			        return o is D && Equals((D) o);

    1846. 

  1846. 			    }

    1847. 

  1847. 			

    1848. 

  1848. 			    public bool Equals(D d) {

    1849. 

  1849. 			        return d != null && d.Val == Val;

    1850. 

  1850. 			    }

    1851. 

  1851. 			

    1852. 

  1852. 			    public override int GetHashCode() {

    1853. 

  1853. 			        return Val;

    1854. 

  1854. 			    }

    1855. 

  1855. 			}

    1856. 

  1856. 			

    1857. 

  1857. 			public enum E {

    1858. 

  1858. 			  A=1, B=2

    1859. 

  1859. 			}

    1860. 

  1860. 			

    1861. 

  1861. 			public enum El : long {

    1862. 

  1862. 			  A, B, C

    1863. 

  1863. 			}

    1864. 

  1864. 			

    1865. 

  1865. 			public struct S : IEquatable<S> {

    1866. 

  1866. 			    public override bool Equals(object o) {

    1867. 

  1867. 			        return (o is S) && Equals((S) o);

    1868. 

  1868. 			    }

    1869. 

  1869. 			    public bool Equals(S other) {

    1870. 

  1870. 			        return true;

    1871. 

  1871. 			    }

    1872. 

  1872. 			    public override int GetHashCode() {

    1873. 

  1873. 			        return 0;

    1874. 

  1874. 			    }

    1875. 

  1875. 			}

    1876. 

  1876. 			

    1877. 

  1877. 			public struct Sp : IEquatable<Sp> {

    1878. 

  1878. 			    public Sp(int i, double d) {

    1879. 

  1879. 			        I = i;

    1880. 

  1880. 			        D = d;

    1881. 

  1881. 			    }

    1882. 

  1882. 			

    1883. 

  1883. 			    public int I;

    1884. 

  1884. 			    public double D;

    1885. 

  1885. 			

    1886. 

  1886. 			    public override bool Equals(object o) {

    1887. 

  1887. 			        return (o is Sp) && Equals((Sp) o);

    1888. 

  1888. 			    }

    1889. 

  1889. 			    public bool Equals(Sp other) {

    1890. 

  1890. 			        return other.I == I && other.D == D;

    1891. 

  1891. 			    }

    1892. 

  1892. 			    public override int GetHashCode() {

    1893. 

  1893. 			        return I.GetHashCode() ^ D.GetHashCode();

    1894. 

  1894. 			    }

    1895. 

  1895. 			}

    1896. 

  1896. 			

    1897. 

  1897. 			public struct Ss : IEquatable<Ss> {

    1898. 

  1898. 			    public Ss(S s) {

    1899. 

  1899. 			        Val = s;

    1900. 

  1900. 			    }

    1901. 

  1901. 			

    1902. 

  1902. 			    public S Val;

    1903. 

  1903. 			

    1904. 

  1904. 			    public override bool Equals(object o) {

    1905. 

  1905. 			        return (o is Ss) && Equals((Ss) o);

    1906. 

  1906. 			    }

    1907. 

  1907. 			    public bool Equals(Ss other) {

    1908. 

  1908. 			        return other.Val.Equals(Val);

    1909. 

  1909. 			    }

    1910. 

  1910. 			    public override int GetHashCode() {

    1911. 

  1911. 			        return Val.GetHashCode();

    1912. 

  1912. 			    }

    1913. 

  1913. 			}

    1914. 

  1914. 			

    1915. 

  1915. 			public struct Sc : IEquatable<Sc> {

    1916. 

  1916. 			    public Sc(string s) {

    1917. 

  1917. 			        S = s;

    1918. 

  1918. 			    }

    1919. 

  1919. 			

    1920. 

  1920. 			    public string S;

    1921. 

  1921. 			

    1922. 

  1922. 			    public override bool Equals(object o) {

    1923. 

  1923. 			        return (o is Sc) && Equals((Sc) o);

    1924. 

  1924. 			    }

    1925. 

  1925. 			    public bool Equals(Sc other) {

    1926. 

  1926. 			        return other.S == S;

    1927. 

  1927. 			    }

    1928. 

  1928. 			    public override int GetHashCode() {

    1929. 

  1929. 			        return S.GetHashCode();

    1930. 

  1930. 			    }

    1931. 

  1931. 			}

    1932. 

  1932. 			

    1933. 

  1933. 			public struct Scs : IEquatable<Scs> {

    1934. 

  1934. 			    public Scs(string s, S val) {

    1935. 

  1935. 			        S = s;

    1936. 

  1936. 			        Val = val;

    1937. 

  1937. 			    }

    1938. 

  1938. 			

    1939. 

  1939. 			    public string S;

    1940. 

  1940. 			    public S Val;

    1941. 

  1941. 			

    1942. 

  1942. 			    public override bool Equals(object o) {

    1943. 

  1943. 			        return (o is Scs) && Equals((Scs) o);

    1944. 

  1944. 			    }

    1945. 

  1945. 			    public bool Equals(Scs other) {

    1946. 

  1946. 			        return other.S == S && other.Val.Equals(Val);

    1947. 

  1947. 			    }

    1948. 

  1948. 			    public override int GetHashCode() {

    1949. 

  1949. 			        return S.GetHashCode() ^ Val.GetHashCode();

    1950. 

  1950. 			    }

    1951. 

  1951. 			}

    1952. 

  1952. 			

    1953. 

  1953. 		

    1954. 

  1954. 	}

    1955. 

  1955. 				

    1956. 

  1956. 				//-------- Scenario 1722

    1957. 

  1957. 				namespace Scenario1722{

    1958. 

  1958. 					

    1959. 

  1959. 					public class Test

    1960. 

  1960. 					{

    1961. 

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

    1962. 

  1962. 				    public static Expression check16__() {

    1963. 

  1963. 				       if(Main() != 0 ) {

    1964. 

  1964. 				           throw new Exception();

    1965. 

  1965. 				       } else { 

    1966. 

  1966. 				           return Expression.Constant(0);

    1967. 

  1967. 				       }

    1968. 

  1968. 				    }

    1969. 

  1969. 					public     static int Main()

    1970. 

  1970. 					    {

    1971. 

  1971. 					        Ext.StartCapture();

    1972. 

  1972. 					        bool success = false;

    1973. 

  1973. 					        try

    1974. 

  1974. 					        {

    1975. 

  1975. 					            success = check16();

    1976. 

  1976. 					        }

    1977. 

  1977. 					        finally

    1978. 

  1978. 					        {

    1979. 

  1979. 					            Ext.StopCapture();

    1980. 

  1980. 					        }

    1981. 

  1981. 					        return success ? 0 : 1;

    1982. 

  1982. 					    }

    1983. 

  1983. 					

    1984. 

  1984. 					    static bool check16() {

    1985. 

  1985. 					        foreach (Sc val in new Sc[] { default(Sc), new Sc(), new Sc(null) }) {

    1986. 

  1986. 					            if (!check16(val)) {

    1987. 

  1987. 					                return false;

    1988. 

  1988. 					            }

    1989. 

  1989. 					        }

    1990. 

  1990. 					        return true;

    1991. 

  1991. 					    }

    1992. 

  1992. 					

    1993. 

  1993. 					    static bool check16(Sc val) {

    1994. 

  1994. 					        Expression<Func<Sc>> e =

    1995. 

  1995. 					            Expression.Lambda<Func<Sc>>(

    1996. 

  1996. 					                Expression.Constant(val, typeof(Sc)),

    1997. 

  1997. 					                new System.Collections.Generic.List<ParameterExpression>());

    1998. 

  1998. 					        Func<Sc> f = e.Compile();

    1999. 

  1999. 					        return object.Equals(f(), val);

    2000. 

  2000. 					    }

    2001. 

  2001. 					}

    2002. 

  2002. 				

    2003. 

  2003. 				

    2004. 

  2004. 				public  static class Ext {

    2005. 

  2005. 				    public static void StartCapture() {

    2006. 

  2006. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2007. 

  2007. 				//        m.Invoke(null, new object[] { "test.dll" });

    2008. 

  2008. 				    }

    2009. 

  2009. 				

    2010. 

  2010. 				    public static void StopCapture() {

    2011. 

  2011. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2012. 

  2012. 				//        m.Invoke(null, new object[0]);

    2013. 

  2013. 				    }

    2014. 

  2014. 				

    2015. 

  2015. 				    public static bool IsIntegralOrEnum(Type type) {

    2016. 

  2016. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2017. 

  2017. 				            case TypeCode.Byte:

    2018. 

  2018. 				            case TypeCode.SByte:

    2019. 

  2019. 				            case TypeCode.Int16:

    2020. 

  2020. 				            case TypeCode.Int32:

    2021. 

  2021. 				            case TypeCode.Int64:

    2022. 

  2022. 				            case TypeCode.UInt16:

    2023. 

  2023. 				            case TypeCode.UInt32:

    2024. 

  2024. 				            case TypeCode.UInt64:

    2025. 

  2025. 				                return true;

    2026. 

  2026. 				            default:

    2027. 

  2027. 				                return false;

    2028. 

  2028. 				        }

    2029. 

  2029. 				    }

    2030. 

  2030. 				

    2031. 

  2031. 				    public static bool IsFloating(Type type) {

    2032. 

  2032. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2033. 

  2033. 				            case TypeCode.Single:

    2034. 

  2034. 				            case TypeCode.Double:

    2035. 

  2035. 				                return true;

    2036. 

  2036. 				            default:

    2037. 

  2037. 				                return false;

    2038. 

  2038. 				        }

    2039. 

  2039. 				    }

    2040. 

  2040. 				

    2041. 

  2041. 				    public static Type GetNonNullableType(Type type) {

    2042. 

  2042. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    2043. 

  2043. 				                type.GetGenericArguments()[0] :

    2044. 

  2044. 				                type;

    2045. 

  2045. 				    }

    2046. 

  2046. 				}

    2047. 

  2047. 				

    2048. 

  2048. 			

    2049. 

  2049. 			

    2050. 

  2050. 			

    2051. 

  2051. 			public interface I {

    2052. 

  2052. 			  void M();

    2053. 

  2053. 			}

    2054. 

  2054. 			

    2055. 

  2055. 			public  class C : IEquatable<C>, I {

    2056. 

  2056. 			    void I.M() {

    2057. 

  2057. 			    }

    2058. 

  2058. 			

    2059. 

  2059. 			    public override bool Equals(object o) {

    2060. 

  2060. 			        return o is C && Equals((C) o);

    2061. 

  2061. 			    }

    2062. 

  2062. 			

    2063. 

  2063. 			    public bool Equals(C c) {

    2064. 

  2064. 			        return c != null;

    2065. 

  2065. 			    }

    2066. 

  2066. 			

    2067. 

  2067. 			    public override int GetHashCode() {

    2068. 

  2068. 			        return 0;

    2069. 

  2069. 			    }

    2070. 

  2070. 			}

    2071. 

  2071. 			

    2072. 

  2072. 			public  class D : C, IEquatable<D> {

    2073. 

  2073. 			    public int Val;

    2074. 

  2074. 			    public D() {

    2075. 

  2075. 			    }

    2076. 

  2076. 			    public D(int val) {

    2077. 

  2077. 			        Val = val;

    2078. 

  2078. 			    }

    2079. 

  2079. 			

    2080. 

  2080. 			    public override bool Equals(object o) {

    2081. 

  2081. 			        return o is D && Equals((D) o);

    2082. 

  2082. 			    }

    2083. 

  2083. 			

    2084. 

  2084. 			    public bool Equals(D d) {

    2085. 

  2085. 			        return d != null && d.Val == Val;

    2086. 

  2086. 			    }

    2087. 

  2087. 			

    2088. 

  2088. 			    public override int GetHashCode() {

    2089. 

  2089. 			        return Val;

    2090. 

  2090. 			    }

    2091. 

  2091. 			}

    2092. 

  2092. 			

    2093. 

  2093. 			public enum E {

    2094. 

  2094. 			  A=1, B=2

    2095. 

  2095. 			}

    2096. 

  2096. 			

    2097. 

  2097. 			public enum El : long {

    2098. 

  2098. 			  A, B, C

    2099. 

  2099. 			}

    2100. 

  2100. 			

    2101. 

  2101. 			public struct S : IEquatable<S> {

    2102. 

  2102. 			    public override bool Equals(object o) {

    2103. 

  2103. 			        return (o is S) && Equals((S) o);

    2104. 

  2104. 			    }

    2105. 

  2105. 			    public bool Equals(S other) {

    2106. 

  2106. 			        return true;

    2107. 

  2107. 			    }

    2108. 

  2108. 			    public override int GetHashCode() {

    2109. 

  2109. 			        return 0;

    2110. 

  2110. 			    }

    2111. 

  2111. 			}

    2112. 

  2112. 			

    2113. 

  2113. 			public struct Sp : IEquatable<Sp> {

    2114. 

  2114. 			    public Sp(int i, double d) {

    2115. 

  2115. 			        I = i;

    2116. 

  2116. 			        D = d;

    2117. 

  2117. 			    }

    2118. 

  2118. 			

    2119. 

  2119. 			    public int I;

    2120. 

  2120. 			    public double D;

    2121. 

  2121. 			

    2122. 

  2122. 			    public override bool Equals(object o) {

    2123. 

  2123. 			        return (o is Sp) && Equals((Sp) o);

    2124. 

  2124. 			    }

    2125. 

  2125. 			    public bool Equals(Sp other) {

    2126. 

  2126. 			        return other.I == I && other.D == D;

    2127. 

  2127. 			    }

    2128. 

  2128. 			    public override int GetHashCode() {

    2129. 

  2129. 			        return I.GetHashCode() ^ D.GetHashCode();

    2130. 

  2130. 			    }

    2131. 

  2131. 			}

    2132. 

  2132. 			

    2133. 

  2133. 			public struct Ss : IEquatable<Ss> {

    2134. 

  2134. 			    public Ss(S s) {

    2135. 

  2135. 			        Val = s;

    2136. 

  2136. 			    }

    2137. 

  2137. 			

    2138. 

  2138. 			    public S Val;

    2139. 

  2139. 			

    2140. 

  2140. 			    public override bool Equals(object o) {

    2141. 

  2141. 			        return (o is Ss) && Equals((Ss) o);

    2142. 

  2142. 			    }

    2143. 

  2143. 			    public bool Equals(Ss other) {

    2144. 

  2144. 			        return other.Val.Equals(Val);

    2145. 

  2145. 			    }

    2146. 

  2146. 			    public override int GetHashCode() {

    2147. 

  2147. 			        return Val.GetHashCode();

    2148. 

  2148. 			    }

    2149. 

  2149. 			}

    2150. 

  2150. 			

    2151. 

  2151. 			public struct Sc : IEquatable<Sc> {

    2152. 

  2152. 			    public Sc(string s) {

    2153. 

  2153. 			        S = s;

    2154. 

  2154. 			    }

    2155. 

  2155. 			

    2156. 

  2156. 			    public string S;

    2157. 

  2157. 			

    2158. 

  2158. 			    public override bool Equals(object o) {

    2159. 

  2159. 			        return (o is Sc) && Equals((Sc) o);

    2160. 

  2160. 			    }

    2161. 

  2161. 			    public bool Equals(Sc other) {

    2162. 

  2162. 			        return other.S == S;

    2163. 

  2163. 			    }

    2164. 

  2164. 			    public override int GetHashCode() {

    2165. 

  2165. 			        return S.GetHashCode();

    2166. 

  2166. 			    }

    2167. 

  2167. 			}

    2168. 

  2168. 			

    2169. 

  2169. 			public struct Scs : IEquatable<Scs> {

    2170. 

  2170. 			    public Scs(string s, S val) {

    2171. 

  2171. 			        S = s;

    2172. 

  2172. 			        Val = val;

    2173. 

  2173. 			    }

    2174. 

  2174. 			

    2175. 

  2175. 			    public string S;

    2176. 

  2176. 			    public S Val;

    2177. 

  2177. 			

    2178. 

  2178. 			    public override bool Equals(object o) {

    2179. 

  2179. 			        return (o is Scs) && Equals((Scs) o);

    2180. 

  2180. 			    }

    2181. 

  2181. 			    public bool Equals(Scs other) {

    2182. 

  2182. 			        return other.S == S && other.Val.Equals(Val);

    2183. 

  2183. 			    }

    2184. 

  2184. 			    public override int GetHashCode() {

    2185. 

  2185. 			        return S.GetHashCode() ^ Val.GetHashCode();

    2186. 

  2186. 			    }

    2187. 

  2187. 			}

    2188. 

  2188. 			

    2189. 

  2189. 		

    2190. 

  2190. 	}

    2191. 

  2191. 				

    2192. 

  2192. 				//-------- Scenario 1723

    2193. 

  2193. 				namespace Scenario1723{

    2194. 

  2194. 					

    2195. 

  2195. 					public class Test

    2196. 

  2196. 					{

    2197. 

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

    2198. 

  2198. 				    public static Expression check17__() {

    2199. 

  2199. 				       if(Main() != 0 ) {

    2200. 

  2200. 				           throw new Exception();

    2201. 

  2201. 				       } else { 

    2202. 

  2202. 				           return Expression.Constant(0);

    2203. 

  2203. 				       }

    2204. 

  2204. 				    }

    2205. 

  2205. 					public     static int Main()

    2206. 

  2206. 					    {

    2207. 

  2207. 					        Ext.StartCapture();

    2208. 

  2208. 					        bool success = false;

    2209. 

  2209. 					        try

    2210. 

  2210. 					        {

    2211. 

  2211. 					            success = check17();

    2212. 

  2212. 					        }

    2213. 

  2213. 					        finally

    2214. 

  2214. 					        {

    2215. 

  2215. 					            Ext.StopCapture();

    2216. 

  2216. 					        }

    2217. 

  2217. 					        return success ? 0 : 1;

    2218. 

  2218. 					    }

    2219. 

  2219. 					

    2220. 

  2220. 					    static bool check17() {

    2221. 

  2221. 					        foreach (Scs val in new Scs[] { default(Scs), new Scs(), new Scs(null,new S()) }) {

    2222. 

  2222. 					            if (!check17(val)) {

    2223. 

  2223. 					                return false;

    2224. 

  2224. 					            }

    2225. 

  2225. 					        }

    2226. 

  2226. 					        return true;

    2227. 

  2227. 					    }

    2228. 

  2228. 					

    2229. 

  2229. 					    static bool check17(Scs val) {

    2230. 

  2230. 					        Expression<Func<Scs>> e =

    2231. 

  2231. 					            Expression.Lambda<Func<Scs>>(

    2232. 

  2232. 					                Expression.Constant(val, typeof(Scs)),

    2233. 

  2233. 					                new System.Collections.Generic.List<ParameterExpression>());

    2234. 

  2234. 					        Func<Scs> f = e.Compile();

    2235. 

  2235. 					        return object.Equals(f(), val);

    2236. 

  2236. 					    }

    2237. 

  2237. 					}

    2238. 

  2238. 				

    2239. 

  2239. 				

    2240. 

  2240. 				public  static class Ext {

    2241. 

  2241. 				    public static void StartCapture() {

    2242. 

  2242. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2243. 

  2243. 				//        m.Invoke(null, new object[] { "test.dll" });

    2244. 

  2244. 				    }

    2245. 

  2245. 				

    2246. 

  2246. 				    public static void StopCapture() {

    2247. 

  2247. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2248. 

  2248. 				//        m.Invoke(null, new object[0]);

    2249. 

  2249. 				    }

    2250. 

  2250. 				

    2251. 

  2251. 				    public static bool IsIntegralOrEnum(Type type) {

    2252. 

  2252. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2253. 

  2253. 				            case TypeCode.Byte:

    2254. 

  2254. 				            case TypeCode.SByte:

    2255. 

  2255. 				            case TypeCode.Int16:

    2256. 

  2256. 				            case TypeCode.Int32:

    2257. 

  2257. 				            case TypeCode.Int64:

    2258. 

  2258. 				            case TypeCode.UInt16:

    2259. 

  2259. 				            case TypeCode.UInt32:

    2260. 

  2260. 				            case TypeCode.UInt64:

    2261. 

  2261. 				                return true;

    2262. 

  2262. 				            default:

    2263. 

  2263. 				                return false;

    2264. 

  2264. 				        }

    2265. 

  2265. 				    }

    2266. 

  2266. 				

    2267. 

  2267. 				    public static bool IsFloating(Type type) {

    2268. 

  2268. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2269. 

  2269. 				            case TypeCode.Single:

    2270. 

  2270. 				            case TypeCode.Double:

    2271. 

  2271. 				                return true;

    2272. 

  2272. 				            default:

    2273. 

  2273. 				                return false;

    2274. 

  2274. 				        }

    2275. 

  2275. 				    }

    2276. 

  2276. 				

    2277. 

  2277. 				    public static Type GetNonNullableType(Type type) {

    2278. 

  2278. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    2279. 

  2279. 				                type.GetGenericArguments()[0] :

    2280. 

  2280. 				                type;

    2281. 

  2281. 				    }

    2282. 

  2282. 				}

    2283. 

  2283. 				

    2284. 

  2284. 			

    2285. 

  2285. 			

    2286. 

  2286. 			

    2287. 

  2287. 			public interface I {

    2288. 

  2288. 			  void M();

    2289. 

  2289. 			}

    2290. 

  2290. 			

    2291. 

  2291. 			public  class C : IEquatable<C>, I {

    2292. 

  2292. 			    void I.M() {

    2293. 

  2293. 			    }

    2294. 

  2294. 			

    2295. 

  2295. 			    public override bool Equals(object o) {

    2296. 

  2296. 			        return o is C && Equals((C) o);

    2297. 

  2297. 			    }

    2298. 

  2298. 			

    2299. 

  2299. 			    public bool Equals(C c) {

    2300. 

  2300. 			        return c != null;

    2301. 

  2301. 			    }

    2302. 

  2302. 			

    2303. 

  2303. 			    public override int GetHashCode() {

    2304. 

  2304. 			        return 0;

    2305. 

  2305. 			    }

    2306. 

  2306. 			}

    2307. 

  2307. 			

    2308. 

  2308. 			public  class D : C, IEquatable<D> {

    2309. 

  2309. 			    public int Val;

    2310. 

  2310. 			    public D() {

    2311. 

  2311. 			    }

    2312. 

  2312. 			    public D(int val) {

    2313. 

  2313. 			        Val = val;

    2314. 

  2314. 			    }

    2315. 

  2315. 			

    2316. 

  2316. 			    public override bool Equals(object o) {

    2317. 

  2317. 			        return o is D && Equals((D) o);

    2318. 

  2318. 			    }

    2319. 

  2319. 			

    2320. 

  2320. 			    public bool Equals(D d) {

    2321. 

  2321. 			        return d != null && d.Val == Val;

    2322. 

  2322. 			    }

    2323. 

  2323. 			

    2324. 

  2324. 			    public override int GetHashCode() {

    2325. 

  2325. 			        return Val;

    2326. 

  2326. 			    }

    2327. 

  2327. 			}

    2328. 

  2328. 			

    2329. 

  2329. 			public enum E {

    2330. 

  2330. 			  A=1, B=2

    2331. 

  2331. 			}

    2332. 

  2332. 			

    2333. 

  2333. 			public enum El : long {

    2334. 

  2334. 			  A, B, C

    2335. 

  2335. 			}

    2336. 

  2336. 			

    2337. 

  2337. 			public struct S : IEquatable<S> {

    2338. 

  2338. 			    public override bool Equals(object o) {

    2339. 

  2339. 			        return (o is S) && Equals((S) o);

    2340. 

  2340. 			    }

    2341. 

  2341. 			    public bool Equals(S other) {

    2342. 

  2342. 			        return true;

    2343. 

  2343. 			    }

    2344. 

  2344. 			    public override int GetHashCode() {

    2345. 

  2345. 			        return 0;

    2346. 

  2346. 			    }

    2347. 

  2347. 			}

    2348. 

  2348. 			

    2349. 

  2349. 			public struct Sp : IEquatable<Sp> {

    2350. 

  2350. 			    public Sp(int i, double d) {

    2351. 

  2351. 			        I = i;

    2352. 

  2352. 			        D = d;

    2353. 

  2353. 			    }

    2354. 

  2354. 			

    2355. 

  2355. 			    public int I;

    2356. 

  2356. 			    public double D;

    2357. 

  2357. 			

    2358. 

  2358. 			    public override bool Equals(object o) {

    2359. 

  2359. 			        return (o is Sp) && Equals((Sp) o);

    2360. 

  2360. 			    }

    2361. 

  2361. 			    public bool Equals(Sp other) {

    2362. 

  2362. 			        return other.I == I && other.D == D;

    2363. 

  2363. 			    }

    2364. 

  2364. 			    public override int GetHashCode() {

    2365. 

  2365. 			        return I.GetHashCode() ^ D.GetHashCode();

    2366. 

  2366. 			    }

    2367. 

  2367. 			}

    2368. 

  2368. 			

    2369. 

  2369. 			public struct Ss : IEquatable<Ss> {

    2370. 

  2370. 			    public Ss(S s) {

    2371. 

  2371. 			        Val = s;

    2372. 

  2372. 			    }

    2373. 

  2373. 			

    2374. 

  2374. 			    public S Val;

    2375. 

  2375. 			

    2376. 

  2376. 			    public override bool Equals(object o) {

    2377. 

  2377. 			        return (o is Ss) && Equals((Ss) o);

    2378. 

  2378. 			    }

    2379. 

  2379. 			    public bool Equals(Ss other) {

    2380. 

  2380. 			        return other.Val.Equals(Val);

    2381. 

  2381. 			    }

    2382. 

  2382. 			    public override int GetHashCode() {

    2383. 

  2383. 			        return Val.GetHashCode();

    2384. 

  2384. 			    }

    2385. 

  2385. 			}

    2386. 

  2386. 			

    2387. 

  2387. 			public struct Sc : IEquatable<Sc> {

    2388. 

  2388. 			    public Sc(string s) {

    2389. 

  2389. 			        S = s;

    2390. 

  2390. 			    }

    2391. 

  2391. 			

    2392. 

  2392. 			    public string S;

    2393. 

  2393. 			

    2394. 

  2394. 			    public override bool Equals(object o) {

    2395. 

  2395. 			        return (o is Sc) && Equals((Sc) o);

    2396. 

  2396. 			    }

    2397. 

  2397. 			    public bool Equals(Sc other) {

    2398. 

  2398. 			        return other.S == S;

    2399. 

  2399. 			    }

    2400. 

  2400. 			    public override int GetHashCode() {

    2401. 

  2401. 			        return S.GetHashCode();

    2402. 

  2402. 			    }

    2403. 

  2403. 			}

    2404. 

  2404. 			

    2405. 

  2405. 			public struct Scs : IEquatable<Scs> {

    2406. 

  2406. 			    public Scs(string s, S val) {

    2407. 

  2407. 			        S = s;

    2408. 

  2408. 			        Val = val;

    2409. 

  2409. 			    }

    2410. 

  2410. 			

    2411. 

  2411. 			    public string S;

    2412. 

  2412. 			    public S Val;

    2413. 

  2413. 			

    2414. 

  2414. 			    public override bool Equals(object o) {

    2415. 

  2415. 			        return (o is Scs) && Equals((Scs) o);

    2416. 

  2416. 			    }

    2417. 

  2417. 			    public bool Equals(Scs other) {

    2418. 

  2418. 			        return other.S == S && other.Val.Equals(Val);

    2419. 

  2419. 			    }

    2420. 

  2420. 			    public override int GetHashCode() {

    2421. 

  2421. 			        return S.GetHashCode() ^ Val.GetHashCode();

    2422. 

  2422. 			    }

    2423. 

  2423. 			}

    2424. 

  2424. 			

    2425. 

  2425. 		

    2426. 

  2426. 	}

    2427. 

  2427. 				

    2428. 

  2428. 				//-------- Scenario 1724

    2429. 

  2429. 				namespace Scenario1724{

    2430. 

  2430. 					

    2431. 

  2431. 					public class Test

    2432. 

  2432. 					{

    2433. 

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

    2434. 

  2434. 				    public static Expression check18_S___() {

    2435. 

  2435. 				       if(Main() != 0 ) {

    2436. 

  2436. 				           throw new Exception();

    2437. 

  2437. 				       } else { 

    2438. 

  2438. 				           return Expression.Constant(0);

    2439. 

  2439. 				       }

    2440. 

  2440. 				    }

    2441. 

  2441. 					public     static int Main()

    2442. 

  2442. 					    {

    2443. 

  2443. 					        Ext.StartCapture();

    2444. 

  2444. 					        bool success = false;

    2445. 

  2445. 					        try

    2446. 

  2446. 					        {

    2447. 

  2447. 					            success = check18<S>();

    2448. 

  2448. 					        }

    2449. 

  2449. 					        finally

    2450. 

  2450. 					        {

    2451. 

  2451. 					            Ext.StopCapture();

    2452. 

  2452. 					        }

    2453. 

  2453. 					        return success ? 0 : 1;

    2454. 

  2454. 					    }

    2455. 

  2455. 					

    2456. 

  2456. 					    static bool check18<Ts>() where Ts : struct {

    2457. 

  2457. 					        foreach (Ts val in new Ts[] { default(Ts), new Ts() }) {

    2458. 

  2458. 					            if (!check18<Ts>(val)) {

    2459. 

  2459. 					                return false;

    2460. 

  2460. 					            }

    2461. 

  2461. 					        }

    2462. 

  2462. 					        return true;

    2463. 

  2463. 					    }

    2464. 

  2464. 					

    2465. 

  2465. 					    static bool check18<Ts>(Ts val) where Ts : struct {

    2466. 

  2466. 					        Expression<Func<Ts>> e =

    2467. 

  2467. 					            Expression.Lambda<Func<Ts>>(

    2468. 

  2468. 					                Expression.Constant(val, typeof(Ts)),

    2469. 

  2469. 					                new System.Collections.Generic.List<ParameterExpression>());

    2470. 

  2470. 					        Func<Ts> f = e.Compile();

    2471. 

  2471. 					        return object.Equals(f(), val);

    2472. 

  2472. 					    }

    2473. 

  2473. 					}

    2474. 

  2474. 				

    2475. 

  2475. 				

    2476. 

  2476. 				public  static class Ext {

    2477. 

  2477. 				    public static void StartCapture() {

    2478. 

  2478. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2479. 

  2479. 				//        m.Invoke(null, new object[] { "test.dll" });

    2480. 

  2480. 				    }

    2481. 

  2481. 				

    2482. 

  2482. 				    public static void StopCapture() {

    2483. 

  2483. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2484. 

  2484. 				//        m.Invoke(null, new object[0]);

    2485. 

  2485. 				    }

    2486. 

  2486. 				

    2487. 

  2487. 				    public static bool IsIntegralOrEnum(Type type) {

    2488. 

  2488. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2489. 

  2489. 				            case TypeCode.Byte:

    2490. 

  2490. 				            case TypeCode.SByte:

    2491. 

  2491. 				            case TypeCode.Int16:

    2492. 

  2492. 				            case TypeCode.Int32:

    2493. 

  2493. 				            case TypeCode.Int64:

    2494. 

  2494. 				            case TypeCode.UInt16:

    2495. 

  2495. 				            case TypeCode.UInt32:

    2496. 

  2496. 				            case TypeCode.UInt64:

    2497. 

  2497. 				                return true;

    2498. 

  2498. 				            default:

    2499. 

  2499. 				                return false;

    2500. 

  2500. 				        }

    2501. 

  2501. 				    }

    2502. 

  2502. 				

    2503. 

  2503. 				    public static bool IsFloating(Type type) {

    2504. 

  2504. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2505. 

  2505. 				            case TypeCode.Single:

    2506. 

  2506. 				            case TypeCode.Double:

    2507. 

  2507. 				                return true;

    2508. 

  2508. 				            default:

    2509. 

  2509. 				                return false;

    2510. 

  2510. 				        }

    2511. 

  2511. 				    }

    2512. 

  2512. 				

    2513. 

  2513. 				    public static Type GetNonNullableType(Type type) {

    2514. 

  2514. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    2515. 

  2515. 				                type.GetGenericArguments()[0] :

    2516. 

  2516. 				                type;

    2517. 

  2517. 				    }

    2518. 

  2518. 				}

    2519. 

  2519. 				

    2520. 

  2520. 			

    2521. 

  2521. 			

    2522. 

  2522. 			

    2523. 

  2523. 			public interface I {

    2524. 

  2524. 			  void M();

    2525. 

  2525. 			}

    2526. 

  2526. 			

    2527. 

  2527. 			public  class C : IEquatable<C>, I {

    2528. 

  2528. 			    void I.M() {

    2529. 

  2529. 			    }

    2530. 

  2530. 			

    2531. 

  2531. 			    public override bool Equals(object o) {

    2532. 

  2532. 			        return o is C && Equals((C) o);

    2533. 

  2533. 			    }

    2534. 

  2534. 			

    2535. 

  2535. 			    public bool Equals(C c) {

    2536. 

  2536. 			        return c != null;

    2537. 

  2537. 			    }

    2538. 

  2538. 			

    2539. 

  2539. 			    public override int GetHashCode() {

    2540. 

  2540. 			        return 0;

    2541. 

  2541. 			    }

    2542. 

  2542. 			}

    2543. 

  2543. 			

    2544. 

  2544. 			public  class D : C, IEquatable<D> {

    2545. 

  2545. 			    public int Val;

    2546. 

  2546. 			    public D() {

    2547. 

  2547. 			    }

    2548. 

  2548. 			    public D(int val) {

    2549. 

  2549. 			        Val = val;

    2550. 

  2550. 			    }

    2551. 

  2551. 			

    2552. 

  2552. 			    public override bool Equals(object o) {

    2553. 

  2553. 			        return o is D && Equals((D) o);

    2554. 

  2554. 			    }

    2555. 

  2555. 			

    2556. 

  2556. 			    public bool Equals(D d) {

    2557. 

  2557. 			        return d != null && d.Val == Val;

    2558. 

  2558. 			    }

    2559. 

  2559. 			

    2560. 

  2560. 			    public override int GetHashCode() {

    2561. 

  2561. 			        return Val;

    2562. 

  2562. 			    }

    2563. 

  2563. 			}

    2564. 

  2564. 			

    2565. 

  2565. 			public enum E {

    2566. 

  2566. 			  A=1, B=2

    2567. 

  2567. 			}

    2568. 

  2568. 			

    2569. 

  2569. 			public enum El : long {

    2570. 

  2570. 			  A, B, C

    2571. 

  2571. 			}

    2572. 

  2572. 			

    2573. 

  2573. 			public struct S : IEquatable<S> {

    2574. 

  2574. 			    public override bool Equals(object o) {

    2575. 

  2575. 			        return (o is S) && Equals((S) o);

    2576. 

  2576. 			    }

    2577. 

  2577. 			    public bool Equals(S other) {

    2578. 

  2578. 			        return true;

    2579. 

  2579. 			    }

    2580. 

  2580. 			    public override int GetHashCode() {

    2581. 

  2581. 			        return 0;

    2582. 

  2582. 			    }

    2583. 

  2583. 			}

    2584. 

  2584. 			

    2585. 

  2585. 			public struct Sp : IEquatable<Sp> {

    2586. 

  2586. 			    public Sp(int i, double d) {

    2587. 

  2587. 			        I = i;

    2588. 

  2588. 			        D = d;

    2589. 

  2589. 			    }

    2590. 

  2590. 			

    2591. 

  2591. 			    public int I;

    2592. 

  2592. 			    public double D;

    2593. 

  2593. 			

    2594. 

  2594. 			    public override bool Equals(object o) {

    2595. 

  2595. 			        return (o is Sp) && Equals((Sp) o);

    2596. 

  2596. 			    }

    2597. 

  2597. 			    public bool Equals(Sp other) {

    2598. 

  2598. 			        return other.I == I && other.D == D;

    2599. 

  2599. 			    }

    2600. 

  2600. 			    public override int GetHashCode() {

    2601. 

  2601. 			        return I.GetHashCode() ^ D.GetHashCode();

    2602. 

  2602. 			    }

    2603. 

  2603. 			}

    2604. 

  2604. 			

    2605. 

  2605. 			public struct Ss : IEquatable<Ss> {

    2606. 

  2606. 			    public Ss(S s) {

    2607. 

  2607. 			        Val = s;

    2608. 

  2608. 			    }

    2609. 

  2609. 			

    2610. 

  2610. 			    public S Val;

    2611. 

  2611. 			

    2612. 

  2612. 			    public override bool Equals(object o) {

    2613. 

  2613. 			        return (o is Ss) && Equals((Ss) o);

    2614. 

  2614. 			    }

    2615. 

  2615. 			    public bool Equals(Ss other) {

    2616. 

  2616. 			        return other.Val.Equals(Val);

    2617. 

  2617. 			    }

    2618. 

  2618. 			    public override int GetHashCode() {

    2619. 

  2619. 			        return Val.GetHashCode();

    2620. 

  2620. 			    }

    2621. 

  2621. 			}

    2622. 

  2622. 			

    2623. 

  2623. 			public struct Sc : IEquatable<Sc> {

    2624. 

  2624. 			    public Sc(string s) {

    2625. 

  2625. 			        S = s;

    2626. 

  2626. 			    }

    2627. 

  2627. 			

    2628. 

  2628. 			    public string S;

    2629. 

  2629. 			

    2630. 

  2630. 			    public override bool Equals(object o) {

    2631. 

  2631. 			        return (o is Sc) && Equals((Sc) o);

    2632. 

  2632. 			    }

    2633. 

  2633. 			    public bool Equals(Sc other) {

    2634. 

  2634. 			        return other.S == S;

    2635. 

  2635. 			    }

    2636. 

  2636. 			    public override int GetHashCode() {

    2637. 

  2637. 			        return S.GetHashCode();

    2638. 

  2638. 			    }

    2639. 

  2639. 			}

    2640. 

  2640. 			

    2641. 

  2641. 			public struct Scs : IEquatable<Scs> {

    2642. 

  2642. 			    public Scs(string s, S val) {

    2643. 

  2643. 			        S = s;

    2644. 

  2644. 			        Val = val;

    2645. 

  2645. 			    }

    2646. 

  2646. 			

    2647. 

  2647. 			    public string S;

    2648. 

  2648. 			    public S Val;

    2649. 

  2649. 			

    2650. 

  2650. 			    public override bool Equals(object o) {

    2651. 

  2651. 			        return (o is Scs) && Equals((Scs) o);

    2652. 

  2652. 			    }

    2653. 

  2653. 			    public bool Equals(Scs other) {

    2654. 

  2654. 			        return other.S == S && other.Val.Equals(Val);

    2655. 

  2655. 			    }

    2656. 

  2656. 			    public override int GetHashCode() {

    2657. 

  2657. 			        return S.GetHashCode() ^ Val.GetHashCode();

    2658. 

  2658. 			    }

    2659. 

  2659. 			}

    2660. 

  2660. 			

    2661. 

  2661. 		

    2662. 

  2662. 	}

    2663. 

  2663. 				

    2664. 

  2664. 				//-------- Scenario 1725

    2665. 

  2665. 				namespace Scenario1725{

    2666. 

  2666. 					

    2667. 

  2667. 					public class Test

    2668. 

  2668. 					{

    2669. 

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

    2670. 

  2670. 				    public static Expression check18_Scs___() {

    2671. 

  2671. 				       if(Main() != 0 ) {

    2672. 

  2672. 				           throw new Exception();

    2673. 

  2673. 				       } else { 

    2674. 

  2674. 				           return Expression.Constant(0);

    2675. 

  2675. 				       }

    2676. 

  2676. 				    }

    2677. 

  2677. 					public     static int Main()

    2678. 

  2678. 					    {

    2679. 

  2679. 					        Ext.StartCapture();

    2680. 

  2680. 					        bool success = false;

    2681. 

  2681. 					        try

    2682. 

  2682. 					        {

    2683. 

  2683. 					            success = check18<Scs>();

    2684. 

  2684. 					        }

    2685. 

  2685. 					        finally

    2686. 

  2686. 					        {

    2687. 

  2687. 					            Ext.StopCapture();

    2688. 

  2688. 					        }

    2689. 

  2689. 					        return success ? 0 : 1;

    2690. 

  2690. 					    }

    2691. 

  2691. 					

    2692. 

  2692. 					    static bool check18<Ts>() where Ts : struct {

    2693. 

  2693. 					        foreach (Ts val in new Ts[] { default(Ts), new Ts() }) {

    2694. 

  2694. 					            if (!check18<Ts>(val)) {

    2695. 

  2695. 					                return false;

    2696. 

  2696. 					            }

    2697. 

  2697. 					        }

    2698. 

  2698. 					        return true;

    2699. 

  2699. 					    }

    2700. 

  2700. 					

    2701. 

  2701. 					    static bool check18<Ts>(Ts val) where Ts : struct {

    2702. 

  2702. 					        Expression<Func<Ts>> e =

    2703. 

  2703. 					            Expression.Lambda<Func<Ts>>(

    2704. 

  2704. 					                Expression.Constant(val, typeof(Ts)),

    2705. 

  2705. 					                new System.Collections.Generic.List<ParameterExpression>());

    2706. 

  2706. 					        Func<Ts> f = e.Compile();

    2707. 

  2707. 					        return object.Equals(f(), val);

    2708. 

  2708. 					    }

    2709. 

  2709. 					}

    2710. 

  2710. 				

    2711. 

  2711. 				

    2712. 

  2712. 				public  static class Ext {

    2713. 

  2713. 				    public static void StartCapture() {

    2714. 

  2714. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2715. 

  2715. 				//        m.Invoke(null, new object[] { "test.dll" });

    2716. 

  2716. 				    }

    2717. 

  2717. 				

    2718. 

  2718. 				    public static void StopCapture() {

    2719. 

  2719. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2720. 

  2720. 				//        m.Invoke(null, new object[0]);

    2721. 

  2721. 				    }

    2722. 

  2722. 				

    2723. 

  2723. 				    public static bool IsIntegralOrEnum(Type type) {

    2724. 

  2724. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2725. 

  2725. 				            case TypeCode.Byte:

    2726. 

  2726. 				            case TypeCode.SByte:

    2727. 

  2727. 				            case TypeCode.Int16:

    2728. 

  2728. 				            case TypeCode.Int32:

    2729. 

  2729. 				            case TypeCode.Int64:

    2730. 

  2730. 				            case TypeCode.UInt16:

    2731. 

  2731. 				            case TypeCode.UInt32:

    2732. 

  2732. 				            case TypeCode.UInt64:

    2733. 

  2733. 				                return true;

    2734. 

  2734. 				            default:

    2735. 

  2735. 				                return false;

    2736. 

  2736. 				        }

    2737. 

  2737. 				    }

    2738. 

  2738. 				

    2739. 

  2739. 				    public static bool IsFloating(Type type) {

    2740. 

  2740. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2741. 

  2741. 				            case TypeCode.Single:

    2742. 

  2742. 				            case TypeCode.Double:

    2743. 

  2743. 				                return true;

    2744. 

  2744. 				            default:

    2745. 

  2745. 				                return false;

    2746. 

  2746. 				        }

    2747. 

  2747. 				    }

    2748. 

  2748. 				

    2749. 

  2749. 				    public static Type GetNonNullableType(Type type) {

    2750. 

  2750. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    2751. 

  2751. 				                type.GetGenericArguments()[0] :

    2752. 

  2752. 				                type;

    2753. 

  2753. 				    }

    2754. 

  2754. 				}

    2755. 

  2755. 				

    2756. 

  2756. 			

    2757. 

  2757. 			

    2758. 

  2758. 			

    2759. 

  2759. 			public interface I {

    2760. 

  2760. 			  void M();

    2761. 

  2761. 			}

    2762. 

  2762. 			

    2763. 

  2763. 			public  class C : IEquatable<C>, I {

    2764. 

  2764. 			    void I.M() {

    2765. 

  2765. 			    }

    2766. 

  2766. 			

    2767. 

  2767. 			    public override bool Equals(object o) {

    2768. 

  2768. 			        return o is C && Equals((C) o);

    2769. 

  2769. 			    }

    2770. 

  2770. 			

    2771. 

  2771. 			    public bool Equals(C c) {

    2772. 

  2772. 			        return c != null;

    2773. 

  2773. 			    }

    2774. 

  2774. 			

    2775. 

  2775. 			    public override int GetHashCode() {

    2776. 

  2776. 			        return 0;

    2777. 

  2777. 			    }

    2778. 

  2778. 			}

    2779. 

  2779. 			

    2780. 

  2780. 			public  class D : C, IEquatable<D> {

    2781. 

  2781. 			    public int Val;

    2782. 

  2782. 			    public D() {

    2783. 

  2783. 			    }

    2784. 

  2784. 			    public D(int val) {

    2785. 

  2785. 			        Val = val;

    2786. 

  2786. 			    }

    2787. 

  2787. 			

    2788. 

  2788. 			    public override bool Equals(object o) {

    2789. 

  2789. 			        return o is D && Equals((D) o);

    2790. 

  2790. 			    }

    2791. 

  2791. 			

    2792. 

  2792. 			    public bool Equals(D d) {

    2793. 

  2793. 			        return d != null && d.Val == Val;

    2794. 

  2794. 			    }

    2795. 

  2795. 			

    2796. 

  2796. 			    public override int GetHashCode() {

    2797. 

  2797. 			        return Val;

    2798. 

  2798. 			    }

    2799. 

  2799. 			}

    2800. 

  2800. 			

    2801. 

  2801. 			public enum E {

    2802. 

  2802. 			  A=1, B=2

    2803. 

  2803. 			}

    2804. 

  2804. 			

    2805. 

  2805. 			public enum El : long {

    2806. 

  2806. 			  A, B, C

    2807. 

  2807. 			}

    2808. 

  2808. 			

    2809. 

  2809. 			public struct S : IEquatable<S> {

    2810. 

  2810. 			    public override bool Equals(object o) {

    2811. 

  2811. 			        return (o is S) && Equals((S) o);

    2812. 

  2812. 			    }

    2813. 

  2813. 			    public bool Equals(S other) {

    2814. 

  2814. 			        return true;

    2815. 

  2815. 			    }

    2816. 

  2816. 			    public override int GetHashCode() {

    2817. 

  2817. 			        return 0;

    2818. 

  2818. 			    }

    2819. 

  2819. 			}

    2820. 

  2820. 			

    2821. 

  2821. 			public struct Sp : IEquatable<Sp> {

    2822. 

  2822. 			    public Sp(int i, double d) {

    2823. 

  2823. 			        I = i;

    2824. 

  2824. 			        D = d;

    2825. 

  2825. 			    }

    2826. 

  2826. 			

    2827. 

  2827. 			    public int I;

    2828. 

  2828. 			    public double D;

    2829. 

  2829. 			

    2830. 

  2830. 			    public override bool Equals(object o) {

    2831. 

  2831. 			        return (o is Sp) && Equals((Sp) o);

    2832. 

  2832. 			    }

    2833. 

  2833. 			    public bool Equals(Sp other) {

    2834. 

  2834. 			        return other.I == I && other.D == D;

    2835. 

  2835. 			    }

    2836. 

  2836. 			    public override int GetHashCode() {

    2837. 

  2837. 			        return I.GetHashCode() ^ D.GetHashCode();

    2838. 

  2838. 			    }

    2839. 

  2839. 			}

    2840. 

  2840. 			

    2841. 

  2841. 			public struct Ss : IEquatable<Ss> {

    2842. 

  2842. 			    public Ss(S s) {

    2843. 

  2843. 			        Val = s;

    2844. 

  2844. 			    }

    2845. 

  2845. 			

    2846. 

  2846. 			    public S Val;

    2847. 

  2847. 			

    2848. 

  2848. 			    public override bool Equals(object o) {

    2849. 

  2849. 			        return (o is Ss) && Equals((Ss) o);

    2850. 

  2850. 			    }

    2851. 

  2851. 			    public bool Equals(Ss other) {

    2852. 

  2852. 			        return other.Val.Equals(Val);

    2853. 

  2853. 			    }

    2854. 

  2854. 			    public override int GetHashCode() {

    2855. 

  2855. 			        return Val.GetHashCode();

    2856. 

  2856. 			    }

    2857. 

  2857. 			}

    2858. 

  2858. 			

    2859. 

  2859. 			public struct Sc : IEquatable<Sc> {

    2860. 

  2860. 			    public Sc(string s) {

    2861. 

  2861. 			        S = s;

    2862. 

  2862. 			    }

    2863. 

  2863. 			

    2864. 

  2864. 			    public string S;

    2865. 

  2865. 			

    2866. 

  2866. 			    public override bool Equals(object o) {

    2867. 

  2867. 			        return (o is Sc) && Equals((Sc) o);

    2868. 

  2868. 			    }

    2869. 

  2869. 			    public bool Equals(Sc other) {

    2870. 

  2870. 			        return other.S == S;

    2871. 

  2871. 			    }

    2872. 

  2872. 			    public override int GetHashCode() {

    2873. 

  2873. 			        return S.GetHashCode();

    2874. 

  2874. 			    }

    2875. 

  2875. 			}

    2876. 

  2876. 			

    2877. 

  2877. 			public struct Scs : IEquatable<Scs> {

    2878. 

  2878. 			    public Scs(string s, S val) {

    2879. 

  2879. 			        S = s;

    2880. 

  2880. 			        Val = val;

    2881. 

  2881. 			    }

    2882. 

  2882. 			

    2883. 

  2883. 			    public string S;

    2884. 

  2884. 			    public S Val;

    2885. 

  2885. 			

    2886. 

  2886. 			    public override bool Equals(object o) {

    2887. 

  2887. 			        return (o is Scs) && Equals((Scs) o);

    2888. 

  2888. 			    }

    2889. 

  2889. 			    public bool Equals(Scs other) {

    2890. 

  2890. 			        return other.S == S && other.Val.Equals(Val);

    2891. 

  2891. 			    }

    2892. 

  2892. 			    public override int GetHashCode() {

    2893. 

  2893. 			        return S.GetHashCode() ^ Val.GetHashCode();

    2894. 

  2894. 			    }

    2895. 

  2895. 			}

    2896. 

  2896. 			

    2897. 

  2897. 		

    2898. 

  2898. 	}

    2899. 

  2899. 				

    2900. 

  2900. 				//-------- Scenario 1726

    2901. 

  2901. 				namespace Scenario1726{

    2902. 

  2902. 					

    2903. 

  2903. 					public class Test

    2904. 

  2904. 					{

    2905. 

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

    2906. 

  2906. 				    public static Expression check18_E___() {

    2907. 

  2907. 				       if(Main() != 0 ) {

    2908. 

  2908. 				           throw new Exception();

    2909. 

  2909. 				       } else { 

    2910. 

  2910. 				           return Expression.Constant(0);

    2911. 

  2911. 				       }

    2912. 

  2912. 				    }

    2913. 

  2913. 					public     static int Main()

    2914. 

  2914. 					    {

    2915. 

  2915. 					        Ext.StartCapture();

    2916. 

  2916. 					        bool success = false;

    2917. 

  2917. 					        try

    2918. 

  2918. 					        {

    2919. 

  2919. 					            success = check18<E>();

    2920. 

  2920. 					        }

    2921. 

  2921. 					        finally

    2922. 

  2922. 					        {

    2923. 

  2923. 					            Ext.StopCapture();

    2924. 

  2924. 					        }

    2925. 

  2925. 					        return success ? 0 : 1;

    2926. 

  2926. 					    }

    2927. 

  2927. 					

    2928. 

  2928. 					    static bool check18<Ts>() where Ts : struct {

    2929. 

  2929. 					        foreach (Ts val in new Ts[] { default(Ts), new Ts() }) {

    2930. 

  2930. 					            if (!check18<Ts>(val)) {

    2931. 

  2931. 					                return false;

    2932. 

  2932. 					            }

    2933. 

  2933. 					        }

    2934. 

  2934. 					        return true;

    2935. 

  2935. 					    }

    2936. 

  2936. 					

    2937. 

  2937. 					    static bool check18<Ts>(Ts val) where Ts : struct {

    2938. 

  2938. 					        Expression<Func<Ts>> e =

    2939. 

  2939. 					            Expression.Lambda<Func<Ts>>(

    2940. 

  2940. 					                Expression.Constant(val, typeof(Ts)),

    2941. 

  2941. 					                new System.Collections.Generic.List<ParameterExpression>());

    2942. 

  2942. 					        Func<Ts> f = e.Compile();

    2943. 

  2943. 					        return object.Equals(f(), val);

    2944. 

  2944. 					    }

    2945. 

  2945. 					}

    2946. 

  2946. 				

    2947. 

  2947. 				

    2948. 

  2948. 				public  static class Ext {

    2949. 

  2949. 				    public static void StartCapture() {

    2950. 

  2950. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2951. 

  2951. 				//        m.Invoke(null, new object[] { "test.dll" });

    2952. 

  2952. 				    }

    2953. 

  2953. 				

    2954. 

  2954. 				    public static void StopCapture() {

    2955. 

  2955. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    2956. 

  2956. 				//        m.Invoke(null, new object[0]);

    2957. 

  2957. 				    }

    2958. 

  2958. 				

    2959. 

  2959. 				    public static bool IsIntegralOrEnum(Type type) {

    2960. 

  2960. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2961. 

  2961. 				            case TypeCode.Byte:

    2962. 

  2962. 				            case TypeCode.SByte:

    2963. 

  2963. 				            case TypeCode.Int16:

    2964. 

  2964. 				            case TypeCode.Int32:

    2965. 

  2965. 				            case TypeCode.Int64:

    2966. 

  2966. 				            case TypeCode.UInt16:

    2967. 

  2967. 				            case TypeCode.UInt32:

    2968. 

  2968. 				            case TypeCode.UInt64:

    2969. 

  2969. 				                return true;

    2970. 

  2970. 				            default:

    2971. 

  2971. 				                return false;

    2972. 

  2972. 				        }

    2973. 

  2973. 				    }

    2974. 

  2974. 				

    2975. 

  2975. 				    public static bool IsFloating(Type type) {

    2976. 

  2976. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    2977. 

  2977. 				            case TypeCode.Single:

    2978. 

  2978. 				            case TypeCode.Double:

    2979. 

  2979. 				                return true;

    2980. 

  2980. 				            default:

    2981. 

  2981. 				                return false;

    2982. 

  2982. 				        }

    2983. 

  2983. 				    }

    2984. 

  2984. 				

    2985. 

  2985. 				    public static Type GetNonNullableType(Type type) {

    2986. 

  2986. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    2987. 

  2987. 				                type.GetGenericArguments()[0] :

    2988. 

  2988. 				                type;

    2989. 

  2989. 				    }

    2990. 

  2990. 				}

    2991. 

  2991. 				

    2992. 

  2992. 			

    2993. 

  2993. 			

    2994. 

  2994. 			

    2995. 

  2995. 			public interface I {

    2996. 

  2996. 			  void M();

    2997. 

  2997. 			}

    2998. 

  2998. 			

    2999. 

  2999. 			public  class C : IEquatable<C>, I {

    3000. 

  3000. 			    void I.M() {

    3001. 

  3001. 			    }

    3002. 

  3002. 			

    3003. 

  3003. 			    public override bool Equals(object o) {

    3004. 

  3004. 			        return o is C && Equals((C) o);

    3005. 

  3005. 			    }

    3006. 

  3006. 			

    3007. 

  3007. 			    public bool Equals(C c) {

    3008. 

  3008. 			        return c != null;

    3009. 

  3009. 			    }

    3010. 

  3010. 			

    3011. 

  3011. 			    public override int GetHashCode() {

    3012. 

  3012. 			        return 0;

    3013. 

  3013. 			    }

    3014. 

  3014. 			}

    3015. 

  3015. 			

    3016. 

  3016. 			public  class D : C, IEquatable<D> {

    3017. 

  3017. 			    public int Val;

    3018. 

  3018. 			    public D() {

    3019. 

  3019. 			    }

    3020. 

  3020. 			    public D(int val) {

    3021. 

  3021. 			        Val = val;

    3022. 

  3022. 			    }

    3023. 

  3023. 			

    3024. 

  3024. 			    public override bool Equals(object o) {

    3025. 

  3025. 			        return o is D && Equals((D) o);

    3026. 

  3026. 			    }

    3027. 

  3027. 			

    3028. 

  3028. 			    public bool Equals(D d) {

    3029. 

  3029. 			        return d != null && d.Val == Val;

    3030. 

  3030. 			    }

    3031. 

  3031. 			

    3032. 

  3032. 			    public override int GetHashCode() {

    3033. 

  3033. 			        return Val;

    3034. 

  3034. 			    }

    3035. 

  3035. 			}

    3036. 

  3036. 			

    3037. 

  3037. 			public enum E {

    3038. 

  3038. 			  A=1, B=2

    3039. 

  3039. 			}

    3040. 

  3040. 			

    3041. 

  3041. 			public enum El : long {

    3042. 

  3042. 			  A, B, C

    3043. 

  3043. 			}

    3044. 

  3044. 			

    3045. 

  3045. 			public struct S : IEquatable<S> {

    3046. 

  3046. 			    public override bool Equals(object o) {

    3047. 

  3047. 			        return (o is S) && Equals((S) o);

    3048. 

  3048. 			    }

    3049. 

  3049. 			    public bool Equals(S other) {

    3050. 

  3050. 			        return true;

    3051. 

  3051. 			    }

    3052. 

  3052. 			    public override int GetHashCode() {

    3053. 

  3053. 			        return 0;

    3054. 

  3054. 			    }

    3055. 

  3055. 			}

    3056. 

  3056. 			

    3057. 

  3057. 			public struct Sp : IEquatable<Sp> {

    3058. 

  3058. 			    public Sp(int i, double d) {

    3059. 

  3059. 			        I = i;

    3060. 

  3060. 			        D = d;

    3061. 

  3061. 			    }

    3062. 

  3062. 			

    3063. 

  3063. 			    public int I;

    3064. 

  3064. 			    public double D;

    3065. 

  3065. 			

    3066. 

  3066. 			    public override bool Equals(object o) {

    3067. 

  3067. 			        return (o is Sp) && Equals((Sp) o);

    3068. 

  3068. 			    }

    3069. 

  3069. 			    public bool Equals(Sp other) {

    3070. 

  3070. 			        return other.I == I && other.D == D;

    3071. 

  3071. 			    }

    3072. 

  3072. 			    public override int GetHashCode() {

    3073. 

  3073. 			        return I.GetHashCode() ^ D.GetHashCode();

    3074. 

  3074. 			    }

    3075. 

  3075. 			}

    3076. 

  3076. 			

    3077. 

  3077. 			public struct Ss : IEquatable<Ss> {

    3078. 

  3078. 			    public Ss(S s) {

    3079. 

  3079. 			        Val = s;

    3080. 

  3080. 			    }

    3081. 

  3081. 			

    3082. 

  3082. 			    public S Val;

    3083. 

  3083. 			

    3084. 

  3084. 			    public override bool Equals(object o) {

    3085. 

  3085. 			        return (o is Ss) && Equals((Ss) o);

    3086. 

  3086. 			    }

    3087. 

  3087. 			    public bool Equals(Ss other) {

    3088. 

  3088. 			        return other.Val.Equals(Val);

    3089. 

  3089. 			    }

    3090. 

  3090. 			    public override int GetHashCode() {

    3091. 

  3091. 			        return Val.GetHashCode();

    3092. 

  3092. 			    }

    3093. 

  3093. 			}

    3094. 

  3094. 			

    3095. 

  3095. 			public struct Sc : IEquatable<Sc> {

    3096. 

  3096. 			    public Sc(string s) {

    3097. 

  3097. 			        S = s;

    3098. 

  3098. 			    }

    3099. 

  3099. 			

    3100. 

  3100. 			    public string S;

    3101. 

  3101. 			

    3102. 

  3102. 			    public override bool Equals(object o) {

    3103. 

  3103. 			        return (o is Sc) && Equals((Sc) o);

    3104. 

  3104. 			    }

    3105. 

  3105. 			    public bool Equals(Sc other) {

    3106. 

  3106. 			        return other.S == S;

    3107. 

  3107. 			    }

    3108. 

  3108. 			    public override int GetHashCode() {

    3109. 

  3109. 			        return S.GetHashCode();

    3110. 

  3110. 			    }

    3111. 

  3111. 			}

    3112. 

  3112. 			

    3113. 

  3113. 			public struct Scs : IEquatable<Scs> {

    3114. 

  3114. 			    public Scs(string s, S val) {

    3115. 

  3115. 			        S = s;

    3116. 

  3116. 			        Val = val;

    3117. 

  3117. 			    }

    3118. 

  3118. 			

    3119. 

  3119. 			    public string S;

    3120. 

  3120. 			    public S Val;

    3121. 

  3121. 			

    3122. 

  3122. 			    public override bool Equals(object o) {

    3123. 

  3123. 			        return (o is Scs) && Equals((Scs) o);

    3124. 

  3124. 			    }

    3125. 

  3125. 			    public bool Equals(Scs other) {

    3126. 

  3126. 			        return other.S == S && other.Val.Equals(Val);

    3127. 

  3127. 			    }

    3128. 

  3128. 			    public override int GetHashCode() {

    3129. 

  3129. 			        return S.GetHashCode() ^ Val.GetHashCode();

    3130. 

  3130. 			    }

    3131. 

  3131. 			}

    3132. 

  3132. 			

    3133. 

  3133. 		

    3134. 

  3134. 	}

    3135. 

  3135. 				

    3136. 

  3136. 				//-------- Scenario 1727

    3137. 

  3137. 				namespace Scenario1727{

    3138. 

  3138. 					

    3139. 

  3139. 					public class Test

    3140. 

  3140. 					{

    3141. 

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

    3142. 

  3142. 				    public static Expression check19__() {

    3143. 

  3143. 				       if(Main() != 0 ) {

    3144. 

  3144. 				           throw new Exception();

    3145. 

  3145. 				       } else { 

    3146. 

  3146. 				           return Expression.Constant(0);

    3147. 

  3147. 				       }

    3148. 

  3148. 				    }

    3149. 

  3149. 					public     static int Main()

    3150. 

  3150. 					    {

    3151. 

  3151. 					        Ext.StartCapture();

    3152. 

  3152. 					        bool success = false;

    3153. 

  3153. 					        try

    3154. 

  3154. 					        {

    3155. 

  3155. 					            success = check19();

    3156. 

  3156. 					        }

    3157. 

  3157. 					        finally

    3158. 

  3158. 					        {

    3159. 

  3159. 					            Ext.StopCapture();

    3160. 

  3160. 					        }

    3161. 

  3161. 					        return success ? 0 : 1;

    3162. 

  3162. 					    }

    3163. 

  3163. 					

    3164. 

  3164. 					    static bool check19() {

    3165. 

  3165. 					        foreach (E val in new E[] { (E) 0, E.A, E.B, (E) int.MaxValue, (E) int.MinValue }) {

    3166. 

  3166. 					            if (!check19(val)) {

    3167. 

  3167. 					                return false;

    3168. 

  3168. 					            }

    3169. 

  3169. 					        }

    3170. 

  3170. 					        return true;

    3171. 

  3171. 					    }

    3172. 

  3172. 					

    3173. 

  3173. 					    static bool check19(E val) {

    3174. 

  3174. 					        Expression<Func<E>> e =

    3175. 

  3175. 					            Expression.Lambda<Func<E>>(

    3176. 

  3176. 					                Expression.Constant(val, typeof(E)),

    3177. 

  3177. 					                new System.Collections.Generic.List<ParameterExpression>());

    3178. 

  3178. 					        Func<E> f = e.Compile();

    3179. 

  3179. 					        return object.Equals(f(), val);

    3180. 

  3180. 					    }

    3181. 

  3181. 					}

    3182. 

  3182. 				

    3183. 

  3183. 				

    3184. 

  3184. 				public  static class Ext {

    3185. 

  3185. 				    public static void StartCapture() {

    3186. 

  3186. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3187. 

  3187. 				//        m.Invoke(null, new object[] { "test.dll" });

    3188. 

  3188. 				    }

    3189. 

  3189. 				

    3190. 

  3190. 				    public static void StopCapture() {

    3191. 

  3191. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3192. 

  3192. 				//        m.Invoke(null, new object[0]);

    3193. 

  3193. 				    }

    3194. 

  3194. 				

    3195. 

  3195. 				    public static bool IsIntegralOrEnum(Type type) {

    3196. 

  3196. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3197. 

  3197. 				            case TypeCode.Byte:

    3198. 

  3198. 				            case TypeCode.SByte:

    3199. 

  3199. 				            case TypeCode.Int16:

    3200. 

  3200. 				            case TypeCode.Int32:

    3201. 

  3201. 				            case TypeCode.Int64:

    3202. 

  3202. 				            case TypeCode.UInt16:

    3203. 

  3203. 				            case TypeCode.UInt32:

    3204. 

  3204. 				            case TypeCode.UInt64:

    3205. 

  3205. 				                return true;

    3206. 

  3206. 				            default:

    3207. 

  3207. 				                return false;

    3208. 

  3208. 				        }

    3209. 

  3209. 				    }

    3210. 

  3210. 				

    3211. 

  3211. 				    public static bool IsFloating(Type type) {

    3212. 

  3212. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3213. 

  3213. 				            case TypeCode.Single:

    3214. 

  3214. 				            case TypeCode.Double:

    3215. 

  3215. 				                return true;

    3216. 

  3216. 				            default:

    3217. 

  3217. 				                return false;

    3218. 

  3218. 				        }

    3219. 

  3219. 				    }

    3220. 

  3220. 				

    3221. 

  3221. 				    public static Type GetNonNullableType(Type type) {

    3222. 

  3222. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    3223. 

  3223. 				                type.GetGenericArguments()[0] :

    3224. 

  3224. 				                type;

    3225. 

  3225. 				    }

    3226. 

  3226. 				}

    3227. 

  3227. 				

    3228. 

  3228. 			

    3229. 

  3229. 			

    3230. 

  3230. 			

    3231. 

  3231. 			public interface I {

    3232. 

  3232. 			  void M();

    3233. 

  3233. 			}

    3234. 

  3234. 			

    3235. 

  3235. 			public  class C : IEquatable<C>, I {

    3236. 

  3236. 			    void I.M() {

    3237. 

  3237. 			    }

    3238. 

  3238. 			

    3239. 

  3239. 			    public override bool Equals(object o) {

    3240. 

  3240. 			        return o is C && Equals((C) o);

    3241. 

  3241. 			    }

    3242. 

  3242. 			

    3243. 

  3243. 			    public bool Equals(C c) {

    3244. 

  3244. 			        return c != null;

    3245. 

  3245. 			    }

    3246. 

  3246. 			

    3247. 

  3247. 			    public override int GetHashCode() {

    3248. 

  3248. 			        return 0;

    3249. 

  3249. 			    }

    3250. 

  3250. 			}

    3251. 

  3251. 			

    3252. 

  3252. 			public  class D : C, IEquatable<D> {

    3253. 

  3253. 			    public int Val;

    3254. 

  3254. 			    public D() {

    3255. 

  3255. 			    }

    3256. 

  3256. 			    public D(int val) {

    3257. 

  3257. 			        Val = val;

    3258. 

  3258. 			    }

    3259. 

  3259. 			

    3260. 

  3260. 			    public override bool Equals(object o) {

    3261. 

  3261. 			        return o is D && Equals((D) o);

    3262. 

  3262. 			    }

    3263. 

  3263. 			

    3264. 

  3264. 			    public bool Equals(D d) {

    3265. 

  3265. 			        return d != null && d.Val == Val;

    3266. 

  3266. 			    }

    3267. 

  3267. 			

    3268. 

  3268. 			    public override int GetHashCode() {

    3269. 

  3269. 			        return Val;

    3270. 

  3270. 			    }

    3271. 

  3271. 			}

    3272. 

  3272. 			

    3273. 

  3273. 			public enum E {

    3274. 

  3274. 			  A=1, B=2

    3275. 

  3275. 			}

    3276. 

  3276. 			

    3277. 

  3277. 			public enum El : long {

    3278. 

  3278. 			  A, B, C

    3279. 

  3279. 			}

    3280. 

  3280. 			

    3281. 

  3281. 			public struct S : IEquatable<S> {

    3282. 

  3282. 			    public override bool Equals(object o) {

    3283. 

  3283. 			        return (o is S) && Equals((S) o);

    3284. 

  3284. 			    }

    3285. 

  3285. 			    public bool Equals(S other) {

    3286. 

  3286. 			        return true;

    3287. 

  3287. 			    }

    3288. 

  3288. 			    public override int GetHashCode() {

    3289. 

  3289. 			        return 0;

    3290. 

  3290. 			    }

    3291. 

  3291. 			}

    3292. 

  3292. 			

    3293. 

  3293. 			public struct Sp : IEquatable<Sp> {

    3294. 

  3294. 			    public Sp(int i, double d) {

    3295. 

  3295. 			        I = i;

    3296. 

  3296. 			        D = d;

    3297. 

  3297. 			    }

    3298. 

  3298. 			

    3299. 

  3299. 			    public int I;

    3300. 

  3300. 			    public double D;

    3301. 

  3301. 			

    3302. 

  3302. 			    public override bool Equals(object o) {

    3303. 

  3303. 			        return (o is Sp) && Equals((Sp) o);

    3304. 

  3304. 			    }

    3305. 

  3305. 			    public bool Equals(Sp other) {

    3306. 

  3306. 			        return other.I == I && other.D == D;

    3307. 

  3307. 			    }

    3308. 

  3308. 			    public override int GetHashCode() {

    3309. 

  3309. 			        return I.GetHashCode() ^ D.GetHashCode();

    3310. 

  3310. 			    }

    3311. 

  3311. 			}

    3312. 

  3312. 			

    3313. 

  3313. 			public struct Ss : IEquatable<Ss> {

    3314. 

  3314. 			    public Ss(S s) {

    3315. 

  3315. 			        Val = s;

    3316. 

  3316. 			    }

    3317. 

  3317. 			

    3318. 

  3318. 			    public S Val;

    3319. 

  3319. 			

    3320. 

  3320. 			    public override bool Equals(object o) {

    3321. 

  3321. 			        return (o is Ss) && Equals((Ss) o);

    3322. 

  3322. 			    }

    3323. 

  3323. 			    public bool Equals(Ss other) {

    3324. 

  3324. 			        return other.Val.Equals(Val);

    3325. 

  3325. 			    }

    3326. 

  3326. 			    public override int GetHashCode() {

    3327. 

  3327. 			        return Val.GetHashCode();

    3328. 

  3328. 			    }

    3329. 

  3329. 			}

    3330. 

  3330. 			

    3331. 

  3331. 			public struct Sc : IEquatable<Sc> {

    3332. 

  3332. 			    public Sc(string s) {

    3333. 

  3333. 			        S = s;

    3334. 

  3334. 			    }

    3335. 

  3335. 			

    3336. 

  3336. 			    public string S;

    3337. 

  3337. 			

    3338. 

  3338. 			    public override bool Equals(object o) {

    3339. 

  3339. 			        return (o is Sc) && Equals((Sc) o);

    3340. 

  3340. 			    }

    3341. 

  3341. 			    public bool Equals(Sc other) {

    3342. 

  3342. 			        return other.S == S;

    3343. 

  3343. 			    }

    3344. 

  3344. 			    public override int GetHashCode() {

    3345. 

  3345. 			        return S.GetHashCode();

    3346. 

  3346. 			    }

    3347. 

  3347. 			}

    3348. 

  3348. 			

    3349. 

  3349. 			public struct Scs : IEquatable<Scs> {

    3350. 

  3350. 			    public Scs(string s, S val) {

    3351. 

  3351. 			        S = s;

    3352. 

  3352. 			        Val = val;

    3353. 

  3353. 			    }

    3354. 

  3354. 			

    3355. 

  3355. 			    public string S;

    3356. 

  3356. 			    public S Val;

    3357. 

  3357. 			

    3358. 

  3358. 			    public override bool Equals(object o) {

    3359. 

  3359. 			        return (o is Scs) && Equals((Scs) o);

    3360. 

  3360. 			    }

    3361. 

  3361. 			    public bool Equals(Scs other) {

    3362. 

  3362. 			        return other.S == S && other.Val.Equals(Val);

    3363. 

  3363. 			    }

    3364. 

  3364. 			    public override int GetHashCode() {

    3365. 

  3365. 			        return S.GetHashCode() ^ Val.GetHashCode();

    3366. 

  3366. 			    }

    3367. 

  3367. 			}

    3368. 

  3368. 			

    3369. 

  3369. 		

    3370. 

  3370. 	}

    3371. 

  3371. 				

    3372. 

  3372. 				//-------- Scenario 1728

    3373. 

  3373. 				namespace Scenario1728{

    3374. 

  3374. 					

    3375. 

  3375. 					public class Test

    3376. 

  3376. 					{

    3377. 

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

    3378. 

  3378. 				    public static Expression check20__() {

    3379. 

  3379. 				       if(Main() != 0 ) {

    3380. 

  3380. 				           throw new Exception();

    3381. 

  3381. 				       } else { 

    3382. 

  3382. 				           return Expression.Constant(0);

    3383. 

  3383. 				       }

    3384. 

  3384. 				    }

    3385. 

  3385. 					public     static int Main()

    3386. 

  3386. 					    {

    3387. 

  3387. 					        Ext.StartCapture();

    3388. 

  3388. 					        bool success = false;

    3389. 

  3389. 					        try

    3390. 

  3390. 					        {

    3391. 

  3391. 					            success = check20();

    3392. 

  3392. 					        }

    3393. 

  3393. 					        finally

    3394. 

  3394. 					        {

    3395. 

  3395. 					            Ext.StopCapture();

    3396. 

  3396. 					        }

    3397. 

  3397. 					        return success ? 0 : 1;

    3398. 

  3398. 					    }

    3399. 

  3399. 					

    3400. 

  3400. 					    static bool check20() {

    3401. 

  3401. 					        foreach (El val in new El[] { (El) 0, El.A, El.B, (El) long.MaxValue, (El) long.MinValue }) {

    3402. 

  3402. 					            if (!check20(val)) {

    3403. 

  3403. 					                return false;

    3404. 

  3404. 					            }

    3405. 

  3405. 					        }

    3406. 

  3406. 					        return true;

    3407. 

  3407. 					    }

    3408. 

  3408. 					

    3409. 

  3409. 					    static bool check20(El val) {

    3410. 

  3410. 					        Expression<Func<El>> e =

    3411. 

  3411. 					            Expression.Lambda<Func<El>>(

    3412. 

  3412. 					                Expression.Constant(val, typeof(El)),

    3413. 

  3413. 					                new System.Collections.Generic.List<ParameterExpression>());

    3414. 

  3414. 					        Func<El> f = e.Compile();

    3415. 

  3415. 					        return object.Equals(f(), val);

    3416. 

  3416. 					    }

    3417. 

  3417. 					}

    3418. 

  3418. 				

    3419. 

  3419. 				

    3420. 

  3420. 				public  static class Ext {

    3421. 

  3421. 				    public static void StartCapture() {

    3422. 

  3422. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3423. 

  3423. 				//        m.Invoke(null, new object[] { "test.dll" });

    3424. 

  3424. 				    }

    3425. 

  3425. 				

    3426. 

  3426. 				    public static void StopCapture() {

    3427. 

  3427. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3428. 

  3428. 				//        m.Invoke(null, new object[0]);

    3429. 

  3429. 				    }

    3430. 

  3430. 				

    3431. 

  3431. 				    public static bool IsIntegralOrEnum(Type type) {

    3432. 

  3432. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3433. 

  3433. 				            case TypeCode.Byte:

    3434. 

  3434. 				            case TypeCode.SByte:

    3435. 

  3435. 				            case TypeCode.Int16:

    3436. 

  3436. 				            case TypeCode.Int32:

    3437. 

  3437. 				            case TypeCode.Int64:

    3438. 

  3438. 				            case TypeCode.UInt16:

    3439. 

  3439. 				            case TypeCode.UInt32:

    3440. 

  3440. 				            case TypeCode.UInt64:

    3441. 

  3441. 				                return true;

    3442. 

  3442. 				            default:

    3443. 

  3443. 				                return false;

    3444. 

  3444. 				        }

    3445. 

  3445. 				    }

    3446. 

  3446. 				

    3447. 

  3447. 				    public static bool IsFloating(Type type) {

    3448. 

  3448. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3449. 

  3449. 				            case TypeCode.Single:

    3450. 

  3450. 				            case TypeCode.Double:

    3451. 

  3451. 				                return true;

    3452. 

  3452. 				            default:

    3453. 

  3453. 				                return false;

    3454. 

  3454. 				        }

    3455. 

  3455. 				    }

    3456. 

  3456. 				

    3457. 

  3457. 				    public static Type GetNonNullableType(Type type) {

    3458. 

  3458. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    3459. 

  3459. 				                type.GetGenericArguments()[0] :

    3460. 

  3460. 				                type;

    3461. 

  3461. 				    }

    3462. 

  3462. 				}

    3463. 

  3463. 				

    3464. 

  3464. 			

    3465. 

  3465. 			

    3466. 

  3466. 			

    3467. 

  3467. 			public interface I {

    3468. 

  3468. 			  void M();

    3469. 

  3469. 			}

    3470. 

  3470. 			

    3471. 

  3471. 			public  class C : IEquatable<C>, I {

    3472. 

  3472. 			    void I.M() {

    3473. 

  3473. 			    }

    3474. 

  3474. 			

    3475. 

  3475. 			    public override bool Equals(object o) {

    3476. 

  3476. 			        return o is C && Equals((C) o);

    3477. 

  3477. 			    }

    3478. 

  3478. 			

    3479. 

  3479. 			    public bool Equals(C c) {

    3480. 

  3480. 			        return c != null;

    3481. 

  3481. 			    }

    3482. 

  3482. 			

    3483. 

  3483. 			    public override int GetHashCode() {

    3484. 

  3484. 			        return 0;

    3485. 

  3485. 			    }

    3486. 

  3486. 			}

    3487. 

  3487. 			

    3488. 

  3488. 			public  class D : C, IEquatable<D> {

    3489. 

  3489. 			    public int Val;

    3490. 

  3490. 			    public D() {

    3491. 

  3491. 			    }

    3492. 

  3492. 			    public D(int val) {

    3493. 

  3493. 			        Val = val;

    3494. 

  3494. 			    }

    3495. 

  3495. 			

    3496. 

  3496. 			    public override bool Equals(object o) {

    3497. 

  3497. 			        return o is D && Equals((D) o);

    3498. 

  3498. 			    }

    3499. 

  3499. 			

    3500. 

  3500. 			    public bool Equals(D d) {

    3501. 

  3501. 			        return d != null && d.Val == Val;

    3502. 

  3502. 			    }

    3503. 

  3503. 			

    3504. 

  3504. 			    public override int GetHashCode() {

    3505. 

  3505. 			        return Val;

    3506. 

  3506. 			    }

    3507. 

  3507. 			}

    3508. 

  3508. 			

    3509. 

  3509. 			public enum E {

    3510. 

  3510. 			  A=1, B=2

    3511. 

  3511. 			}

    3512. 

  3512. 			

    3513. 

  3513. 			public enum El : long {

    3514. 

  3514. 			  A, B, C

    3515. 

  3515. 			}

    3516. 

  3516. 			

    3517. 

  3517. 			public struct S : IEquatable<S> {

    3518. 

  3518. 			    public override bool Equals(object o) {

    3519. 

  3519. 			        return (o is S) && Equals((S) o);

    3520. 

  3520. 			    }

    3521. 

  3521. 			    public bool Equals(S other) {

    3522. 

  3522. 			        return true;

    3523. 

  3523. 			    }

    3524. 

  3524. 			    public override int GetHashCode() {

    3525. 

  3525. 			        return 0;

    3526. 

  3526. 			    }

    3527. 

  3527. 			}

    3528. 

  3528. 			

    3529. 

  3529. 			public struct Sp : IEquatable<Sp> {

    3530. 

  3530. 			    public Sp(int i, double d) {

    3531. 

  3531. 			        I = i;

    3532. 

  3532. 			        D = d;

    3533. 

  3533. 			    }

    3534. 

  3534. 			

    3535. 

  3535. 			    public int I;

    3536. 

  3536. 			    public double D;

    3537. 

  3537. 			

    3538. 

  3538. 			    public override bool Equals(object o) {

    3539. 

  3539. 			        return (o is Sp) && Equals((Sp) o);

    3540. 

  3540. 			    }

    3541. 

  3541. 			    public bool Equals(Sp other) {

    3542. 

  3542. 			        return other.I == I && other.D == D;

    3543. 

  3543. 			    }

    3544. 

  3544. 			    public override int GetHashCode() {

    3545. 

  3545. 			        return I.GetHashCode() ^ D.GetHashCode();

    3546. 

  3546. 			    }

    3547. 

  3547. 			}

    3548. 

  3548. 			

    3549. 

  3549. 			public struct Ss : IEquatable<Ss> {

    3550. 

  3550. 			    public Ss(S s) {

    3551. 

  3551. 			        Val = s;

    3552. 

  3552. 			    }

    3553. 

  3553. 			

    3554. 

  3554. 			    public S Val;

    3555. 

  3555. 			

    3556. 

  3556. 			    public override bool Equals(object o) {

    3557. 

  3557. 			        return (o is Ss) && Equals((Ss) o);

    3558. 

  3558. 			    }

    3559. 

  3559. 			    public bool Equals(Ss other) {

    3560. 

  3560. 			        return other.Val.Equals(Val);

    3561. 

  3561. 			    }

    3562. 

  3562. 			    public override int GetHashCode() {

    3563. 

  3563. 			        return Val.GetHashCode();

    3564. 

  3564. 			    }

    3565. 

  3565. 			}

    3566. 

  3566. 			

    3567. 

  3567. 			public struct Sc : IEquatable<Sc> {

    3568. 

  3568. 			    public Sc(string s) {

    3569. 

  3569. 			        S = s;

    3570. 

  3570. 			    }

    3571. 

  3571. 			

    3572. 

  3572. 			    public string S;

    3573. 

  3573. 			

    3574. 

  3574. 			    public override bool Equals(object o) {

    3575. 

  3575. 			        return (o is Sc) && Equals((Sc) o);

    3576. 

  3576. 			    }

    3577. 

  3577. 			    public bool Equals(Sc other) {

    3578. 

  3578. 			        return other.S == S;

    3579. 

  3579. 			    }

    3580. 

  3580. 			    public override int GetHashCode() {

    3581. 

  3581. 			        return S.GetHashCode();

    3582. 

  3582. 			    }

    3583. 

  3583. 			}

    3584. 

  3584. 			

    3585. 

  3585. 			public struct Scs : IEquatable<Scs> {

    3586. 

  3586. 			    public Scs(string s, S val) {

    3587. 

  3587. 			        S = s;

    3588. 

  3588. 			        Val = val;

    3589. 

  3589. 			    }

    3590. 

  3590. 			

    3591. 

  3591. 			    public string S;

    3592. 

  3592. 			    public S Val;

    3593. 

  3593. 			

    3594. 

  3594. 			    public override bool Equals(object o) {

    3595. 

  3595. 			        return (o is Scs) && Equals((Scs) o);

    3596. 

  3596. 			    }

    3597. 

  3597. 			    public bool Equals(Scs other) {

    3598. 

  3598. 			        return other.S == S && other.Val.Equals(Val);

    3599. 

  3599. 			    }

    3600. 

  3600. 			    public override int GetHashCode() {

    3601. 

  3601. 			        return S.GetHashCode() ^ Val.GetHashCode();

    3602. 

  3602. 			    }

    3603. 

  3603. 			}

    3604. 

  3604. 			

    3605. 

  3605. 		

    3606. 

  3606. 	}

    3607. 

  3607. 			

    3608. 

  3608. 			//-------- Scenario 1729

    3609. 

  3609. 			namespace Scenario1729{

    3610. 

  3610. 				

    3611. 

  3611. 				public class Test

    3612. 

  3612. 				{

    3613. 

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

    3614. 

  3614. 			    public static Expression check21__() {

    3615. 

  3615. 			       if(Main() != 0 ) {

    3616. 

  3616. 			           throw new Exception();

    3617. 

  3617. 			       } else { 

    3618. 

  3618. 			           return Expression.Constant(0);

    3619. 

  3619. 			       }

    3620. 

  3620. 			    }

    3621. 

  3621. 				public     static int Main()

    3622. 

  3622. 				    {

    3623. 

  3623. 				        Ext.StartCapture();

    3624. 

  3624. 				        bool success = false;

    3625. 

  3625. 				        try

    3626. 

  3626. 				        {

    3627. 

  3627. 				            success = check21();

    3628. 

  3628. 				        }

    3629. 

  3629. 				        finally

    3630. 

  3630. 				        {

    3631. 

  3631. 				            Ext.StopCapture();

    3632. 

  3632. 				        }

    3633. 

  3633. 				        return success ? 0 : 1;

    3634. 

  3634. 				    }

    3635. 

  3635. 				

    3636. 

  3636. 				    static bool check21() {

    3637. 

  3637. 				        foreach (string val in new string[] { null, "", "a", "foo" }) {

    3638. 

  3638. 				            if (!check21(val)) {

    3639. 

  3639. 				                return false;

    3640. 

  3640. 				            }

    3641. 

  3641. 				        }

    3642. 

  3642. 				        return true;

    3643. 

  3643. 				    }

    3644. 

  3644. 				

    3645. 

  3645. 				    static bool check21(string val) {

    3646. 

  3646. 				        Expression<Func<string>> e =

    3647. 

  3647. 				            Expression.Lambda<Func<string>>(

    3648. 

  3648. 				                Expression.Constant(val, typeof(string)),

    3649. 

  3649. 				                new System.Collections.Generic.List<ParameterExpression>());

    3650. 

  3650. 				        Func<string> f = e.Compile();

    3651. 

  3651. 				        return object.Equals(f(), val);

    3652. 

  3652. 				    }

    3653. 

  3653. 				}

    3654. 

  3654. 			

    3655. 

  3655. 			

    3656. 

  3656. 			public  static class Ext {

    3657. 

  3657. 			    public static void StartCapture() {

    3658. 

  3658. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3659. 

  3659. 			//        m.Invoke(null, new object[] { "test.dll" });

    3660. 

  3660. 			    }

    3661. 

  3661. 			

    3662. 

  3662. 			    public static void StopCapture() {

    3663. 

  3663. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3664. 

  3664. 			//        m.Invoke(null, new object[0]);

    3665. 

  3665. 			    }

    3666. 

  3666. 			

    3667. 

  3667. 			    public static bool IsIntegralOrEnum(Type type) {

    3668. 

  3668. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3669. 

  3669. 			            case TypeCode.Byte:

    3670. 

  3670. 			            case TypeCode.SByte:

    3671. 

  3671. 			            case TypeCode.Int16:

    3672. 

  3672. 			            case TypeCode.Int32:

    3673. 

  3673. 			            case TypeCode.Int64:

    3674. 

  3674. 			            case TypeCode.UInt16:

    3675. 

  3675. 			            case TypeCode.UInt32:

    3676. 

  3676. 			            case TypeCode.UInt64:

    3677. 

  3677. 			                return true;

    3678. 

  3678. 			            default:

    3679. 

  3679. 			                return false;

    3680. 

  3680. 			        }

    3681. 

  3681. 			    }

    3682. 

  3682. 			

    3683. 

  3683. 			    public static bool IsFloating(Type type) {

    3684. 

  3684. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3685. 

  3685. 			            case TypeCode.Single:

    3686. 

  3686. 			            case TypeCode.Double:

    3687. 

  3687. 			                return true;

    3688. 

  3688. 			            default:

    3689. 

  3689. 			                return false;

    3690. 

  3690. 			        }

    3691. 

  3691. 			    }

    3692. 

  3692. 			

    3693. 

  3693. 			    public static Type GetNonNullableType(Type type) {

    3694. 

  3694. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    3695. 

  3695. 			                type.GetGenericArguments()[0] :

    3696. 

  3696. 			                type;

    3697. 

  3697. 			    }

    3698. 

  3698. 			}

    3699. 

  3699. 			

    3700. 

  3700. 		

    3701. 

  3701. 	}

    3702. 

  3702. 				

    3703. 

  3703. 				//-------- Scenario 1730

    3704. 

  3704. 				namespace Scenario1730{

    3705. 

  3705. 					

    3706. 

  3706. 					public class Test

    3707. 

  3707. 					{

    3708. 

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

    3709. 

  3709. 				    public static Expression check22__() {

    3710. 

  3710. 				       if(Main() != 0 ) {

    3711. 

  3711. 				           throw new Exception();

    3712. 

  3712. 				       } else { 

    3713. 

  3713. 				           return Expression.Constant(0);

    3714. 

  3714. 				       }

    3715. 

  3715. 				    }

    3716. 

  3716. 					public     static int Main()

    3717. 

  3717. 					    {

    3718. 

  3718. 					        Ext.StartCapture();

    3719. 

  3719. 					        bool success = false;

    3720. 

  3720. 					        try

    3721. 

  3721. 					        {

    3722. 

  3722. 					            success = check22();

    3723. 

  3723. 					        }

    3724. 

  3724. 					        finally

    3725. 

  3725. 					        {

    3726. 

  3726. 					            Ext.StopCapture();

    3727. 

  3727. 					        }

    3728. 

  3728. 					        return success ? 0 : 1;

    3729. 

  3729. 					    }

    3730. 

  3730. 					

    3731. 

  3731. 					    static bool check22() {

    3732. 

  3732. 					        foreach (object val in new object[] { null, new object(), new C(), new D(3) }) {

    3733. 

  3733. 					            if (!check22(val)) {

    3734. 

  3734. 					                return false;

    3735. 

  3735. 					            }

    3736. 

  3736. 					        }

    3737. 

  3737. 					        return true;

    3738. 

  3738. 					    }

    3739. 

  3739. 					

    3740. 

  3740. 					    static bool check22(object val) {

    3741. 

  3741. 					        Expression<Func<object>> e =

    3742. 

  3742. 					            Expression.Lambda<Func<object>>(

    3743. 

  3743. 					                Expression.Constant(val, typeof(object)),

    3744. 

  3744. 					                new System.Collections.Generic.List<ParameterExpression>());

    3745. 

  3745. 					        Func<object> f = e.Compile();

    3746. 

  3746. 					        return object.Equals(f(), val);

    3747. 

  3747. 					    }

    3748. 

  3748. 					}

    3749. 

  3749. 				

    3750. 

  3750. 				

    3751. 

  3751. 				public  static class Ext {

    3752. 

  3752. 				    public static void StartCapture() {

    3753. 

  3753. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3754. 

  3754. 				//        m.Invoke(null, new object[] { "test.dll" });

    3755. 

  3755. 				    }

    3756. 

  3756. 				

    3757. 

  3757. 				    public static void StopCapture() {

    3758. 

  3758. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3759. 

  3759. 				//        m.Invoke(null, new object[0]);

    3760. 

  3760. 				    }

    3761. 

  3761. 				

    3762. 

  3762. 				    public static bool IsIntegralOrEnum(Type type) {

    3763. 

  3763. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3764. 

  3764. 				            case TypeCode.Byte:

    3765. 

  3765. 				            case TypeCode.SByte:

    3766. 

  3766. 				            case TypeCode.Int16:

    3767. 

  3767. 				            case TypeCode.Int32:

    3768. 

  3768. 				            case TypeCode.Int64:

    3769. 

  3769. 				            case TypeCode.UInt16:

    3770. 

  3770. 				            case TypeCode.UInt32:

    3771. 

  3771. 				            case TypeCode.UInt64:

    3772. 

  3772. 				                return true;

    3773. 

  3773. 				            default:

    3774. 

  3774. 				                return false;

    3775. 

  3775. 				        }

    3776. 

  3776. 				    }

    3777. 

  3777. 				

    3778. 

  3778. 				    public static bool IsFloating(Type type) {

    3779. 

  3779. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    3780. 

  3780. 				            case TypeCode.Single:

    3781. 

  3781. 				            case TypeCode.Double:

    3782. 

  3782. 				                return true;

    3783. 

  3783. 				            default:

    3784. 

  3784. 				                return false;

    3785. 

  3785. 				        }

    3786. 

  3786. 				    }

    3787. 

  3787. 				

    3788. 

  3788. 				    public static Type GetNonNullableType(Type type) {

    3789. 

  3789. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    3790. 

  3790. 				                type.GetGenericArguments()[0] :

    3791. 

  3791. 				                type;

    3792. 

  3792. 				    }

    3793. 

  3793. 				}

    3794. 

  3794. 				

    3795. 

  3795. 			

    3796. 

  3796. 			

    3797. 

  3797. 			

    3798. 

  3798. 			public interface I {

    3799. 

  3799. 			  void M();

    3800. 

  3800. 			}

    3801. 

  3801. 			

    3802. 

  3802. 			public  class C : IEquatable<C>, I {

    3803. 

  3803. 			    void I.M() {

    3804. 

  3804. 			    }

    3805. 

  3805. 			

    3806. 

  3806. 			    public override bool Equals(object o) {

    3807. 

  3807. 			        return o is C && Equals((C) o);

    3808. 

  3808. 			    }

    3809. 

  3809. 			

    3810. 

  3810. 			    public bool Equals(C c) {

    3811. 

  3811. 			        return c != null;

    3812. 

  3812. 			    }

    3813. 

  3813. 			

    3814. 

  3814. 			    public override int GetHashCode() {

    3815. 

  3815. 			        return 0;

    3816. 

  3816. 			    }

    3817. 

  3817. 			}

    3818. 

  3818. 			

    3819. 

  3819. 			public  class D : C, IEquatable<D> {

    3820. 

  3820. 			    public int Val;

    3821. 

  3821. 			    public D() {

    3822. 

  3822. 			    }

    3823. 

  3823. 			    public D(int val) {

    3824. 

  3824. 			        Val = val;

    3825. 

  3825. 			    }

    3826. 

  3826. 			

    3827. 

  3827. 			    public override bool Equals(object o) {

    3828. 

  3828. 			        return o is D && Equals((D) o);

    3829. 

  3829. 			    }

    3830. 

  3830. 			

    3831. 

  3831. 			    public bool Equals(D d) {

    3832. 

  3832. 			        return d != null && d.Val == Val;

    3833. 

  3833. 			    }

    3834. 

  3834. 			

    3835. 

  3835. 			    public override int GetHashCode() {

    3836. 

  3836. 			        return Val;

    3837. 

  3837. 			    }

    3838. 

  3838. 			}

    3839. 

  3839. 			

    3840. 

  3840. 			public enum E {

    3841. 

  3841. 			  A=1, B=2

    3842. 

  3842. 			}

    3843. 

  3843. 			

    3844. 

  3844. 			public enum El : long {

    3845. 

  3845. 			  A, B, C

    3846. 

  3846. 			}

    3847. 

  3847. 			

    3848. 

  3848. 			public struct S : IEquatable<S> {

    3849. 

  3849. 			    public override bool Equals(object o) {

    3850. 

  3850. 			        return (o is S) && Equals((S) o);

    3851. 

  3851. 			    }

    3852. 

  3852. 			    public bool Equals(S other) {

    3853. 

  3853. 			        return true;

    3854. 

  3854. 			    }

    3855. 

  3855. 			    public override int GetHashCode() {

    3856. 

  3856. 			        return 0;

    3857. 

  3857. 			    }

    3858. 

  3858. 			}

    3859. 

  3859. 			

    3860. 

  3860. 			public struct Sp : IEquatable<Sp> {

    3861. 

  3861. 			    public Sp(int i, double d) {

    3862. 

  3862. 			        I = i;

    3863. 

  3863. 			        D = d;

    3864. 

  3864. 			    }

    3865. 

  3865. 			

    3866. 

  3866. 			    public int I;

    3867. 

  3867. 			    public double D;

    3868. 

  3868. 			

    3869. 

  3869. 			    public override bool Equals(object o) {

    3870. 

  3870. 			        return (o is Sp) && Equals((Sp) o);

    3871. 

  3871. 			    }

    3872. 

  3872. 			    public bool Equals(Sp other) {

    3873. 

  3873. 			        return other.I == I && other.D == D;

    3874. 

  3874. 			    }

    3875. 

  3875. 			    public override int GetHashCode() {

    3876. 

  3876. 			        return I.GetHashCode() ^ D.GetHashCode();

    3877. 

  3877. 			    }

    3878. 

  3878. 			}

    3879. 

  3879. 			

    3880. 

  3880. 			public struct Ss : IEquatable<Ss> {

    3881. 

  3881. 			    public Ss(S s) {

    3882. 

  3882. 			        Val = s;

    3883. 

  3883. 			    }

    3884. 

  3884. 			

    3885. 

  3885. 			    public S Val;

    3886. 

  3886. 			

    3887. 

  3887. 			    public override bool Equals(object o) {

    3888. 

  3888. 			        return (o is Ss) && Equals((Ss) o);

    3889. 

  3889. 			    }

    3890. 

  3890. 			    public bool Equals(Ss other) {

    3891. 

  3891. 			        return other.Val.Equals(Val);

    3892. 

  3892. 			    }

    3893. 

  3893. 			    public override int GetHashCode() {

    3894. 

  3894. 			        return Val.GetHashCode();

    3895. 

  3895. 			    }

    3896. 

  3896. 			}

    3897. 

  3897. 			

    3898. 

  3898. 			public struct Sc : IEquatable<Sc> {

    3899. 

  3899. 			    public Sc(string s) {

    3900. 

  3900. 			        S = s;

    3901. 

  3901. 			    }

    3902. 

  3902. 			

    3903. 

  3903. 			    public string S;

    3904. 

  3904. 			

    3905. 

  3905. 			    public override bool Equals(object o) {

    3906. 

  3906. 			        return (o is Sc) && Equals((Sc) o);

    3907. 

  3907. 			    }

    3908. 

  3908. 			    public bool Equals(Sc other) {

    3909. 

  3909. 			        return other.S == S;

    3910. 

  3910. 			    }

    3911. 

  3911. 			    public override int GetHashCode() {

    3912. 

  3912. 			        return S.GetHashCode();

    3913. 

  3913. 			    }

    3914. 

  3914. 			}

    3915. 

  3915. 			

    3916. 

  3916. 			public struct Scs : IEquatable<Scs> {

    3917. 

  3917. 			    public Scs(string s, S val) {

    3918. 

  3918. 			        S = s;

    3919. 

  3919. 			        Val = val;

    3920. 

  3920. 			    }

    3921. 

  3921. 			

    3922. 

  3922. 			    public string S;

    3923. 

  3923. 			    public S Val;

    3924. 

  3924. 			

    3925. 

  3925. 			    public override bool Equals(object o) {

    3926. 

  3926. 			        return (o is Scs) && Equals((Scs) o);

    3927. 

  3927. 			    }

    3928. 

  3928. 			    public bool Equals(Scs other) {

    3929. 

  3929. 			        return other.S == S && other.Val.Equals(Val);

    3930. 

  3930. 			    }

    3931. 

  3931. 			    public override int GetHashCode() {

    3932. 

  3932. 			        return S.GetHashCode() ^ Val.GetHashCode();

    3933. 

  3933. 			    }

    3934. 

  3934. 			}

    3935. 

  3935. 			

    3936. 

  3936. 		

    3937. 

  3937. 	}

    3938. 

  3938. 				

    3939. 

  3939. 				//-------- Scenario 1731

    3940. 

  3940. 				namespace Scenario1731{

    3941. 

  3941. 					

    3942. 

  3942. 					public class Test

    3943. 

  3943. 					{

    3944. 

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

    3945. 

  3945. 				    public static Expression check23__() {

    3946. 

  3946. 				       if(Main() != 0 ) {

    3947. 

  3947. 				           throw new Exception();

    3948. 

  3948. 				       } else { 

    3949. 

  3949. 				           return Expression.Constant(0);

    3950. 

  3950. 				       }

    3951. 

  3951. 				    }

    3952. 

  3952. 					public     static int Main()

    3953. 

  3953. 					    {

    3954. 

  3954. 					        Ext.StartCapture();

    3955. 

  3955. 					        bool success = false;

    3956. 

  3956. 					        try

    3957. 

  3957. 					        {

    3958. 

  3958. 					            success = check23();

    3959. 

  3959. 					        }

    3960. 

  3960. 					        finally

    3961. 

  3961. 					        {

    3962. 

  3962. 					            Ext.StopCapture();

    3963. 

  3963. 					        }

    3964. 

  3964. 					        return success ? 0 : 1;

    3965. 

  3965. 					    }

    3966. 

  3966. 					

    3967. 

  3967. 					    static bool check23() {

    3968. 

  3968. 					        foreach (C val in new C[] { null, new C(), new D(), new D(0), new D(5) }) {

    3969. 

  3969. 					            if (!check23(val)) {

    3970. 

  3970. 					                return false;

    3971. 

  3971. 					            }

    3972. 

  3972. 					        }

    3973. 

  3973. 					        return true;

    3974. 

  3974. 					    }

    3975. 

  3975. 					

    3976. 

  3976. 					    static bool check23(C val) {

    3977. 

  3977. 					        Expression<Func<C>> e =

    3978. 

  3978. 					            Expression.Lambda<Func<C>>(

    3979. 

  3979. 					                Expression.Constant(val, typeof(C)),

    3980. 

  3980. 					                new System.Collections.Generic.List<ParameterExpression>());

    3981. 

  3981. 					        Func<C> f = e.Compile();

    3982. 

  3982. 					        return object.Equals(f(), val);

    3983. 

  3983. 					    }

    3984. 

  3984. 					}

    3985. 

  3985. 				

    3986. 

  3986. 				

    3987. 

  3987. 				public  static class Ext {

    3988. 

  3988. 				    public static void StartCapture() {

    3989. 

  3989. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3990. 

  3990. 				//        m.Invoke(null, new object[] { "test.dll" });

    3991. 

  3991. 				    }

    3992. 

  3992. 				

    3993. 

  3993. 				    public static void StopCapture() {

    3994. 

  3994. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    3995. 

  3995. 				//        m.Invoke(null, new object[0]);

    3996. 

  3996. 				    }

    3997. 

  3997. 				

    3998. 

  3998. 				    public static bool IsIntegralOrEnum(Type type) {

    3999. 

  3999. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4000. 

  4000. 				            case TypeCode.Byte:

    4001. 

  4001. 				            case TypeCode.SByte:

    4002. 

  4002. 				            case TypeCode.Int16:

    4003. 

  4003. 				            case TypeCode.Int32:

    4004. 

  4004. 				            case TypeCode.Int64:

    4005. 

  4005. 				            case TypeCode.UInt16:

    4006. 

  4006. 				            case TypeCode.UInt32:

    4007. 

  4007. 				            case TypeCode.UInt64:

    4008. 

  4008. 				                return true;

    4009. 

  4009. 				            default:

    4010. 

  4010. 				                return false;

    4011. 

  4011. 				        }

    4012. 

  4012. 				    }

    4013. 

  4013. 				

    4014. 

  4014. 				    public static bool IsFloating(Type type) {

    4015. 

  4015. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4016. 

  4016. 				            case TypeCode.Single:

    4017. 

  4017. 				            case TypeCode.Double:

    4018. 

  4018. 				                return true;

    4019. 

  4019. 				            default:

    4020. 

  4020. 				                return false;

    4021. 

  4021. 				        }

    4022. 

  4022. 				    }

    4023. 

  4023. 				

    4024. 

  4024. 				    public static Type GetNonNullableType(Type type) {

    4025. 

  4025. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    4026. 

  4026. 				                type.GetGenericArguments()[0] :

    4027. 

  4027. 				                type;

    4028. 

  4028. 				    }

    4029. 

  4029. 				}

    4030. 

  4030. 				

    4031. 

  4031. 			

    4032. 

  4032. 			

    4033. 

  4033. 			

    4034. 

  4034. 			public interface I {

    4035. 

  4035. 			  void M();

    4036. 

  4036. 			}

    4037. 

  4037. 			

    4038. 

  4038. 			public  class C : IEquatable<C>, I {

    4039. 

  4039. 			    void I.M() {

    4040. 

  4040. 			    }

    4041. 

  4041. 			

    4042. 

  4042. 			    public override bool Equals(object o) {

    4043. 

  4043. 			        return o is C && Equals((C) o);

    4044. 

  4044. 			    }

    4045. 

  4045. 			

    4046. 

  4046. 			    public bool Equals(C c) {

    4047. 

  4047. 			        return c != null;

    4048. 

  4048. 			    }

    4049. 

  4049. 			

    4050. 

  4050. 			    public override int GetHashCode() {

    4051. 

  4051. 			        return 0;

    4052. 

  4052. 			    }

    4053. 

  4053. 			}

    4054. 

  4054. 			

    4055. 

  4055. 			public  class D : C, IEquatable<D> {

    4056. 

  4056. 			    public int Val;

    4057. 

  4057. 			    public D() {

    4058. 

  4058. 			    }

    4059. 

  4059. 			    public D(int val) {

    4060. 

  4060. 			        Val = val;

    4061. 

  4061. 			    }

    4062. 

  4062. 			

    4063. 

  4063. 			    public override bool Equals(object o) {

    4064. 

  4064. 			        return o is D && Equals((D) o);

    4065. 

  4065. 			    }

    4066. 

  4066. 			

    4067. 

  4067. 			    public bool Equals(D d) {

    4068. 

  4068. 			        return d != null && d.Val == Val;

    4069. 

  4069. 			    }

    4070. 

  4070. 			

    4071. 

  4071. 			    public override int GetHashCode() {

    4072. 

  4072. 			        return Val;

    4073. 

  4073. 			    }

    4074. 

  4074. 			}

    4075. 

  4075. 			

    4076. 

  4076. 			public enum E {

    4077. 

  4077. 			  A=1, B=2

    4078. 

  4078. 			}

    4079. 

  4079. 			

    4080. 

  4080. 			public enum El : long {

    4081. 

  4081. 			  A, B, C

    4082. 

  4082. 			}

    4083. 

  4083. 			

    4084. 

  4084. 			public struct S : IEquatable<S> {

    4085. 

  4085. 			    public override bool Equals(object o) {

    4086. 

  4086. 			        return (o is S) && Equals((S) o);

    4087. 

  4087. 			    }

    4088. 

  4088. 			    public bool Equals(S other) {

    4089. 

  4089. 			        return true;

    4090. 

  4090. 			    }

    4091. 

  4091. 			    public override int GetHashCode() {

    4092. 

  4092. 			        return 0;

    4093. 

  4093. 			    }

    4094. 

  4094. 			}

    4095. 

  4095. 			

    4096. 

  4096. 			public struct Sp : IEquatable<Sp> {

    4097. 

  4097. 			    public Sp(int i, double d) {

    4098. 

  4098. 			        I = i;

    4099. 

  4099. 			        D = d;

    4100. 

  4100. 			    }

    4101. 

  4101. 			

    4102. 

  4102. 			    public int I;

    4103. 

  4103. 			    public double D;

    4104. 

  4104. 			

    4105. 

  4105. 			    public override bool Equals(object o) {

    4106. 

  4106. 			        return (o is Sp) && Equals((Sp) o);

    4107. 

  4107. 			    }

    4108. 

  4108. 			    public bool Equals(Sp other) {

    4109. 

  4109. 			        return other.I == I && other.D == D;

    4110. 

  4110. 			    }

    4111. 

  4111. 			    public override int GetHashCode() {

    4112. 

  4112. 			        return I.GetHashCode() ^ D.GetHashCode();

    4113. 

  4113. 			    }

    4114. 

  4114. 			}

    4115. 

  4115. 			

    4116. 

  4116. 			public struct Ss : IEquatable<Ss> {

    4117. 

  4117. 			    public Ss(S s) {

    4118. 

  4118. 			        Val = s;

    4119. 

  4119. 			    }

    4120. 

  4120. 			

    4121. 

  4121. 			    public S Val;

    4122. 

  4122. 			

    4123. 

  4123. 			    public override bool Equals(object o) {

    4124. 

  4124. 			        return (o is Ss) && Equals((Ss) o);

    4125. 

  4125. 			    }

    4126. 

  4126. 			    public bool Equals(Ss other) {

    4127. 

  4127. 			        return other.Val.Equals(Val);

    4128. 

  4128. 			    }

    4129. 

  4129. 			    public override int GetHashCode() {

    4130. 

  4130. 			        return Val.GetHashCode();

    4131. 

  4131. 			    }

    4132. 

  4132. 			}

    4133. 

  4133. 			

    4134. 

  4134. 			public struct Sc : IEquatable<Sc> {

    4135. 

  4135. 			    public Sc(string s) {

    4136. 

  4136. 			        S = s;

    4137. 

  4137. 			    }

    4138. 

  4138. 			

    4139. 

  4139. 			    public string S;

    4140. 

  4140. 			

    4141. 

  4141. 			    public override bool Equals(object o) {

    4142. 

  4142. 			        return (o is Sc) && Equals((Sc) o);

    4143. 

  4143. 			    }

    4144. 

  4144. 			    public bool Equals(Sc other) {

    4145. 

  4145. 			        return other.S == S;

    4146. 

  4146. 			    }

    4147. 

  4147. 			    public override int GetHashCode() {

    4148. 

  4148. 			        return S.GetHashCode();

    4149. 

  4149. 			    }

    4150. 

  4150. 			}

    4151. 

  4151. 			

    4152. 

  4152. 			public struct Scs : IEquatable<Scs> {

    4153. 

  4153. 			    public Scs(string s, S val) {

    4154. 

  4154. 			        S = s;

    4155. 

  4155. 			        Val = val;

    4156. 

  4156. 			    }

    4157. 

  4157. 			

    4158. 

  4158. 			    public string S;

    4159. 

  4159. 			    public S Val;

    4160. 

  4160. 			

    4161. 

  4161. 			    public override bool Equals(object o) {

    4162. 

  4162. 			        return (o is Scs) && Equals((Scs) o);

    4163. 

  4163. 			    }

    4164. 

  4164. 			    public bool Equals(Scs other) {

    4165. 

  4165. 			        return other.S == S && other.Val.Equals(Val);

    4166. 

  4166. 			    }

    4167. 

  4167. 			    public override int GetHashCode() {

    4168. 

  4168. 			        return S.GetHashCode() ^ Val.GetHashCode();

    4169. 

  4169. 			    }

    4170. 

  4170. 			}

    4171. 

  4171. 			

    4172. 

  4172. 		

    4173. 

  4173. 	}

    4174. 

  4174. 				

    4175. 

  4175. 				//-------- Scenario 1732

    4176. 

  4176. 				namespace Scenario1732{

    4177. 

  4177. 					

    4178. 

  4178. 					public class Test

    4179. 

  4179. 					{

    4180. 

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

    4181. 

  4181. 				    public static Expression check24__() {

    4182. 

  4182. 				       if(Main() != 0 ) {

    4183. 

  4183. 				           throw new Exception();

    4184. 

  4184. 				       } else { 

    4185. 

  4185. 				           return Expression.Constant(0);

    4186. 

  4186. 				       }

    4187. 

  4187. 				    }

    4188. 

  4188. 					public     static int Main()

    4189. 

  4189. 					    {

    4190. 

  4190. 					        Ext.StartCapture();

    4191. 

  4191. 					        bool success = false;

    4192. 

  4192. 					        try

    4193. 

  4193. 					        {

    4194. 

  4194. 					            success = check24();

    4195. 

  4195. 					        }

    4196. 

  4196. 					        finally

    4197. 

  4197. 					        {

    4198. 

  4198. 					            Ext.StopCapture();

    4199. 

  4199. 					        }

    4200. 

  4200. 					        return success ? 0 : 1;

    4201. 

  4201. 					    }

    4202. 

  4202. 					

    4203. 

  4203. 					    static bool check24() {

    4204. 

  4204. 					        foreach (D val in new D[] { null, new D(), new D(0), new D(5) }) {

    4205. 

  4205. 					            if (!check24(val)) {

    4206. 

  4206. 					                return false;

    4207. 

  4207. 					            }

    4208. 

  4208. 					        }

    4209. 

  4209. 					        return true;

    4210. 

  4210. 					    }

    4211. 

  4211. 					

    4212. 

  4212. 					    static bool check24(D val) {

    4213. 

  4213. 					        Expression<Func<D>> e =

    4214. 

  4214. 					            Expression.Lambda<Func<D>>(

    4215. 

  4215. 					                Expression.Constant(val, typeof(D)),

    4216. 

  4216. 					                new System.Collections.Generic.List<ParameterExpression>());

    4217. 

  4217. 					        Func<D> f = e.Compile();

    4218. 

  4218. 					        return object.Equals(f(), val);

    4219. 

  4219. 					    }

    4220. 

  4220. 					}

    4221. 

  4221. 				

    4222. 

  4222. 				

    4223. 

  4223. 				public  static class Ext {

    4224. 

  4224. 				    public static void StartCapture() {

    4225. 

  4225. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4226. 

  4226. 				//        m.Invoke(null, new object[] { "test.dll" });

    4227. 

  4227. 				    }

    4228. 

  4228. 				

    4229. 

  4229. 				    public static void StopCapture() {

    4230. 

  4230. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4231. 

  4231. 				//        m.Invoke(null, new object[0]);

    4232. 

  4232. 				    }

    4233. 

  4233. 				

    4234. 

  4234. 				    public static bool IsIntegralOrEnum(Type type) {

    4235. 

  4235. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4236. 

  4236. 				            case TypeCode.Byte:

    4237. 

  4237. 				            case TypeCode.SByte:

    4238. 

  4238. 				            case TypeCode.Int16:

    4239. 

  4239. 				            case TypeCode.Int32:

    4240. 

  4240. 				            case TypeCode.Int64:

    4241. 

  4241. 				            case TypeCode.UInt16:

    4242. 

  4242. 				            case TypeCode.UInt32:

    4243. 

  4243. 				            case TypeCode.UInt64:

    4244. 

  4244. 				                return true;

    4245. 

  4245. 				            default:

    4246. 

  4246. 				                return false;

    4247. 

  4247. 				        }

    4248. 

  4248. 				    }

    4249. 

  4249. 				

    4250. 

  4250. 				    public static bool IsFloating(Type type) {

    4251. 

  4251. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4252. 

  4252. 				            case TypeCode.Single:

    4253. 

  4253. 				            case TypeCode.Double:

    4254. 

  4254. 				                return true;

    4255. 

  4255. 				            default:

    4256. 

  4256. 				                return false;

    4257. 

  4257. 				        }

    4258. 

  4258. 				    }

    4259. 

  4259. 				

    4260. 

  4260. 				    public static Type GetNonNullableType(Type type) {

    4261. 

  4261. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    4262. 

  4262. 				                type.GetGenericArguments()[0] :

    4263. 

  4263. 				                type;

    4264. 

  4264. 				    }

    4265. 

  4265. 				}

    4266. 

  4266. 				

    4267. 

  4267. 			

    4268. 

  4268. 			

    4269. 

  4269. 			

    4270. 

  4270. 			public interface I {

    4271. 

  4271. 			  void M();

    4272. 

  4272. 			}

    4273. 

  4273. 			

    4274. 

  4274. 			public  class C : IEquatable<C>, I {

    4275. 

  4275. 			    void I.M() {

    4276. 

  4276. 			    }

    4277. 

  4277. 			

    4278. 

  4278. 			    public override bool Equals(object o) {

    4279. 

  4279. 			        return o is C && Equals((C) o);

    4280. 

  4280. 			    }

    4281. 

  4281. 			

    4282. 

  4282. 			    public bool Equals(C c) {

    4283. 

  4283. 			        return c != null;

    4284. 

  4284. 			    }

    4285. 

  4285. 			

    4286. 

  4286. 			    public override int GetHashCode() {

    4287. 

  4287. 			        return 0;

    4288. 

  4288. 			    }

    4289. 

  4289. 			}

    4290. 

  4290. 			

    4291. 

  4291. 			public  class D : C, IEquatable<D> {

    4292. 

  4292. 			    public int Val;

    4293. 

  4293. 			    public D() {

    4294. 

  4294. 			    }

    4295. 

  4295. 			    public D(int val) {

    4296. 

  4296. 			        Val = val;

    4297. 

  4297. 			    }

    4298. 

  4298. 			

    4299. 

  4299. 			    public override bool Equals(object o) {

    4300. 

  4300. 			        return o is D && Equals((D) o);

    4301. 

  4301. 			    }

    4302. 

  4302. 			

    4303. 

  4303. 			    public bool Equals(D d) {

    4304. 

  4304. 			        return d != null && d.Val == Val;

    4305. 

  4305. 			    }

    4306. 

  4306. 			

    4307. 

  4307. 			    public override int GetHashCode() {

    4308. 

  4308. 			        return Val;

    4309. 

  4309. 			    }

    4310. 

  4310. 			}

    4311. 

  4311. 			

    4312. 

  4312. 			public enum E {

    4313. 

  4313. 			  A=1, B=2

    4314. 

  4314. 			}

    4315. 

  4315. 			

    4316. 

  4316. 			public enum El : long {

    4317. 

  4317. 			  A, B, C

    4318. 

  4318. 			}

    4319. 

  4319. 			

    4320. 

  4320. 			public struct S : IEquatable<S> {

    4321. 

  4321. 			    public override bool Equals(object o) {

    4322. 

  4322. 			        return (o is S) && Equals((S) o);

    4323. 

  4323. 			    }

    4324. 

  4324. 			    public bool Equals(S other) {

    4325. 

  4325. 			        return true;

    4326. 

  4326. 			    }

    4327. 

  4327. 			    public override int GetHashCode() {

    4328. 

  4328. 			        return 0;

    4329. 

  4329. 			    }

    4330. 

  4330. 			}

    4331. 

  4331. 			

    4332. 

  4332. 			public struct Sp : IEquatable<Sp> {

    4333. 

  4333. 			    public Sp(int i, double d) {

    4334. 

  4334. 			        I = i;

    4335. 

  4335. 			        D = d;

    4336. 

  4336. 			    }

    4337. 

  4337. 			

    4338. 

  4338. 			    public int I;

    4339. 

  4339. 			    public double D;

    4340. 

  4340. 			

    4341. 

  4341. 			    public override bool Equals(object o) {

    4342. 

  4342. 			        return (o is Sp) && Equals((Sp) o);

    4343. 

  4343. 			    }

    4344. 

  4344. 			    public bool Equals(Sp other) {

    4345. 

  4345. 			        return other.I == I && other.D == D;

    4346. 

  4346. 			    }

    4347. 

  4347. 			    public override int GetHashCode() {

    4348. 

  4348. 			        return I.GetHashCode() ^ D.GetHashCode();

    4349. 

  4349. 			    }

    4350. 

  4350. 			}

    4351. 

  4351. 			

    4352. 

  4352. 			public struct Ss : IEquatable<Ss> {

    4353. 

  4353. 			    public Ss(S s) {

    4354. 

  4354. 			        Val = s;

    4355. 

  4355. 			    }

    4356. 

  4356. 			

    4357. 

  4357. 			    public S Val;

    4358. 

  4358. 			

    4359. 

  4359. 			    public override bool Equals(object o) {

    4360. 

  4360. 			        return (o is Ss) && Equals((Ss) o);

    4361. 

  4361. 			    }

    4362. 

  4362. 			    public bool Equals(Ss other) {

    4363. 

  4363. 			        return other.Val.Equals(Val);

    4364. 

  4364. 			    }

    4365. 

  4365. 			    public override int GetHashCode() {

    4366. 

  4366. 			        return Val.GetHashCode();

    4367. 

  4367. 			    }

    4368. 

  4368. 			}

    4369. 

  4369. 			

    4370. 

  4370. 			public struct Sc : IEquatable<Sc> {

    4371. 

  4371. 			    public Sc(string s) {

    4372. 

  4372. 			        S = s;

    4373. 

  4373. 			    }

    4374. 

  4374. 			

    4375. 

  4375. 			    public string S;

    4376. 

  4376. 			

    4377. 

  4377. 			    public override bool Equals(object o) {

    4378. 

  4378. 			        return (o is Sc) && Equals((Sc) o);

    4379. 

  4379. 			    }

    4380. 

  4380. 			    public bool Equals(Sc other) {

    4381. 

  4381. 			        return other.S == S;

    4382. 

  4382. 			    }

    4383. 

  4383. 			    public override int GetHashCode() {

    4384. 

  4384. 			        return S.GetHashCode();

    4385. 

  4385. 			    }

    4386. 

  4386. 			}

    4387. 

  4387. 			

    4388. 

  4388. 			public struct Scs : IEquatable<Scs> {

    4389. 

  4389. 			    public Scs(string s, S val) {

    4390. 

  4390. 			        S = s;

    4391. 

  4391. 			        Val = val;

    4392. 

  4392. 			    }

    4393. 

  4393. 			

    4394. 

  4394. 			    public string S;

    4395. 

  4395. 			    public S Val;

    4396. 

  4396. 			

    4397. 

  4397. 			    public override bool Equals(object o) {

    4398. 

  4398. 			        return (o is Scs) && Equals((Scs) o);

    4399. 

  4399. 			    }

    4400. 

  4400. 			    public bool Equals(Scs other) {

    4401. 

  4401. 			        return other.S == S && other.Val.Equals(Val);

    4402. 

  4402. 			    }

    4403. 

  4403. 			    public override int GetHashCode() {

    4404. 

  4404. 			        return S.GetHashCode() ^ Val.GetHashCode();

    4405. 

  4405. 			    }

    4406. 

  4406. 			}

    4407. 

  4407. 			

    4408. 

  4408. 		

    4409. 

  4409. 	}

    4410. 

  4410. 				

    4411. 

  4411. 				//-------- Scenario 1733

    4412. 

  4412. 				namespace Scenario1733{

    4413. 

  4413. 					

    4414. 

  4414. 					public class Test

    4415. 

  4415. 					{

    4416. 

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

    4417. 

  4417. 				    public static Expression check25_object___() {

    4418. 

  4418. 				       if(Main() != 0 ) {

    4419. 

  4419. 				           throw new Exception();

    4420. 

  4420. 				       } else { 

    4421. 

  4421. 				           return Expression.Constant(0);

    4422. 

  4422. 				       }

    4423. 

  4423. 				    }

    4424. 

  4424. 					public     static int Main()

    4425. 

  4425. 					    {

    4426. 

  4426. 					        Ext.StartCapture();

    4427. 

  4427. 					        bool success = false;

    4428. 

  4428. 					        try

    4429. 

  4429. 					        {

    4430. 

  4430. 					            success = check25<object>();

    4431. 

  4431. 					        }

    4432. 

  4432. 					        finally

    4433. 

  4433. 					        {

    4434. 

  4434. 					            Ext.StopCapture();

    4435. 

  4435. 					        }

    4436. 

  4436. 					        return success ? 0 : 1;

    4437. 

  4437. 					    }

    4438. 

  4438. 					

    4439. 

  4439. 					    static bool check25<T>() {

    4440. 

  4440. 					        foreach (T val in new T[] { default(T) }) {

    4441. 

  4441. 					            if (!check25<T>(val)) {

    4442. 

  4442. 					                return false;

    4443. 

  4443. 					            }

    4444. 

  4444. 					        }

    4445. 

  4445. 					        return true;

    4446. 

  4446. 					    }

    4447. 

  4447. 					

    4448. 

  4448. 					    static bool check25<T>(T val) {

    4449. 

  4449. 					        Expression<Func<T>> e =

    4450. 

  4450. 					            Expression.Lambda<Func<T>>(

    4451. 

  4451. 					                Expression.Constant(val, typeof(T)),

    4452. 

  4452. 					                new System.Collections.Generic.List<ParameterExpression>());

    4453. 

  4453. 					        Func<T> f = e.Compile();

    4454. 

  4454. 					        return object.Equals(f(), val);

    4455. 

  4455. 					    }

    4456. 

  4456. 					}

    4457. 

  4457. 				

    4458. 

  4458. 				

    4459. 

  4459. 				public  static class Ext {

    4460. 

  4460. 				    public static void StartCapture() {

    4461. 

  4461. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4462. 

  4462. 				//        m.Invoke(null, new object[] { "test.dll" });

    4463. 

  4463. 				    }

    4464. 

  4464. 				

    4465. 

  4465. 				    public static void StopCapture() {

    4466. 

  4466. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4467. 

  4467. 				//        m.Invoke(null, new object[0]);

    4468. 

  4468. 				    }

    4469. 

  4469. 				

    4470. 

  4470. 				    public static bool IsIntegralOrEnum(Type type) {

    4471. 

  4471. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4472. 

  4472. 				            case TypeCode.Byte:

    4473. 

  4473. 				            case TypeCode.SByte:

    4474. 

  4474. 				            case TypeCode.Int16:

    4475. 

  4475. 				            case TypeCode.Int32:

    4476. 

  4476. 				            case TypeCode.Int64:

    4477. 

  4477. 				            case TypeCode.UInt16:

    4478. 

  4478. 				            case TypeCode.UInt32:

    4479. 

  4479. 				            case TypeCode.UInt64:

    4480. 

  4480. 				                return true;

    4481. 

  4481. 				            default:

    4482. 

  4482. 				                return false;

    4483. 

  4483. 				        }

    4484. 

  4484. 				    }

    4485. 

  4485. 				

    4486. 

  4486. 				    public static bool IsFloating(Type type) {

    4487. 

  4487. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4488. 

  4488. 				            case TypeCode.Single:

    4489. 

  4489. 				            case TypeCode.Double:

    4490. 

  4490. 				                return true;

    4491. 

  4491. 				            default:

    4492. 

  4492. 				                return false;

    4493. 

  4493. 				        }

    4494. 

  4494. 				    }

    4495. 

  4495. 				

    4496. 

  4496. 				    public static Type GetNonNullableType(Type type) {

    4497. 

  4497. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    4498. 

  4498. 				                type.GetGenericArguments()[0] :

    4499. 

  4499. 				                type;

    4500. 

  4500. 				    }

    4501. 

  4501. 				}

    4502. 

  4502. 				

    4503. 

  4503. 			

    4504. 

  4504. 			

    4505. 

  4505. 			

    4506. 

  4506. 			public interface I {

    4507. 

  4507. 			  void M();

    4508. 

  4508. 			}

    4509. 

  4509. 			

    4510. 

  4510. 			public  class C : IEquatable<C>, I {

    4511. 

  4511. 			    void I.M() {

    4512. 

  4512. 			    }

    4513. 

  4513. 			

    4514. 

  4514. 			    public override bool Equals(object o) {

    4515. 

  4515. 			        return o is C && Equals((C) o);

    4516. 

  4516. 			    }

    4517. 

  4517. 			

    4518. 

  4518. 			    public bool Equals(C c) {

    4519. 

  4519. 			        return c != null;

    4520. 

  4520. 			    }

    4521. 

  4521. 			

    4522. 

  4522. 			    public override int GetHashCode() {

    4523. 

  4523. 			        return 0;

    4524. 

  4524. 			    }

    4525. 

  4525. 			}

    4526. 

  4526. 			

    4527. 

  4527. 			public  class D : C, IEquatable<D> {

    4528. 

  4528. 			    public int Val;

    4529. 

  4529. 			    public D() {

    4530. 

  4530. 			    }

    4531. 

  4531. 			    public D(int val) {

    4532. 

  4532. 			        Val = val;

    4533. 

  4533. 			    }

    4534. 

  4534. 			

    4535. 

  4535. 			    public override bool Equals(object o) {

    4536. 

  4536. 			        return o is D && Equals((D) o);

    4537. 

  4537. 			    }

    4538. 

  4538. 			

    4539. 

  4539. 			    public bool Equals(D d) {

    4540. 

  4540. 			        return d != null && d.Val == Val;

    4541. 

  4541. 			    }

    4542. 

  4542. 			

    4543. 

  4543. 			    public override int GetHashCode() {

    4544. 

  4544. 			        return Val;

    4545. 

  4545. 			    }

    4546. 

  4546. 			}

    4547. 

  4547. 			

    4548. 

  4548. 			public enum E {

    4549. 

  4549. 			  A=1, B=2

    4550. 

  4550. 			}

    4551. 

  4551. 			

    4552. 

  4552. 			public enum El : long {

    4553. 

  4553. 			  A, B, C

    4554. 

  4554. 			}

    4555. 

  4555. 			

    4556. 

  4556. 			public struct S : IEquatable<S> {

    4557. 

  4557. 			    public override bool Equals(object o) {

    4558. 

  4558. 			        return (o is S) && Equals((S) o);

    4559. 

  4559. 			    }

    4560. 

  4560. 			    public bool Equals(S other) {

    4561. 

  4561. 			        return true;

    4562. 

  4562. 			    }

    4563. 

  4563. 			    public override int GetHashCode() {

    4564. 

  4564. 			        return 0;

    4565. 

  4565. 			    }

    4566. 

  4566. 			}

    4567. 

  4567. 			

    4568. 

  4568. 			public struct Sp : IEquatable<Sp> {

    4569. 

  4569. 			    public Sp(int i, double d) {

    4570. 

  4570. 			        I = i;

    4571. 

  4571. 			        D = d;

    4572. 

  4572. 			    }

    4573. 

  4573. 			

    4574. 

  4574. 			    public int I;

    4575. 

  4575. 			    public double D;

    4576. 

  4576. 			

    4577. 

  4577. 			    public override bool Equals(object o) {

    4578. 

  4578. 			        return (o is Sp) && Equals((Sp) o);

    4579. 

  4579. 			    }

    4580. 

  4580. 			    public bool Equals(Sp other) {

    4581. 

  4581. 			        return other.I == I && other.D == D;

    4582. 

  4582. 			    }

    4583. 

  4583. 			    public override int GetHashCode() {

    4584. 

  4584. 			        return I.GetHashCode() ^ D.GetHashCode();

    4585. 

  4585. 			    }

    4586. 

  4586. 			}

    4587. 

  4587. 			

    4588. 

  4588. 			public struct Ss : IEquatable<Ss> {

    4589. 

  4589. 			    public Ss(S s) {

    4590. 

  4590. 			        Val = s;

    4591. 

  4591. 			    }

    4592. 

  4592. 			

    4593. 

  4593. 			    public S Val;

    4594. 

  4594. 			

    4595. 

  4595. 			    public override bool Equals(object o) {

    4596. 

  4596. 			        return (o is Ss) && Equals((Ss) o);

    4597. 

  4597. 			    }

    4598. 

  4598. 			    public bool Equals(Ss other) {

    4599. 

  4599. 			        return other.Val.Equals(Val);

    4600. 

  4600. 			    }

    4601. 

  4601. 			    public override int GetHashCode() {

    4602. 

  4602. 			        return Val.GetHashCode();

    4603. 

  4603. 			    }

    4604. 

  4604. 			}

    4605. 

  4605. 			

    4606. 

  4606. 			public struct Sc : IEquatable<Sc> {

    4607. 

  4607. 			    public Sc(string s) {

    4608. 

  4608. 			        S = s;

    4609. 

  4609. 			    }

    4610. 

  4610. 			

    4611. 

  4611. 			    public string S;

    4612. 

  4612. 			

    4613. 

  4613. 			    public override bool Equals(object o) {

    4614. 

  4614. 			        return (o is Sc) && Equals((Sc) o);

    4615. 

  4615. 			    }

    4616. 

  4616. 			    public bool Equals(Sc other) {

    4617. 

  4617. 			        return other.S == S;

    4618. 

  4618. 			    }

    4619. 

  4619. 			    public override int GetHashCode() {

    4620. 

  4620. 			        return S.GetHashCode();

    4621. 

  4621. 			    }

    4622. 

  4622. 			}

    4623. 

  4623. 			

    4624. 

  4624. 			public struct Scs : IEquatable<Scs> {

    4625. 

  4625. 			    public Scs(string s, S val) {

    4626. 

  4626. 			        S = s;

    4627. 

  4627. 			        Val = val;

    4628. 

  4628. 			    }

    4629. 

  4629. 			

    4630. 

  4630. 			    public string S;

    4631. 

  4631. 			    public S Val;

    4632. 

  4632. 			

    4633. 

  4633. 			    public override bool Equals(object o) {

    4634. 

  4634. 			        return (o is Scs) && Equals((Scs) o);

    4635. 

  4635. 			    }

    4636. 

  4636. 			    public bool Equals(Scs other) {

    4637. 

  4637. 			        return other.S == S && other.Val.Equals(Val);

    4638. 

  4638. 			    }

    4639. 

  4639. 			    public override int GetHashCode() {

    4640. 

  4640. 			        return S.GetHashCode() ^ Val.GetHashCode();

    4641. 

  4641. 			    }

    4642. 

  4642. 			}

    4643. 

  4643. 			

    4644. 

  4644. 		

    4645. 

  4645. 	}

    4646. 

  4646. 				

    4647. 

  4647. 				//-------- Scenario 1734

    4648. 

  4648. 				namespace Scenario1734{

    4649. 

  4649. 					

    4650. 

  4650. 					public class Test

    4651. 

  4651. 					{

    4652. 

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

    4653. 

  4653. 				    public static Expression check25_C___() {

    4654. 

  4654. 				       if(Main() != 0 ) {

    4655. 

  4655. 				           throw new Exception();

    4656. 

  4656. 				       } else { 

    4657. 

  4657. 				           return Expression.Constant(0);

    4658. 

  4658. 				       }

    4659. 

  4659. 				    }

    4660. 

  4660. 					public     static int Main()

    4661. 

  4661. 					    {

    4662. 

  4662. 					        Ext.StartCapture();

    4663. 

  4663. 					        bool success = false;

    4664. 

  4664. 					        try

    4665. 

  4665. 					        {

    4666. 

  4666. 					            success = check25<C>();

    4667. 

  4667. 					        }

    4668. 

  4668. 					        finally

    4669. 

  4669. 					        {

    4670. 

  4670. 					            Ext.StopCapture();

    4671. 

  4671. 					        }

    4672. 

  4672. 					        return success ? 0 : 1;

    4673. 

  4673. 					    }

    4674. 

  4674. 					

    4675. 

  4675. 					    static bool check25<T>() {

    4676. 

  4676. 					        foreach (T val in new T[] { default(T) }) {

    4677. 

  4677. 					            if (!check25<T>(val)) {

    4678. 

  4678. 					                return false;

    4679. 

  4679. 					            }

    4680. 

  4680. 					        }

    4681. 

  4681. 					        return true;

    4682. 

  4682. 					    }

    4683. 

  4683. 					

    4684. 

  4684. 					    static bool check25<T>(T val) {

    4685. 

  4685. 					        Expression<Func<T>> e =

    4686. 

  4686. 					            Expression.Lambda<Func<T>>(

    4687. 

  4687. 					                Expression.Constant(val, typeof(T)),

    4688. 

  4688. 					                new System.Collections.Generic.List<ParameterExpression>());

    4689. 

  4689. 					        Func<T> f = e.Compile();

    4690. 

  4690. 					        return object.Equals(f(), val);

    4691. 

  4691. 					    }

    4692. 

  4692. 					}

    4693. 

  4693. 				

    4694. 

  4694. 				

    4695. 

  4695. 				public  static class Ext {

    4696. 

  4696. 				    public static void StartCapture() {

    4697. 

  4697. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4698. 

  4698. 				//        m.Invoke(null, new object[] { "test.dll" });

    4699. 

  4699. 				    }

    4700. 

  4700. 				

    4701. 

  4701. 				    public static void StopCapture() {

    4702. 

  4702. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4703. 

  4703. 				//        m.Invoke(null, new object[0]);

    4704. 

  4704. 				    }

    4705. 

  4705. 				

    4706. 

  4706. 				    public static bool IsIntegralOrEnum(Type type) {

    4707. 

  4707. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4708. 

  4708. 				            case TypeCode.Byte:

    4709. 

  4709. 				            case TypeCode.SByte:

    4710. 

  4710. 				            case TypeCode.Int16:

    4711. 

  4711. 				            case TypeCode.Int32:

    4712. 

  4712. 				            case TypeCode.Int64:

    4713. 

  4713. 				            case TypeCode.UInt16:

    4714. 

  4714. 				            case TypeCode.UInt32:

    4715. 

  4715. 				            case TypeCode.UInt64:

    4716. 

  4716. 				                return true;

    4717. 

  4717. 				            default:

    4718. 

  4718. 				                return false;

    4719. 

  4719. 				        }

    4720. 

  4720. 				    }

    4721. 

  4721. 				

    4722. 

  4722. 				    public static bool IsFloating(Type type) {

    4723. 

  4723. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4724. 

  4724. 				            case TypeCode.Single:

    4725. 

  4725. 				            case TypeCode.Double:

    4726. 

  4726. 				                return true;

    4727. 

  4727. 				            default:

    4728. 

  4728. 				                return false;

    4729. 

  4729. 				        }

    4730. 

  4730. 				    }

    4731. 

  4731. 				

    4732. 

  4732. 				    public static Type GetNonNullableType(Type type) {

    4733. 

  4733. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    4734. 

  4734. 				                type.GetGenericArguments()[0] :

    4735. 

  4735. 				                type;

    4736. 

  4736. 				    }

    4737. 

  4737. 				}

    4738. 

  4738. 				

    4739. 

  4739. 			

    4740. 

  4740. 			

    4741. 

  4741. 			

    4742. 

  4742. 			public interface I {

    4743. 

  4743. 			  void M();

    4744. 

  4744. 			}

    4745. 

  4745. 			

    4746. 

  4746. 			public  class C : IEquatable<C>, I {

    4747. 

  4747. 			    void I.M() {

    4748. 

  4748. 			    }

    4749. 

  4749. 			

    4750. 

  4750. 			    public override bool Equals(object o) {

    4751. 

  4751. 			        return o is C && Equals((C) o);

    4752. 

  4752. 			    }

    4753. 

  4753. 			

    4754. 

  4754. 			    public bool Equals(C c) {

    4755. 

  4755. 			        return c != null;

    4756. 

  4756. 			    }

    4757. 

  4757. 			

    4758. 

  4758. 			    public override int GetHashCode() {

    4759. 

  4759. 			        return 0;

    4760. 

  4760. 			    }

    4761. 

  4761. 			}

    4762. 

  4762. 			

    4763. 

  4763. 			public  class D : C, IEquatable<D> {

    4764. 

  4764. 			    public int Val;

    4765. 

  4765. 			    public D() {

    4766. 

  4766. 			    }

    4767. 

  4767. 			    public D(int val) {

    4768. 

  4768. 			        Val = val;

    4769. 

  4769. 			    }

    4770. 

  4770. 			

    4771. 

  4771. 			    public override bool Equals(object o) {

    4772. 

  4772. 			        return o is D && Equals((D) o);

    4773. 

  4773. 			    }

    4774. 

  4774. 			

    4775. 

  4775. 			    public bool Equals(D d) {

    4776. 

  4776. 			        return d != null && d.Val == Val;

    4777. 

  4777. 			    }

    4778. 

  4778. 			

    4779. 

  4779. 			    public override int GetHashCode() {

    4780. 

  4780. 			        return Val;

    4781. 

  4781. 			    }

    4782. 

  4782. 			}

    4783. 

  4783. 			

    4784. 

  4784. 			public enum E {

    4785. 

  4785. 			  A=1, B=2

    4786. 

  4786. 			}

    4787. 

  4787. 			

    4788. 

  4788. 			public enum El : long {

    4789. 

  4789. 			  A, B, C

    4790. 

  4790. 			}

    4791. 

  4791. 			

    4792. 

  4792. 			public struct S : IEquatable<S> {

    4793. 

  4793. 			    public override bool Equals(object o) {

    4794. 

  4794. 			        return (o is S) && Equals((S) o);

    4795. 

  4795. 			    }

    4796. 

  4796. 			    public bool Equals(S other) {

    4797. 

  4797. 			        return true;

    4798. 

  4798. 			    }

    4799. 

  4799. 			    public override int GetHashCode() {

    4800. 

  4800. 			        return 0;

    4801. 

  4801. 			    }

    4802. 

  4802. 			}

    4803. 

  4803. 			

    4804. 

  4804. 			public struct Sp : IEquatable<Sp> {

    4805. 

  4805. 			    public Sp(int i, double d) {

    4806. 

  4806. 			        I = i;

    4807. 

  4807. 			        D = d;

    4808. 

  4808. 			    }

    4809. 

  4809. 			

    4810. 

  4810. 			    public int I;

    4811. 

  4811. 			    public double D;

    4812. 

  4812. 			

    4813. 

  4813. 			    public override bool Equals(object o) {

    4814. 

  4814. 			        return (o is Sp) && Equals((Sp) o);

    4815. 

  4815. 			    }

    4816. 

  4816. 			    public bool Equals(Sp other) {

    4817. 

  4817. 			        return other.I == I && other.D == D;

    4818. 

  4818. 			    }

    4819. 

  4819. 			    public override int GetHashCode() {

    4820. 

  4820. 			        return I.GetHashCode() ^ D.GetHashCode();

    4821. 

  4821. 			    }

    4822. 

  4822. 			}

    4823. 

  4823. 			

    4824. 

  4824. 			public struct Ss : IEquatable<Ss> {

    4825. 

  4825. 			    public Ss(S s) {

    4826. 

  4826. 			        Val = s;

    4827. 

  4827. 			    }

    4828. 

  4828. 			

    4829. 

  4829. 			    public S Val;

    4830. 

  4830. 			

    4831. 

  4831. 			    public override bool Equals(object o) {

    4832. 

  4832. 			        return (o is Ss) && Equals((Ss) o);

    4833. 

  4833. 			    }

    4834. 

  4834. 			    public bool Equals(Ss other) {

    4835. 

  4835. 			        return other.Val.Equals(Val);

    4836. 

  4836. 			    }

    4837. 

  4837. 			    public override int GetHashCode() {

    4838. 

  4838. 			        return Val.GetHashCode();

    4839. 

  4839. 			    }

    4840. 

  4840. 			}

    4841. 

  4841. 			

    4842. 

  4842. 			public struct Sc : IEquatable<Sc> {

    4843. 

  4843. 			    public Sc(string s) {

    4844. 

  4844. 			        S = s;

    4845. 

  4845. 			    }

    4846. 

  4846. 			

    4847. 

  4847. 			    public string S;

    4848. 

  4848. 			

    4849. 

  4849. 			    public override bool Equals(object o) {

    4850. 

  4850. 			        return (o is Sc) && Equals((Sc) o);

    4851. 

  4851. 			    }

    4852. 

  4852. 			    public bool Equals(Sc other) {

    4853. 

  4853. 			        return other.S == S;

    4854. 

  4854. 			    }

    4855. 

  4855. 			    public override int GetHashCode() {

    4856. 

  4856. 			        return S.GetHashCode();

    4857. 

  4857. 			    }

    4858. 

  4858. 			}

    4859. 

  4859. 			

    4860. 

  4860. 			public struct Scs : IEquatable<Scs> {

    4861. 

  4861. 			    public Scs(string s, S val) {

    4862. 

  4862. 			        S = s;

    4863. 

  4863. 			        Val = val;

    4864. 

  4864. 			    }

    4865. 

  4865. 			

    4866. 

  4866. 			    public string S;

    4867. 

  4867. 			    public S Val;

    4868. 

  4868. 			

    4869. 

  4869. 			    public override bool Equals(object o) {

    4870. 

  4870. 			        return (o is Scs) && Equals((Scs) o);

    4871. 

  4871. 			    }

    4872. 

  4872. 			    public bool Equals(Scs other) {

    4873. 

  4873. 			        return other.S == S && other.Val.Equals(Val);

    4874. 

  4874. 			    }

    4875. 

  4875. 			    public override int GetHashCode() {

    4876. 

  4876. 			        return S.GetHashCode() ^ Val.GetHashCode();

    4877. 

  4877. 			    }

    4878. 

  4878. 			}

    4879. 

  4879. 			

    4880. 

  4880. 		

    4881. 

  4881. 	}

    4882. 

  4882. 				

    4883. 

  4883. 				//-------- Scenario 1735

    4884. 

  4884. 				namespace Scenario1735{

    4885. 

  4885. 					

    4886. 

  4886. 					public class Test

    4887. 

  4887. 					{

    4888. 

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

    4889. 

  4889. 				    public static Expression check25_S___() {

    4890. 

  4890. 				       if(Main() != 0 ) {

    4891. 

  4891. 				           throw new Exception();

    4892. 

  4892. 				       } else { 

    4893. 

  4893. 				           return Expression.Constant(0);

    4894. 

  4894. 				       }

    4895. 

  4895. 				    }

    4896. 

  4896. 					public     static int Main()

    4897. 

  4897. 					    {

    4898. 

  4898. 					        Ext.StartCapture();

    4899. 

  4899. 					        bool success = false;

    4900. 

  4900. 					        try

    4901. 

  4901. 					        {

    4902. 

  4902. 					            success = check25<S>();

    4903. 

  4903. 					        }

    4904. 

  4904. 					        finally

    4905. 

  4905. 					        {

    4906. 

  4906. 					            Ext.StopCapture();

    4907. 

  4907. 					        }

    4908. 

  4908. 					        return success ? 0 : 1;

    4909. 

  4909. 					    }

    4910. 

  4910. 					

    4911. 

  4911. 					    static bool check25<T>() {

    4912. 

  4912. 					        foreach (T val in new T[] { default(T) }) {

    4913. 

  4913. 					            if (!check25<T>(val)) {

    4914. 

  4914. 					                return false;

    4915. 

  4915. 					            }

    4916. 

  4916. 					        }

    4917. 

  4917. 					        return true;

    4918. 

  4918. 					    }

    4919. 

  4919. 					

    4920. 

  4920. 					    static bool check25<T>(T val) {

    4921. 

  4921. 					        Expression<Func<T>> e =

    4922. 

  4922. 					            Expression.Lambda<Func<T>>(

    4923. 

  4923. 					                Expression.Constant(val, typeof(T)),

    4924. 

  4924. 					                new System.Collections.Generic.List<ParameterExpression>());

    4925. 

  4925. 					        Func<T> f = e.Compile();

    4926. 

  4926. 					        return object.Equals(f(), val);

    4927. 

  4927. 					    }

    4928. 

  4928. 					}

    4929. 

  4929. 				

    4930. 

  4930. 				

    4931. 

  4931. 				public  static class Ext {

    4932. 

  4932. 				    public static void StartCapture() {

    4933. 

  4933. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4934. 

  4934. 				//        m.Invoke(null, new object[] { "test.dll" });

    4935. 

  4935. 				    }

    4936. 

  4936. 				

    4937. 

  4937. 				    public static void StopCapture() {

    4938. 

  4938. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    4939. 

  4939. 				//        m.Invoke(null, new object[0]);

    4940. 

  4940. 				    }

    4941. 

  4941. 				

    4942. 

  4942. 				    public static bool IsIntegralOrEnum(Type type) {

    4943. 

  4943. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4944. 

  4944. 				            case TypeCode.Byte:

    4945. 

  4945. 				            case TypeCode.SByte:

    4946. 

  4946. 				            case TypeCode.Int16:

    4947. 

  4947. 				            case TypeCode.Int32:

    4948. 

  4948. 				            case TypeCode.Int64:

    4949. 

  4949. 				            case TypeCode.UInt16:

    4950. 

  4950. 				            case TypeCode.UInt32:

    4951. 

  4951. 				            case TypeCode.UInt64:

    4952. 

  4952. 				                return true;

    4953. 

  4953. 				            default:

    4954. 

  4954. 				                return false;

    4955. 

  4955. 				        }

    4956. 

  4956. 				    }

    4957. 

  4957. 				

    4958. 

  4958. 				    public static bool IsFloating(Type type) {

    4959. 

  4959. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    4960. 

  4960. 				            case TypeCode.Single:

    4961. 

  4961. 				            case TypeCode.Double:

    4962. 

  4962. 				                return true;

    4963. 

  4963. 				            default:

    4964. 

  4964. 				                return false;

    4965. 

  4965. 				        }

    4966. 

  4966. 				    }

    4967. 

  4967. 				

    4968. 

  4968. 				    public static Type GetNonNullableType(Type type) {

    4969. 

  4969. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    4970. 

  4970. 				                type.GetGenericArguments()[0] :

    4971. 

  4971. 				                type;

    4972. 

  4972. 				    }

    4973. 

  4973. 				}

    4974. 

  4974. 				

    4975. 

  4975. 			

    4976. 

  4976. 			

    4977. 

  4977. 			

    4978. 

  4978. 			public interface I {

    4979. 

  4979. 			  void M();

    4980. 

  4980. 			}

    4981. 

  4981. 			

    4982. 

  4982. 			public  class C : IEquatable<C>, I {

    4983. 

  4983. 			    void I.M() {

    4984. 

  4984. 			    }

    4985. 

  4985. 			

    4986. 

  4986. 			    public override bool Equals(object o) {

    4987. 

  4987. 			        return o is C && Equals((C) o);

    4988. 

  4988. 			    }

    4989. 

  4989. 			

    4990. 

  4990. 			    public bool Equals(C c) {

    4991. 

  4991. 			        return c != null;

    4992. 

  4992. 			    }

    4993. 

  4993. 			

    4994. 

  4994. 			    public override int GetHashCode() {

    4995. 

  4995. 			        return 0;

    4996. 

  4996. 			    }

    4997. 

  4997. 			}

    4998. 

  4998. 			

    4999. 

  4999. 			public  class D : C, IEquatable<D> {

    5000. 

  5000. 			    public int Val;

    5001. 

  5001. 			    public D() {

    5002. 

  5002. 			    }

    5003. 

  5003. 			    public D(int val) {

    5004. 

  5004. 			        Val = val;

    5005. 

  5005. 			    }

    5006. 

  5006. 			

    5007. 

  5007. 			    public override bool Equals(object o) {

    5008. 

  5008. 			        return o is D && Equals((D) o);

    5009. 

  5009. 			    }

    5010. 

  5010. 			

    5011. 

  5011. 			    public bool Equals(D d) {

    5012. 

  5012. 			        return d != null && d.Val == Val;

    5013. 

  5013. 			    }

    5014. 

  5014. 			

    5015. 

  5015. 			    public override int GetHashCode() {

    5016. 

  5016. 			        return Val;

    5017. 

  5017. 			    }

    5018. 

  5018. 			}

    5019. 

  5019. 			

    5020. 

  5020. 			public enum E {

    5021. 

  5021. 			  A=1, B=2

    5022. 

  5022. 			}

    5023. 

  5023. 			

    5024. 

  5024. 			public enum El : long {

    5025. 

  5025. 			  A, B, C

    5026. 

  5026. 			}

    5027. 

  5027. 			

    5028. 

  5028. 			public struct S : IEquatable<S> {

    5029. 

  5029. 			    public override bool Equals(object o) {

    5030. 

  5030. 			        return (o is S) && Equals((S) o);

    5031. 

  5031. 			    }

    5032. 

  5032. 			    public bool Equals(S other) {

    5033. 

  5033. 			        return true;

    5034. 

  5034. 			    }

    5035. 

  5035. 			    public override int GetHashCode() {

    5036. 

  5036. 			        return 0;

    5037. 

  5037. 			    }

    5038. 

  5038. 			}

    5039. 

  5039. 			

    5040. 

  5040. 			public struct Sp : IEquatable<Sp> {

    5041. 

  5041. 			    public Sp(int i, double d) {

    5042. 

  5042. 			        I = i;

    5043. 

  5043. 			        D = d;

    5044. 

  5044. 			    }

    5045. 

  5045. 			

    5046. 

  5046. 			    public int I;

    5047. 

  5047. 			    public double D;

    5048. 

  5048. 			

    5049. 

  5049. 			    public override bool Equals(object o) {

    5050. 

  5050. 			        return (o is Sp) && Equals((Sp) o);

    5051. 

  5051. 			    }

    5052. 

  5052. 			    public bool Equals(Sp other) {

    5053. 

  5053. 			        return other.I == I && other.D == D;

    5054. 

  5054. 			    }

    5055. 

  5055. 			    public override int GetHashCode() {

    5056. 

  5056. 			        return I.GetHashCode() ^ D.GetHashCode();

    5057. 

  5057. 			    }

    5058. 

  5058. 			}

    5059. 

  5059. 			

    5060. 

  5060. 			public struct Ss : IEquatable<Ss> {

    5061. 

  5061. 			    public Ss(S s) {

    5062. 

  5062. 			        Val = s;

    5063. 

  5063. 			    }

    5064. 

  5064. 			

    5065. 

  5065. 			    public S Val;

    5066. 

  5066. 			

    5067. 

  5067. 			    public override bool Equals(object o) {

    5068. 

  5068. 			        return (o is Ss) && Equals((Ss) o);

    5069. 

  5069. 			    }

    5070. 

  5070. 			    public bool Equals(Ss other) {

    5071. 

  5071. 			        return other.Val.Equals(Val);

    5072. 

  5072. 			    }

    5073. 

  5073. 			    public override int GetHashCode() {

    5074. 

  5074. 			        return Val.GetHashCode();

    5075. 

  5075. 			    }

    5076. 

  5076. 			}

    5077. 

  5077. 			

    5078. 

  5078. 			public struct Sc : IEquatable<Sc> {

    5079. 

  5079. 			    public Sc(string s) {

    5080. 

  5080. 			        S = s;

    5081. 

  5081. 			    }

    5082. 

  5082. 			

    5083. 

  5083. 			    public string S;

    5084. 

  5084. 			

    5085. 

  5085. 			    public override bool Equals(object o) {

    5086. 

  5086. 			        return (o is Sc) && Equals((Sc) o);

    5087. 

  5087. 			    }

    5088. 

  5088. 			    public bool Equals(Sc other) {

    5089. 

  5089. 			        return other.S == S;

    5090. 

  5090. 			    }

    5091. 

  5091. 			    public override int GetHashCode() {

    5092. 

  5092. 			        return S.GetHashCode();

    5093. 

  5093. 			    }

    5094. 

  5094. 			}

    5095. 

  5095. 			

    5096. 

  5096. 			public struct Scs : IEquatable<Scs> {

    5097. 

  5097. 			    public Scs(string s, S val) {

    5098. 

  5098. 			        S = s;

    5099. 

  5099. 			        Val = val;

    5100. 

  5100. 			    }

    5101. 

  5101. 			

    5102. 

  5102. 			    public string S;

    5103. 

  5103. 			    public S Val;

    5104. 

  5104. 			

    5105. 

  5105. 			    public override bool Equals(object o) {

    5106. 

  5106. 			        return (o is Scs) && Equals((Scs) o);

    5107. 

  5107. 			    }

    5108. 

  5108. 			    public bool Equals(Scs other) {

    5109. 

  5109. 			        return other.S == S && other.Val.Equals(Val);

    5110. 

  5110. 			    }

    5111. 

  5111. 			    public override int GetHashCode() {

    5112. 

  5112. 			        return S.GetHashCode() ^ Val.GetHashCode();

    5113. 

  5113. 			    }

    5114. 

  5114. 			}

    5115. 

  5115. 			

    5116. 

  5116. 		

    5117. 

  5117. 	}

    5118. 

  5118. 				

    5119. 

  5119. 				//-------- Scenario 1736

    5120. 

  5120. 				namespace Scenario1736{

    5121. 

  5121. 					

    5122. 

  5122. 					public class Test

    5123. 

  5123. 					{

    5124. 

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

    5125. 

  5125. 				    public static Expression check25_Scs___() {

    5126. 

  5126. 				       if(Main() != 0 ) {

    5127. 

  5127. 				           throw new Exception();

    5128. 

  5128. 				       } else { 

    5129. 

  5129. 				           return Expression.Constant(0);

    5130. 

  5130. 				       }

    5131. 

  5131. 				    }

    5132. 

  5132. 					public     static int Main()

    5133. 

  5133. 					    {

    5134. 

  5134. 					        Ext.StartCapture();

    5135. 

  5135. 					        bool success = false;

    5136. 

  5136. 					        try

    5137. 

  5137. 					        {

    5138. 

  5138. 					            success = check25<Scs>();

    5139. 

  5139. 					        }

    5140. 

  5140. 					        finally

    5141. 

  5141. 					        {

    5142. 

  5142. 					            Ext.StopCapture();

    5143. 

  5143. 					        }

    5144. 

  5144. 					        return success ? 0 : 1;

    5145. 

  5145. 					    }

    5146. 

  5146. 					

    5147. 

  5147. 					    static bool check25<T>() {

    5148. 

  5148. 					        foreach (T val in new T[] { default(T) }) {

    5149. 

  5149. 					            if (!check25<T>(val)) {

    5150. 

  5150. 					                return false;

    5151. 

  5151. 					            }

    5152. 

  5152. 					        }

    5153. 

  5153. 					        return true;

    5154. 

  5154. 					    }

    5155. 

  5155. 					

    5156. 

  5156. 					    static bool check25<T>(T val) {

    5157. 

  5157. 					        Expression<Func<T>> e =

    5158. 

  5158. 					            Expression.Lambda<Func<T>>(

    5159. 

  5159. 					                Expression.Constant(val, typeof(T)),

    5160. 

  5160. 					                new System.Collections.Generic.List<ParameterExpression>());

    5161. 

  5161. 					        Func<T> f = e.Compile();

    5162. 

  5162. 					        return object.Equals(f(), val);

    5163. 

  5163. 					    }

    5164. 

  5164. 					}

    5165. 

  5165. 				

    5166. 

  5166. 				

    5167. 

  5167. 				public  static class Ext {

    5168. 

  5168. 				    public static void StartCapture() {

    5169. 

  5169. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5170. 

  5170. 				//        m.Invoke(null, new object[] { "test.dll" });

    5171. 

  5171. 				    }

    5172. 

  5172. 				

    5173. 

  5173. 				    public static void StopCapture() {

    5174. 

  5174. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5175. 

  5175. 				//        m.Invoke(null, new object[0]);

    5176. 

  5176. 				    }

    5177. 

  5177. 				

    5178. 

  5178. 				    public static bool IsIntegralOrEnum(Type type) {

    5179. 

  5179. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5180. 

  5180. 				            case TypeCode.Byte:

    5181. 

  5181. 				            case TypeCode.SByte:

    5182. 

  5182. 				            case TypeCode.Int16:

    5183. 

  5183. 				            case TypeCode.Int32:

    5184. 

  5184. 				            case TypeCode.Int64:

    5185. 

  5185. 				            case TypeCode.UInt16:

    5186. 

  5186. 				            case TypeCode.UInt32:

    5187. 

  5187. 				            case TypeCode.UInt64:

    5188. 

  5188. 				                return true;

    5189. 

  5189. 				            default:

    5190. 

  5190. 				                return false;

    5191. 

  5191. 				        }

    5192. 

  5192. 				    }

    5193. 

  5193. 				

    5194. 

  5194. 				    public static bool IsFloating(Type type) {

    5195. 

  5195. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5196. 

  5196. 				            case TypeCode.Single:

    5197. 

  5197. 				            case TypeCode.Double:

    5198. 

  5198. 				                return true;

    5199. 

  5199. 				            default:

    5200. 

  5200. 				                return false;

    5201. 

  5201. 				        }

    5202. 

  5202. 				    }

    5203. 

  5203. 				

    5204. 

  5204. 				    public static Type GetNonNullableType(Type type) {

    5205. 

  5205. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    5206. 

  5206. 				                type.GetGenericArguments()[0] :

    5207. 

  5207. 				                type;

    5208. 

  5208. 				    }

    5209. 

  5209. 				}

    5210. 

  5210. 				

    5211. 

  5211. 			

    5212. 

  5212. 			

    5213. 

  5213. 			

    5214. 

  5214. 			public interface I {

    5215. 

  5215. 			  void M();

    5216. 

  5216. 			}

    5217. 

  5217. 			

    5218. 

  5218. 			public  class C : IEquatable<C>, I {

    5219. 

  5219. 			    void I.M() {

    5220. 

  5220. 			    }

    5221. 

  5221. 			

    5222. 

  5222. 			    public override bool Equals(object o) {

    5223. 

  5223. 			        return o is C && Equals((C) o);

    5224. 

  5224. 			    }

    5225. 

  5225. 			

    5226. 

  5226. 			    public bool Equals(C c) {

    5227. 

  5227. 			        return c != null;

    5228. 

  5228. 			    }

    5229. 

  5229. 			

    5230. 

  5230. 			    public override int GetHashCode() {

    5231. 

  5231. 			        return 0;

    5232. 

  5232. 			    }

    5233. 

  5233. 			}

    5234. 

  5234. 			

    5235. 

  5235. 			public  class D : C, IEquatable<D> {

    5236. 

  5236. 			    public int Val;

    5237. 

  5237. 			    public D() {

    5238. 

  5238. 			    }

    5239. 

  5239. 			    public D(int val) {

    5240. 

  5240. 			        Val = val;

    5241. 

  5241. 			    }

    5242. 

  5242. 			

    5243. 

  5243. 			    public override bool Equals(object o) {

    5244. 

  5244. 			        return o is D && Equals((D) o);

    5245. 

  5245. 			    }

    5246. 

  5246. 			

    5247. 

  5247. 			    public bool Equals(D d) {

    5248. 

  5248. 			        return d != null && d.Val == Val;

    5249. 

  5249. 			    }

    5250. 

  5250. 			

    5251. 

  5251. 			    public override int GetHashCode() {

    5252. 

  5252. 			        return Val;

    5253. 

  5253. 			    }

    5254. 

  5254. 			}

    5255. 

  5255. 			

    5256. 

  5256. 			public enum E {

    5257. 

  5257. 			  A=1, B=2

    5258. 

  5258. 			}

    5259. 

  5259. 			

    5260. 

  5260. 			public enum El : long {

    5261. 

  5261. 			  A, B, C

    5262. 

  5262. 			}

    5263. 

  5263. 			

    5264. 

  5264. 			public struct S : IEquatable<S> {

    5265. 

  5265. 			    public override bool Equals(object o) {

    5266. 

  5266. 			        return (o is S) && Equals((S) o);

    5267. 

  5267. 			    }

    5268. 

  5268. 			    public bool Equals(S other) {

    5269. 

  5269. 			        return true;

    5270. 

  5270. 			    }

    5271. 

  5271. 			    public override int GetHashCode() {

    5272. 

  5272. 			        return 0;

    5273. 

  5273. 			    }

    5274. 

  5274. 			}

    5275. 

  5275. 			

    5276. 

  5276. 			public struct Sp : IEquatable<Sp> {

    5277. 

  5277. 			    public Sp(int i, double d) {

    5278. 

  5278. 			        I = i;

    5279. 

  5279. 			        D = d;

    5280. 

  5280. 			    }

    5281. 

  5281. 			

    5282. 

  5282. 			    public int I;

    5283. 

  5283. 			    public double D;

    5284. 

  5284. 			

    5285. 

  5285. 			    public override bool Equals(object o) {

    5286. 

  5286. 			        return (o is Sp) && Equals((Sp) o);

    5287. 

  5287. 			    }

    5288. 

  5288. 			    public bool Equals(Sp other) {

    5289. 

  5289. 			        return other.I == I && other.D == D;

    5290. 

  5290. 			    }

    5291. 

  5291. 			    public override int GetHashCode() {

    5292. 

  5292. 			        return I.GetHashCode() ^ D.GetHashCode();

    5293. 

  5293. 			    }

    5294. 

  5294. 			}

    5295. 

  5295. 			

    5296. 

  5296. 			public struct Ss : IEquatable<Ss> {

    5297. 

  5297. 			    public Ss(S s) {

    5298. 

  5298. 			        Val = s;

    5299. 

  5299. 			    }

    5300. 

  5300. 			

    5301. 

  5301. 			    public S Val;

    5302. 

  5302. 			

    5303. 

  5303. 			    public override bool Equals(object o) {

    5304. 

  5304. 			        return (o is Ss) && Equals((Ss) o);

    5305. 

  5305. 			    }

    5306. 

  5306. 			    public bool Equals(Ss other) {

    5307. 

  5307. 			        return other.Val.Equals(Val);

    5308. 

  5308. 			    }

    5309. 

  5309. 			    public override int GetHashCode() {

    5310. 

  5310. 			        return Val.GetHashCode();

    5311. 

  5311. 			    }

    5312. 

  5312. 			}

    5313. 

  5313. 			

    5314. 

  5314. 			public struct Sc : IEquatable<Sc> {

    5315. 

  5315. 			    public Sc(string s) {

    5316. 

  5316. 			        S = s;

    5317. 

  5317. 			    }

    5318. 

  5318. 			

    5319. 

  5319. 			    public string S;

    5320. 

  5320. 			

    5321. 

  5321. 			    public override bool Equals(object o) {

    5322. 

  5322. 			        return (o is Sc) && Equals((Sc) o);

    5323. 

  5323. 			    }

    5324. 

  5324. 			    public bool Equals(Sc other) {

    5325. 

  5325. 			        return other.S == S;

    5326. 

  5326. 			    }

    5327. 

  5327. 			    public override int GetHashCode() {

    5328. 

  5328. 			        return S.GetHashCode();

    5329. 

  5329. 			    }

    5330. 

  5330. 			}

    5331. 

  5331. 			

    5332. 

  5332. 			public struct Scs : IEquatable<Scs> {

    5333. 

  5333. 			    public Scs(string s, S val) {

    5334. 

  5334. 			        S = s;

    5335. 

  5335. 			        Val = val;

    5336. 

  5336. 			    }

    5337. 

  5337. 			

    5338. 

  5338. 			    public string S;

    5339. 

  5339. 			    public S Val;

    5340. 

  5340. 			

    5341. 

  5341. 			    public override bool Equals(object o) {

    5342. 

  5342. 			        return (o is Scs) && Equals((Scs) o);

    5343. 

  5343. 			    }

    5344. 

  5344. 			    public bool Equals(Scs other) {

    5345. 

  5345. 			        return other.S == S && other.Val.Equals(Val);

    5346. 

  5346. 			    }

    5347. 

  5347. 			    public override int GetHashCode() {

    5348. 

  5348. 			        return S.GetHashCode() ^ Val.GetHashCode();

    5349. 

  5349. 			    }

    5350. 

  5350. 			}

    5351. 

  5351. 			

    5352. 

  5352. 		

    5353. 

  5353. 	}

    5354. 

  5354. 				

    5355. 

  5355. 				//-------- Scenario 1737

    5356. 

  5356. 				namespace Scenario1737{

    5357. 

  5357. 					

    5358. 

  5358. 					public class Test

    5359. 

  5359. 					{

    5360. 

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

    5361. 

  5361. 				    public static Expression check25_E___() {

    5362. 

  5362. 				       if(Main() != 0 ) {

    5363. 

  5363. 				           throw new Exception();

    5364. 

  5364. 				       } else { 

    5365. 

  5365. 				           return Expression.Constant(0);

    5366. 

  5366. 				       }

    5367. 

  5367. 				    }

    5368. 

  5368. 					public     static int Main()

    5369. 

  5369. 					    {

    5370. 

  5370. 					        Ext.StartCapture();

    5371. 

  5371. 					        bool success = false;

    5372. 

  5372. 					        try

    5373. 

  5373. 					        {

    5374. 

  5374. 					            success = check25<E>();

    5375. 

  5375. 					        }

    5376. 

  5376. 					        finally

    5377. 

  5377. 					        {

    5378. 

  5378. 					            Ext.StopCapture();

    5379. 

  5379. 					        }

    5380. 

  5380. 					        return success ? 0 : 1;

    5381. 

  5381. 					    }

    5382. 

  5382. 					

    5383. 

  5383. 					    static bool check25<T>() {

    5384. 

  5384. 					        foreach (T val in new T[] { default(T) }) {

    5385. 

  5385. 					            if (!check25<T>(val)) {

    5386. 

  5386. 					                return false;

    5387. 

  5387. 					            }

    5388. 

  5388. 					        }

    5389. 

  5389. 					        return true;

    5390. 

  5390. 					    }

    5391. 

  5391. 					

    5392. 

  5392. 					    static bool check25<T>(T val) {

    5393. 

  5393. 					        Expression<Func<T>> e =

    5394. 

  5394. 					            Expression.Lambda<Func<T>>(

    5395. 

  5395. 					                Expression.Constant(val, typeof(T)),

    5396. 

  5396. 					                new System.Collections.Generic.List<ParameterExpression>());

    5397. 

  5397. 					        Func<T> f = e.Compile();

    5398. 

  5398. 					        return object.Equals(f(), val);

    5399. 

  5399. 					    }

    5400. 

  5400. 					}

    5401. 

  5401. 				

    5402. 

  5402. 				

    5403. 

  5403. 				public  static class Ext {

    5404. 

  5404. 				    public static void StartCapture() {

    5405. 

  5405. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5406. 

  5406. 				//        m.Invoke(null, new object[] { "test.dll" });

    5407. 

  5407. 				    }

    5408. 

  5408. 				

    5409. 

  5409. 				    public static void StopCapture() {

    5410. 

  5410. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5411. 

  5411. 				//        m.Invoke(null, new object[0]);

    5412. 

  5412. 				    }

    5413. 

  5413. 				

    5414. 

  5414. 				    public static bool IsIntegralOrEnum(Type type) {

    5415. 

  5415. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5416. 

  5416. 				            case TypeCode.Byte:

    5417. 

  5417. 				            case TypeCode.SByte:

    5418. 

  5418. 				            case TypeCode.Int16:

    5419. 

  5419. 				            case TypeCode.Int32:

    5420. 

  5420. 				            case TypeCode.Int64:

    5421. 

  5421. 				            case TypeCode.UInt16:

    5422. 

  5422. 				            case TypeCode.UInt32:

    5423. 

  5423. 				            case TypeCode.UInt64:

    5424. 

  5424. 				                return true;

    5425. 

  5425. 				            default:

    5426. 

  5426. 				                return false;

    5427. 

  5427. 				        }

    5428. 

  5428. 				    }

    5429. 

  5429. 				

    5430. 

  5430. 				    public static bool IsFloating(Type type) {

    5431. 

  5431. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5432. 

  5432. 				            case TypeCode.Single:

    5433. 

  5433. 				            case TypeCode.Double:

    5434. 

  5434. 				                return true;

    5435. 

  5435. 				            default:

    5436. 

  5436. 				                return false;

    5437. 

  5437. 				        }

    5438. 

  5438. 				    }

    5439. 

  5439. 				

    5440. 

  5440. 				    public static Type GetNonNullableType(Type type) {

    5441. 

  5441. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    5442. 

  5442. 				                type.GetGenericArguments()[0] :

    5443. 

  5443. 				                type;

    5444. 

  5444. 				    }

    5445. 

  5445. 				}

    5446. 

  5446. 				

    5447. 

  5447. 			

    5448. 

  5448. 			

    5449. 

  5449. 			

    5450. 

  5450. 			public interface I {

    5451. 

  5451. 			  void M();

    5452. 

  5452. 			}

    5453. 

  5453. 			

    5454. 

  5454. 			public  class C : IEquatable<C>, I {

    5455. 

  5455. 			    void I.M() {

    5456. 

  5456. 			    }

    5457. 

  5457. 			

    5458. 

  5458. 			    public override bool Equals(object o) {

    5459. 

  5459. 			        return o is C && Equals((C) o);

    5460. 

  5460. 			    }

    5461. 

  5461. 			

    5462. 

  5462. 			    public bool Equals(C c) {

    5463. 

  5463. 			        return c != null;

    5464. 

  5464. 			    }

    5465. 

  5465. 			

    5466. 

  5466. 			    public override int GetHashCode() {

    5467. 

  5467. 			        return 0;

    5468. 

  5468. 			    }

    5469. 

  5469. 			}

    5470. 

  5470. 			

    5471. 

  5471. 			public  class D : C, IEquatable<D> {

    5472. 

  5472. 			    public int Val;

    5473. 

  5473. 			    public D() {

    5474. 

  5474. 			    }

    5475. 

  5475. 			    public D(int val) {

    5476. 

  5476. 			        Val = val;

    5477. 

  5477. 			    }

    5478. 

  5478. 			

    5479. 

  5479. 			    public override bool Equals(object o) {

    5480. 

  5480. 			        return o is D && Equals((D) o);

    5481. 

  5481. 			    }

    5482. 

  5482. 			

    5483. 

  5483. 			    public bool Equals(D d) {

    5484. 

  5484. 			        return d != null && d.Val == Val;

    5485. 

  5485. 			    }

    5486. 

  5486. 			

    5487. 

  5487. 			    public override int GetHashCode() {

    5488. 

  5488. 			        return Val;

    5489. 

  5489. 			    }

    5490. 

  5490. 			}

    5491. 

  5491. 			

    5492. 

  5492. 			public enum E {

    5493. 

  5493. 			  A=1, B=2

    5494. 

  5494. 			}

    5495. 

  5495. 			

    5496. 

  5496. 			public enum El : long {

    5497. 

  5497. 			  A, B, C

    5498. 

  5498. 			}

    5499. 

  5499. 			

    5500. 

  5500. 			public struct S : IEquatable<S> {

    5501. 

  5501. 			    public override bool Equals(object o) {

    5502. 

  5502. 			        return (o is S) && Equals((S) o);

    5503. 

  5503. 			    }

    5504. 

  5504. 			    public bool Equals(S other) {

    5505. 

  5505. 			        return true;

    5506. 

  5506. 			    }

    5507. 

  5507. 			    public override int GetHashCode() {

    5508. 

  5508. 			        return 0;

    5509. 

  5509. 			    }

    5510. 

  5510. 			}

    5511. 

  5511. 			

    5512. 

  5512. 			public struct Sp : IEquatable<Sp> {

    5513. 

  5513. 			    public Sp(int i, double d) {

    5514. 

  5514. 			        I = i;

    5515. 

  5515. 			        D = d;

    5516. 

  5516. 			    }

    5517. 

  5517. 			

    5518. 

  5518. 			    public int I;

    5519. 

  5519. 			    public double D;

    5520. 

  5520. 			

    5521. 

  5521. 			    public override bool Equals(object o) {

    5522. 

  5522. 			        return (o is Sp) && Equals((Sp) o);

    5523. 

  5523. 			    }

    5524. 

  5524. 			    public bool Equals(Sp other) {

    5525. 

  5525. 			        return other.I == I && other.D == D;

    5526. 

  5526. 			    }

    5527. 

  5527. 			    public override int GetHashCode() {

    5528. 

  5528. 			        return I.GetHashCode() ^ D.GetHashCode();

    5529. 

  5529. 			    }

    5530. 

  5530. 			}

    5531. 

  5531. 			

    5532. 

  5532. 			public struct Ss : IEquatable<Ss> {

    5533. 

  5533. 			    public Ss(S s) {

    5534. 

  5534. 			        Val = s;

    5535. 

  5535. 			    }

    5536. 

  5536. 			

    5537. 

  5537. 			    public S Val;

    5538. 

  5538. 			

    5539. 

  5539. 			    public override bool Equals(object o) {

    5540. 

  5540. 			        return (o is Ss) && Equals((Ss) o);

    5541. 

  5541. 			    }

    5542. 

  5542. 			    public bool Equals(Ss other) {

    5543. 

  5543. 			        return other.Val.Equals(Val);

    5544. 

  5544. 			    }

    5545. 

  5545. 			    public override int GetHashCode() {

    5546. 

  5546. 			        return Val.GetHashCode();

    5547. 

  5547. 			    }

    5548. 

  5548. 			}

    5549. 

  5549. 			

    5550. 

  5550. 			public struct Sc : IEquatable<Sc> {

    5551. 

  5551. 			    public Sc(string s) {

    5552. 

  5552. 			        S = s;

    5553. 

  5553. 			    }

    5554. 

  5554. 			

    5555. 

  5555. 			    public string S;

    5556. 

  5556. 			

    5557. 

  5557. 			    public override bool Equals(object o) {

    5558. 

  5558. 			        return (o is Sc) && Equals((Sc) o);

    5559. 

  5559. 			    }

    5560. 

  5560. 			    public bool Equals(Sc other) {

    5561. 

  5561. 			        return other.S == S;

    5562. 

  5562. 			    }

    5563. 

  5563. 			    public override int GetHashCode() {

    5564. 

  5564. 			        return S.GetHashCode();

    5565. 

  5565. 			    }

    5566. 

  5566. 			}

    5567. 

  5567. 			

    5568. 

  5568. 			public struct Scs : IEquatable<Scs> {

    5569. 

  5569. 			    public Scs(string s, S val) {

    5570. 

  5570. 			        S = s;

    5571. 

  5571. 			        Val = val;

    5572. 

  5572. 			    }

    5573. 

  5573. 			

    5574. 

  5574. 			    public string S;

    5575. 

  5575. 			    public S Val;

    5576. 

  5576. 			

    5577. 

  5577. 			    public override bool Equals(object o) {

    5578. 

  5578. 			        return (o is Scs) && Equals((Scs) o);

    5579. 

  5579. 			    }

    5580. 

  5580. 			    public bool Equals(Scs other) {

    5581. 

  5581. 			        return other.S == S && other.Val.Equals(Val);

    5582. 

  5582. 			    }

    5583. 

  5583. 			    public override int GetHashCode() {

    5584. 

  5584. 			        return S.GetHashCode() ^ Val.GetHashCode();

    5585. 

  5585. 			    }

    5586. 

  5586. 			}

    5587. 

  5587. 			

    5588. 

  5588. 		

    5589. 

  5589. 	}

    5590. 

  5590. 				

    5591. 

  5591. 				//-------- Scenario 1738

    5592. 

  5592. 				namespace Scenario1738{

    5593. 

  5593. 					

    5594. 

  5594. 					public class Test

    5595. 

  5595. 					{

    5596. 

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

    5597. 

  5597. 				    public static Expression check26_object___() {

    5598. 

  5598. 				       if(Main() != 0 ) {

    5599. 

  5599. 				           throw new Exception();

    5600. 

  5600. 				       } else { 

    5601. 

  5601. 				           return Expression.Constant(0);

    5602. 

  5602. 				       }

    5603. 

  5603. 				    }

    5604. 

  5604. 					public     static int Main()

    5605. 

  5605. 					    {

    5606. 

  5606. 					        Ext.StartCapture();

    5607. 

  5607. 					        bool success = false;

    5608. 

  5608. 					        try

    5609. 

  5609. 					        {

    5610. 

  5610. 					            success = check26<object>();

    5611. 

  5611. 					        }

    5612. 

  5612. 					        finally

    5613. 

  5613. 					        {

    5614. 

  5614. 					            Ext.StopCapture();

    5615. 

  5615. 					        }

    5616. 

  5616. 					        return success ? 0 : 1;

    5617. 

  5617. 					    }

    5618. 

  5618. 					

    5619. 

  5619. 					    static bool check26<Tc>() where Tc : class {

    5620. 

  5620. 					        foreach (Tc val in new Tc[] { null, default(Tc) }) {

    5621. 

  5621. 					            if (!check26<Tc>(val)) {

    5622. 

  5622. 					                return false;

    5623. 

  5623. 					            }

    5624. 

  5624. 					        }

    5625. 

  5625. 					        return true;

    5626. 

  5626. 					    }

    5627. 

  5627. 					

    5628. 

  5628. 					    static bool check26<Tc>(Tc val) where Tc : class {

    5629. 

  5629. 					        Expression<Func<Tc>> e =

    5630. 

  5630. 					            Expression.Lambda<Func<Tc>>(

    5631. 

  5631. 					                Expression.Constant(val, typeof(Tc)),

    5632. 

  5632. 					                new System.Collections.Generic.List<ParameterExpression>());

    5633. 

  5633. 					        Func<Tc> f = e.Compile();

    5634. 

  5634. 					        return object.Equals(f(), val);

    5635. 

  5635. 					    }

    5636. 

  5636. 					}

    5637. 

  5637. 				

    5638. 

  5638. 				

    5639. 

  5639. 				public  static class Ext {

    5640. 

  5640. 				    public static void StartCapture() {

    5641. 

  5641. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5642. 

  5642. 				//        m.Invoke(null, new object[] { "test.dll" });

    5643. 

  5643. 				    }

    5644. 

  5644. 				

    5645. 

  5645. 				    public static void StopCapture() {

    5646. 

  5646. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5647. 

  5647. 				//        m.Invoke(null, new object[0]);

    5648. 

  5648. 				    }

    5649. 

  5649. 				

    5650. 

  5650. 				    public static bool IsIntegralOrEnum(Type type) {

    5651. 

  5651. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5652. 

  5652. 				            case TypeCode.Byte:

    5653. 

  5653. 				            case TypeCode.SByte:

    5654. 

  5654. 				            case TypeCode.Int16:

    5655. 

  5655. 				            case TypeCode.Int32:

    5656. 

  5656. 				            case TypeCode.Int64:

    5657. 

  5657. 				            case TypeCode.UInt16:

    5658. 

  5658. 				            case TypeCode.UInt32:

    5659. 

  5659. 				            case TypeCode.UInt64:

    5660. 

  5660. 				                return true;

    5661. 

  5661. 				            default:

    5662. 

  5662. 				                return false;

    5663. 

  5663. 				        }

    5664. 

  5664. 				    }

    5665. 

  5665. 				

    5666. 

  5666. 				    public static bool IsFloating(Type type) {

    5667. 

  5667. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5668. 

  5668. 				            case TypeCode.Single:

    5669. 

  5669. 				            case TypeCode.Double:

    5670. 

  5670. 				                return true;

    5671. 

  5671. 				            default:

    5672. 

  5672. 				                return false;

    5673. 

  5673. 				        }

    5674. 

  5674. 				    }

    5675. 

  5675. 				

    5676. 

  5676. 				    public static Type GetNonNullableType(Type type) {

    5677. 

  5677. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    5678. 

  5678. 				                type.GetGenericArguments()[0] :

    5679. 

  5679. 				                type;

    5680. 

  5680. 				    }

    5681. 

  5681. 				}

    5682. 

  5682. 				

    5683. 

  5683. 			

    5684. 

  5684. 			

    5685. 

  5685. 			

    5686. 

  5686. 			public interface I {

    5687. 

  5687. 			  void M();

    5688. 

  5688. 			}

    5689. 

  5689. 			

    5690. 

  5690. 			public  class C : IEquatable<C>, I {

    5691. 

  5691. 			    void I.M() {

    5692. 

  5692. 			    }

    5693. 

  5693. 			

    5694. 

  5694. 			    public override bool Equals(object o) {

    5695. 

  5695. 			        return o is C && Equals((C) o);

    5696. 

  5696. 			    }

    5697. 

  5697. 			

    5698. 

  5698. 			    public bool Equals(C c) {

    5699. 

  5699. 			        return c != null;

    5700. 

  5700. 			    }

    5701. 

  5701. 			

    5702. 

  5702. 			    public override int GetHashCode() {

    5703. 

  5703. 			        return 0;

    5704. 

  5704. 			    }

    5705. 

  5705. 			}

    5706. 

  5706. 			

    5707. 

  5707. 			public  class D : C, IEquatable<D> {

    5708. 

  5708. 			    public int Val;

    5709. 

  5709. 			    public D() {

    5710. 

  5710. 			    }

    5711. 

  5711. 			    public D(int val) {

    5712. 

  5712. 			        Val = val;

    5713. 

  5713. 			    }

    5714. 

  5714. 			

    5715. 

  5715. 			    public override bool Equals(object o) {

    5716. 

  5716. 			        return o is D && Equals((D) o);

    5717. 

  5717. 			    }

    5718. 

  5718. 			

    5719. 

  5719. 			    public bool Equals(D d) {

    5720. 

  5720. 			        return d != null && d.Val == Val;

    5721. 

  5721. 			    }

    5722. 

  5722. 			

    5723. 

  5723. 			    public override int GetHashCode() {

    5724. 

  5724. 			        return Val;

    5725. 

  5725. 			    }

    5726. 

  5726. 			}

    5727. 

  5727. 			

    5728. 

  5728. 			public enum E {

    5729. 

  5729. 			  A=1, B=2

    5730. 

  5730. 			}

    5731. 

  5731. 			

    5732. 

  5732. 			public enum El : long {

    5733. 

  5733. 			  A, B, C

    5734. 

  5734. 			}

    5735. 

  5735. 			

    5736. 

  5736. 			public struct S : IEquatable<S> {

    5737. 

  5737. 			    public override bool Equals(object o) {

    5738. 

  5738. 			        return (o is S) && Equals((S) o);

    5739. 

  5739. 			    }

    5740. 

  5740. 			    public bool Equals(S other) {

    5741. 

  5741. 			        return true;

    5742. 

  5742. 			    }

    5743. 

  5743. 			    public override int GetHashCode() {

    5744. 

  5744. 			        return 0;

    5745. 

  5745. 			    }

    5746. 

  5746. 			}

    5747. 

  5747. 			

    5748. 

  5748. 			public struct Sp : IEquatable<Sp> {

    5749. 

  5749. 			    public Sp(int i, double d) {

    5750. 

  5750. 			        I = i;

    5751. 

  5751. 			        D = d;

    5752. 

  5752. 			    }

    5753. 

  5753. 			

    5754. 

  5754. 			    public int I;

    5755. 

  5755. 			    public double D;

    5756. 

  5756. 			

    5757. 

  5757. 			    public override bool Equals(object o) {

    5758. 

  5758. 			        return (o is Sp) && Equals((Sp) o);

    5759. 

  5759. 			    }

    5760. 

  5760. 			    public bool Equals(Sp other) {

    5761. 

  5761. 			        return other.I == I && other.D == D;

    5762. 

  5762. 			    }

    5763. 

  5763. 			    public override int GetHashCode() {

    5764. 

  5764. 			        return I.GetHashCode() ^ D.GetHashCode();

    5765. 

  5765. 			    }

    5766. 

  5766. 			}

    5767. 

  5767. 			

    5768. 

  5768. 			public struct Ss : IEquatable<Ss> {

    5769. 

  5769. 			    public Ss(S s) {

    5770. 

  5770. 			        Val = s;

    5771. 

  5771. 			    }

    5772. 

  5772. 			

    5773. 

  5773. 			    public S Val;

    5774. 

  5774. 			

    5775. 

  5775. 			    public override bool Equals(object o) {

    5776. 

  5776. 			        return (o is Ss) && Equals((Ss) o);

    5777. 

  5777. 			    }

    5778. 

  5778. 			    public bool Equals(Ss other) {

    5779. 

  5779. 			        return other.Val.Equals(Val);

    5780. 

  5780. 			    }

    5781. 

  5781. 			    public override int GetHashCode() {

    5782. 

  5782. 			        return Val.GetHashCode();

    5783. 

  5783. 			    }

    5784. 

  5784. 			}

    5785. 

  5785. 			

    5786. 

  5786. 			public struct Sc : IEquatable<Sc> {

    5787. 

  5787. 			    public Sc(string s) {

    5788. 

  5788. 			        S = s;

    5789. 

  5789. 			    }

    5790. 

  5790. 			

    5791. 

  5791. 			    public string S;

    5792. 

  5792. 			

    5793. 

  5793. 			    public override bool Equals(object o) {

    5794. 

  5794. 			        return (o is Sc) && Equals((Sc) o);

    5795. 

  5795. 			    }

    5796. 

  5796. 			    public bool Equals(Sc other) {

    5797. 

  5797. 			        return other.S == S;

    5798. 

  5798. 			    }

    5799. 

  5799. 			    public override int GetHashCode() {

    5800. 

  5800. 			        return S.GetHashCode();

    5801. 

  5801. 			    }

    5802. 

  5802. 			}

    5803. 

  5803. 			

    5804. 

  5804. 			public struct Scs : IEquatable<Scs> {

    5805. 

  5805. 			    public Scs(string s, S val) {

    5806. 

  5806. 			        S = s;

    5807. 

  5807. 			        Val = val;

    5808. 

  5808. 			    }

    5809. 

  5809. 			

    5810. 

  5810. 			    public string S;

    5811. 

  5811. 			    public S Val;

    5812. 

  5812. 			

    5813. 

  5813. 			    public override bool Equals(object o) {

    5814. 

  5814. 			        return (o is Scs) && Equals((Scs) o);

    5815. 

  5815. 			    }

    5816. 

  5816. 			    public bool Equals(Scs other) {

    5817. 

  5817. 			        return other.S == S && other.Val.Equals(Val);

    5818. 

  5818. 			    }

    5819. 

  5819. 			    public override int GetHashCode() {

    5820. 

  5820. 			        return S.GetHashCode() ^ Val.GetHashCode();

    5821. 

  5821. 			    }

    5822. 

  5822. 			}

    5823. 

  5823. 			

    5824. 

  5824. 		

    5825. 

  5825. 	}

    5826. 

  5826. 				

    5827. 

  5827. 				//-------- Scenario 1739

    5828. 

  5828. 				namespace Scenario1739{

    5829. 

  5829. 					

    5830. 

  5830. 					public class Test

    5831. 

  5831. 					{

    5832. 

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

    5833. 

  5833. 				    public static Expression check26_C___() {

    5834. 

  5834. 				       if(Main() != 0 ) {

    5835. 

  5835. 				           throw new Exception();

    5836. 

  5836. 				       } else { 

    5837. 

  5837. 				           return Expression.Constant(0);

    5838. 

  5838. 				       }

    5839. 

  5839. 				    }

    5840. 

  5840. 					public     static int Main()

    5841. 

  5841. 					    {

    5842. 

  5842. 					        Ext.StartCapture();

    5843. 

  5843. 					        bool success = false;

    5844. 

  5844. 					        try

    5845. 

  5845. 					        {

    5846. 

  5846. 					            success = check26<C>();

    5847. 

  5847. 					        }

    5848. 

  5848. 					        finally

    5849. 

  5849. 					        {

    5850. 

  5850. 					            Ext.StopCapture();

    5851. 

  5851. 					        }

    5852. 

  5852. 					        return success ? 0 : 1;

    5853. 

  5853. 					    }

    5854. 

  5854. 					

    5855. 

  5855. 					    static bool check26<Tc>() where Tc : class {

    5856. 

  5856. 					        foreach (Tc val in new Tc[] { null, default(Tc) }) {

    5857. 

  5857. 					            if (!check26<Tc>(val)) {

    5858. 

  5858. 					                return false;

    5859. 

  5859. 					            }

    5860. 

  5860. 					        }

    5861. 

  5861. 					        return true;

    5862. 

  5862. 					    }

    5863. 

  5863. 					

    5864. 

  5864. 					    static bool check26<Tc>(Tc val) where Tc : class {

    5865. 

  5865. 					        Expression<Func<Tc>> e =

    5866. 

  5866. 					            Expression.Lambda<Func<Tc>>(

    5867. 

  5867. 					                Expression.Constant(val, typeof(Tc)),

    5868. 

  5868. 					                new System.Collections.Generic.List<ParameterExpression>());

    5869. 

  5869. 					        Func<Tc> f = e.Compile();

    5870. 

  5870. 					        return object.Equals(f(), val);

    5871. 

  5871. 					    }

    5872. 

  5872. 					}

    5873. 

  5873. 				

    5874. 

  5874. 				

    5875. 

  5875. 				public  static class Ext {

    5876. 

  5876. 				    public static void StartCapture() {

    5877. 

  5877. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5878. 

  5878. 				//        m.Invoke(null, new object[] { "test.dll" });

    5879. 

  5879. 				    }

    5880. 

  5880. 				

    5881. 

  5881. 				    public static void StopCapture() {

    5882. 

  5882. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    5883. 

  5883. 				//        m.Invoke(null, new object[0]);

    5884. 

  5884. 				    }

    5885. 

  5885. 				

    5886. 

  5886. 				    public static bool IsIntegralOrEnum(Type type) {

    5887. 

  5887. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5888. 

  5888. 				            case TypeCode.Byte:

    5889. 

  5889. 				            case TypeCode.SByte:

    5890. 

  5890. 				            case TypeCode.Int16:

    5891. 

  5891. 				            case TypeCode.Int32:

    5892. 

  5892. 				            case TypeCode.Int64:

    5893. 

  5893. 				            case TypeCode.UInt16:

    5894. 

  5894. 				            case TypeCode.UInt32:

    5895. 

  5895. 				            case TypeCode.UInt64:

    5896. 

  5896. 				                return true;

    5897. 

  5897. 				            default:

    5898. 

  5898. 				                return false;

    5899. 

  5899. 				        }

    5900. 

  5900. 				    }

    5901. 

  5901. 				

    5902. 

  5902. 				    public static bool IsFloating(Type type) {

    5903. 

  5903. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    5904. 

  5904. 				            case TypeCode.Single:

    5905. 

  5905. 				            case TypeCode.Double:

    5906. 

  5906. 				                return true;

    5907. 

  5907. 				            default:

    5908. 

  5908. 				                return false;

    5909. 

  5909. 				        }

    5910. 

  5910. 				    }

    5911. 

  5911. 				

    5912. 

  5912. 				    public static Type GetNonNullableType(Type type) {

    5913. 

  5913. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    5914. 

  5914. 				                type.GetGenericArguments()[0] :

    5915. 

  5915. 				                type;

    5916. 

  5916. 				    }

    5917. 

  5917. 				}

    5918. 

  5918. 				

    5919. 

  5919. 			

    5920. 

  5920. 			

    5921. 

  5921. 			

    5922. 

  5922. 			public interface I {

    5923. 

  5923. 			  void M();

    5924. 

  5924. 			}

    5925. 

  5925. 			

    5926. 

  5926. 			public  class C : IEquatable<C>, I {

    5927. 

  5927. 			    void I.M() {

    5928. 

  5928. 			    }

    5929. 

  5929. 			

    5930. 

  5930. 			    public override bool Equals(object o) {

    5931. 

  5931. 			        return o is C && Equals((C) o);

    5932. 

  5932. 			    }

    5933. 

  5933. 			

    5934. 

  5934. 			    public bool Equals(C c) {

    5935. 

  5935. 			        return c != null;

    5936. 

  5936. 			    }

    5937. 

  5937. 			

    5938. 

  5938. 			    public override int GetHashCode() {

    5939. 

  5939. 			        return 0;

    5940. 

  5940. 			    }

    5941. 

  5941. 			}

    5942. 

  5942. 			

    5943. 

  5943. 			public  class D : C, IEquatable<D> {

    5944. 

  5944. 			    public int Val;

    5945. 

  5945. 			    public D() {

    5946. 

  5946. 			    }

    5947. 

  5947. 			    public D(int val) {

    5948. 

  5948. 			        Val = val;

    5949. 

  5949. 			    }

    5950. 

  5950. 			

    5951. 

  5951. 			    public override bool Equals(object o) {

    5952. 

  5952. 			        return o is D && Equals((D) o);

    5953. 

  5953. 			    }

    5954. 

  5954. 			

    5955. 

  5955. 			    public bool Equals(D d) {

    5956. 

  5956. 			        return d != null && d.Val == Val;

    5957. 

  5957. 			    }

    5958. 

  5958. 			

    5959. 

  5959. 			    public override int GetHashCode() {

    5960. 

  5960. 			        return Val;

    5961. 

  5961. 			    }

    5962. 

  5962. 			}

    5963. 

  5963. 			

    5964. 

  5964. 			public enum E {

    5965. 

  5965. 			  A=1, B=2

    5966. 

  5966. 			}

    5967. 

  5967. 			

    5968. 

  5968. 			public enum El : long {

    5969. 

  5969. 			  A, B, C

    5970. 

  5970. 			}

    5971. 

  5971. 			

    5972. 

  5972. 			public struct S : IEquatable<S> {

    5973. 

  5973. 			    public override bool Equals(object o) {

    5974. 

  5974. 			        return (o is S) && Equals((S) o);

    5975. 

  5975. 			    }

    5976. 

  5976. 			    public bool Equals(S other) {

    5977. 

  5977. 			        return true;

    5978. 

  5978. 			    }

    5979. 

  5979. 			    public override int GetHashCode() {

    5980. 

  5980. 			        return 0;

    5981. 

  5981. 			    }

    5982. 

  5982. 			}

    5983. 

  5983. 			

    5984. 

  5984. 			public struct Sp : IEquatable<Sp> {

    5985. 

  5985. 			    public Sp(int i, double d) {

    5986. 

  5986. 			        I = i;

    5987. 

  5987. 			        D = d;

    5988. 

  5988. 			    }

    5989. 

  5989. 			

    5990. 

  5990. 			    public int I;

    5991. 

  5991. 			    public double D;

    5992. 

  5992. 			

    5993. 

  5993. 			    public override bool Equals(object o) {

    5994. 

  5994. 			        return (o is Sp) && Equals((Sp) o);

    5995. 

  5995. 			    }

    5996. 

  5996. 			    public bool Equals(Sp other) {

    5997. 

  5997. 			        return other.I == I && other.D == D;

    5998. 

  5998. 			    }

    5999. 

  5999. 			    public override int GetHashCode() {

    6000. 

  6000. 			        return I.GetHashCode() ^ D.GetHashCode();

    6001. 

  6001. 			    }

    6002. 

  6002. 			}

    6003. 

  6003. 			

    6004. 

  6004. 			public struct Ss : IEquatable<Ss> {

    6005. 

  6005. 			    public Ss(S s) {

    6006. 

  6006. 			        Val = s;

    6007. 

  6007. 			    }

    6008. 

  6008. 			

    6009. 

  6009. 			    public S Val;

    6010. 

  6010. 			

    6011. 

  6011. 			    public override bool Equals(object o) {

    6012. 

  6012. 			        return (o is Ss) && Equals((Ss) o);

    6013. 

  6013. 			    }

    6014. 

  6014. 			    public bool Equals(Ss other) {

    6015. 

  6015. 			        return other.Val.Equals(Val);

    6016. 

  6016. 			    }

    6017. 

  6017. 			    public override int GetHashCode() {

    6018. 

  6018. 			        return Val.GetHashCode();

    6019. 

  6019. 			    }

    6020. 

  6020. 			}

    6021. 

  6021. 			

    6022. 

  6022. 			public struct Sc : IEquatable<Sc> {

    6023. 

  6023. 			    public Sc(string s) {

    6024. 

  6024. 			        S = s;

    6025. 

  6025. 			    }

    6026. 

  6026. 			

    6027. 

  6027. 			    public string S;

    6028. 

  6028. 			

    6029. 

  6029. 			    public override bool Equals(object o) {

    6030. 

  6030. 			        return (o is Sc) && Equals((Sc) o);

    6031. 

  6031. 			    }

    6032. 

  6032. 			    public bool Equals(Sc other) {

    6033. 

  6033. 			        return other.S == S;

    6034. 

  6034. 			    }

    6035. 

  6035. 			    public override int GetHashCode() {

    6036. 

  6036. 			        return S.GetHashCode();

    6037. 

  6037. 			    }

    6038. 

  6038. 			}

    6039. 

  6039. 			

    6040. 

  6040. 			public struct Scs : IEquatable<Scs> {

    6041. 

  6041. 			    public Scs(string s, S val) {

    6042. 

  6042. 			        S = s;

    6043. 

  6043. 			        Val = val;

    6044. 

  6044. 			    }

    6045. 

  6045. 			

    6046. 

  6046. 			    public string S;

    6047. 

  6047. 			    public S Val;

    6048. 

  6048. 			

    6049. 

  6049. 			    public override bool Equals(object o) {

    6050. 

  6050. 			        return (o is Scs) && Equals((Scs) o);

    6051. 

  6051. 			    }

    6052. 

  6052. 			    public bool Equals(Scs other) {

    6053. 

  6053. 			        return other.S == S && other.Val.Equals(Val);

    6054. 

  6054. 			    }

    6055. 

  6055. 			    public override int GetHashCode() {

    6056. 

  6056. 			        return S.GetHashCode() ^ Val.GetHashCode();

    6057. 

  6057. 			    }

    6058. 

  6058. 			}

    6059. 

  6059. 			

    6060. 

  6060. 		

    6061. 

  6061. 	}

    6062. 

  6062. 				

    6063. 

  6063. 				//-------- Scenario 1740

    6064. 

  6064. 				namespace Scenario1740{

    6065. 

  6065. 					

    6066. 

  6066. 					public class Test

    6067. 

  6067. 					{

    6068. 

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

    6069. 

  6069. 				    public static Expression check27_object___() {

    6070. 

  6070. 				       if(Main() != 0 ) {

    6071. 

  6071. 				           throw new Exception();

    6072. 

  6072. 				       } else { 

    6073. 

  6073. 				           return Expression.Constant(0);

    6074. 

  6074. 				       }

    6075. 

  6075. 				    }

    6076. 

  6076. 					public     static int Main()

    6077. 

  6077. 					    {

    6078. 

  6078. 					        Ext.StartCapture();

    6079. 

  6079. 					        bool success = false;

    6080. 

  6080. 					        try

    6081. 

  6081. 					        {

    6082. 

  6082. 					            success = check27<object>();

    6083. 

  6083. 					        }

    6084. 

  6084. 					        finally

    6085. 

  6085. 					        {

    6086. 

  6086. 					            Ext.StopCapture();

    6087. 

  6087. 					        }

    6088. 

  6088. 					        return success ? 0 : 1;

    6089. 

  6089. 					    }

    6090. 

  6090. 					

    6091. 

  6091. 					    static bool check27<Tcn>() where Tcn : class, new() {

    6092. 

  6092. 					        foreach (Tcn val in new Tcn[] { null, default(Tcn), new Tcn() }) {

    6093. 

  6093. 					            if (!check27<Tcn>(val)) {

    6094. 

  6094. 					                return false;

    6095. 

  6095. 					            }

    6096. 

  6096. 					        }

    6097. 

  6097. 					        return true;

    6098. 

  6098. 					    }

    6099. 

  6099. 					

    6100. 

  6100. 					    static bool check27<Tcn>(Tcn val) where Tcn : class, new() {

    6101. 

  6101. 					        Expression<Func<Tcn>> e =

    6102. 

  6102. 					            Expression.Lambda<Func<Tcn>>(

    6103. 

  6103. 					                Expression.Constant(val, typeof(Tcn)),

    6104. 

  6104. 					                new System.Collections.Generic.List<ParameterExpression>());

    6105. 

  6105. 					        Func<Tcn> f = e.Compile();

    6106. 

  6106. 					        return object.Equals(f(), val);

    6107. 

  6107. 					    }

    6108. 

  6108. 					}

    6109. 

  6109. 				

    6110. 

  6110. 				

    6111. 

  6111. 				public  static class Ext {

    6112. 

  6112. 				    public static void StartCapture() {

    6113. 

  6113. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6114. 

  6114. 				//        m.Invoke(null, new object[] { "test.dll" });

    6115. 

  6115. 				    }

    6116. 

  6116. 				

    6117. 

  6117. 				    public static void StopCapture() {

    6118. 

  6118. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6119. 

  6119. 				//        m.Invoke(null, new object[0]);

    6120. 

  6120. 				    }

    6121. 

  6121. 				

    6122. 

  6122. 				    public static bool IsIntegralOrEnum(Type type) {

    6123. 

  6123. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6124. 

  6124. 				            case TypeCode.Byte:

    6125. 

  6125. 				            case TypeCode.SByte:

    6126. 

  6126. 				            case TypeCode.Int16:

    6127. 

  6127. 				            case TypeCode.Int32:

    6128. 

  6128. 				            case TypeCode.Int64:

    6129. 

  6129. 				            case TypeCode.UInt16:

    6130. 

  6130. 				            case TypeCode.UInt32:

    6131. 

  6131. 				            case TypeCode.UInt64:

    6132. 

  6132. 				                return true;

    6133. 

  6133. 				            default:

    6134. 

  6134. 				                return false;

    6135. 

  6135. 				        }

    6136. 

  6136. 				    }

    6137. 

  6137. 				

    6138. 

  6138. 				    public static bool IsFloating(Type type) {

    6139. 

  6139. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6140. 

  6140. 				            case TypeCode.Single:

    6141. 

  6141. 				            case TypeCode.Double:

    6142. 

  6142. 				                return true;

    6143. 

  6143. 				            default:

    6144. 

  6144. 				                return false;

    6145. 

  6145. 				        }

    6146. 

  6146. 				    }

    6147. 

  6147. 				

    6148. 

  6148. 				    public static Type GetNonNullableType(Type type) {

    6149. 

  6149. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    6150. 

  6150. 				                type.GetGenericArguments()[0] :

    6151. 

  6151. 				                type;

    6152. 

  6152. 				    }

    6153. 

  6153. 				}

    6154. 

  6154. 				

    6155. 

  6155. 			

    6156. 

  6156. 			

    6157. 

  6157. 			

    6158. 

  6158. 			public interface I {

    6159. 

  6159. 			  void M();

    6160. 

  6160. 			}

    6161. 

  6161. 			

    6162. 

  6162. 			public  class C : IEquatable<C>, I {

    6163. 

  6163. 			    void I.M() {

    6164. 

  6164. 			    }

    6165. 

  6165. 			

    6166. 

  6166. 			    public override bool Equals(object o) {

    6167. 

  6167. 			        return o is C && Equals((C) o);

    6168. 

  6168. 			    }

    6169. 

  6169. 			

    6170. 

  6170. 			    public bool Equals(C c) {

    6171. 

  6171. 			        return c != null;

    6172. 

  6172. 			    }

    6173. 

  6173. 			

    6174. 

  6174. 			    public override int GetHashCode() {

    6175. 

  6175. 			        return 0;

    6176. 

  6176. 			    }

    6177. 

  6177. 			}

    6178. 

  6178. 			

    6179. 

  6179. 			public  class D : C, IEquatable<D> {

    6180. 

  6180. 			    public int Val;

    6181. 

  6181. 			    public D() {

    6182. 

  6182. 			    }

    6183. 

  6183. 			    public D(int val) {

    6184. 

  6184. 			        Val = val;

    6185. 

  6185. 			    }

    6186. 

  6186. 			

    6187. 

  6187. 			    public override bool Equals(object o) {

    6188. 

  6188. 			        return o is D && Equals((D) o);

    6189. 

  6189. 			    }

    6190. 

  6190. 			

    6191. 

  6191. 			    public bool Equals(D d) {

    6192. 

  6192. 			        return d != null && d.Val == Val;

    6193. 

  6193. 			    }

    6194. 

  6194. 			

    6195. 

  6195. 			    public override int GetHashCode() {

    6196. 

  6196. 			        return Val;

    6197. 

  6197. 			    }

    6198. 

  6198. 			}

    6199. 

  6199. 			

    6200. 

  6200. 			public enum E {

    6201. 

  6201. 			  A=1, B=2

    6202. 

  6202. 			}

    6203. 

  6203. 			

    6204. 

  6204. 			public enum El : long {

    6205. 

  6205. 			  A, B, C

    6206. 

  6206. 			}

    6207. 

  6207. 			

    6208. 

  6208. 			public struct S : IEquatable<S> {

    6209. 

  6209. 			    public override bool Equals(object o) {

    6210. 

  6210. 			        return (o is S) && Equals((S) o);

    6211. 

  6211. 			    }

    6212. 

  6212. 			    public bool Equals(S other) {

    6213. 

  6213. 			        return true;

    6214. 

  6214. 			    }

    6215. 

  6215. 			    public override int GetHashCode() {

    6216. 

  6216. 			        return 0;

    6217. 

  6217. 			    }

    6218. 

  6218. 			}

    6219. 

  6219. 			

    6220. 

  6220. 			public struct Sp : IEquatable<Sp> {

    6221. 

  6221. 			    public Sp(int i, double d) {

    6222. 

  6222. 			        I = i;

    6223. 

  6223. 			        D = d;

    6224. 

  6224. 			    }

    6225. 

  6225. 			

    6226. 

  6226. 			    public int I;

    6227. 

  6227. 			    public double D;

    6228. 

  6228. 			

    6229. 

  6229. 			    public override bool Equals(object o) {

    6230. 

  6230. 			        return (o is Sp) && Equals((Sp) o);

    6231. 

  6231. 			    }

    6232. 

  6232. 			    public bool Equals(Sp other) {

    6233. 

  6233. 			        return other.I == I && other.D == D;

    6234. 

  6234. 			    }

    6235. 

  6235. 			    public override int GetHashCode() {

    6236. 

  6236. 			        return I.GetHashCode() ^ D.GetHashCode();

    6237. 

  6237. 			    }

    6238. 

  6238. 			}

    6239. 

  6239. 			

    6240. 

  6240. 			public struct Ss : IEquatable<Ss> {

    6241. 

  6241. 			    public Ss(S s) {

    6242. 

  6242. 			        Val = s;

    6243. 

  6243. 			    }

    6244. 

  6244. 			

    6245. 

  6245. 			    public S Val;

    6246. 

  6246. 			

    6247. 

  6247. 			    public override bool Equals(object o) {

    6248. 

  6248. 			        return (o is Ss) && Equals((Ss) o);

    6249. 

  6249. 			    }

    6250. 

  6250. 			    public bool Equals(Ss other) {

    6251. 

  6251. 			        return other.Val.Equals(Val);

    6252. 

  6252. 			    }

    6253. 

  6253. 			    public override int GetHashCode() {

    6254. 

  6254. 			        return Val.GetHashCode();

    6255. 

  6255. 			    }

    6256. 

  6256. 			}

    6257. 

  6257. 			

    6258. 

  6258. 			public struct Sc : IEquatable<Sc> {

    6259. 

  6259. 			    public Sc(string s) {

    6260. 

  6260. 			        S = s;

    6261. 

  6261. 			    }

    6262. 

  6262. 			

    6263. 

  6263. 			    public string S;

    6264. 

  6264. 			

    6265. 

  6265. 			    public override bool Equals(object o) {

    6266. 

  6266. 			        return (o is Sc) && Equals((Sc) o);

    6267. 

  6267. 			    }

    6268. 

  6268. 			    public bool Equals(Sc other) {

    6269. 

  6269. 			        return other.S == S;

    6270. 

  6270. 			    }

    6271. 

  6271. 			    public override int GetHashCode() {

    6272. 

  6272. 			        return S.GetHashCode();

    6273. 

  6273. 			    }

    6274. 

  6274. 			}

    6275. 

  6275. 			

    6276. 

  6276. 			public struct Scs : IEquatable<Scs> {

    6277. 

  6277. 			    public Scs(string s, S val) {

    6278. 

  6278. 			        S = s;

    6279. 

  6279. 			        Val = val;

    6280. 

  6280. 			    }

    6281. 

  6281. 			

    6282. 

  6282. 			    public string S;

    6283. 

  6283. 			    public S Val;

    6284. 

  6284. 			

    6285. 

  6285. 			    public override bool Equals(object o) {

    6286. 

  6286. 			        return (o is Scs) && Equals((Scs) o);

    6287. 

  6287. 			    }

    6288. 

  6288. 			    public bool Equals(Scs other) {

    6289. 

  6289. 			        return other.S == S && other.Val.Equals(Val);

    6290. 

  6290. 			    }

    6291. 

  6291. 			    public override int GetHashCode() {

    6292. 

  6292. 			        return S.GetHashCode() ^ Val.GetHashCode();

    6293. 

  6293. 			    }

    6294. 

  6294. 			}

    6295. 

  6295. 			

    6296. 

  6296. 		

    6297. 

  6297. 	}

    6298. 

  6298. 				

    6299. 

  6299. 				//-------- Scenario 1741

    6300. 

  6300. 				namespace Scenario1741{

    6301. 

  6301. 					

    6302. 

  6302. 					public class Test

    6303. 

  6303. 					{

    6304. 

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

    6305. 

  6305. 				    public static Expression check27_C___() {

    6306. 

  6306. 				       if(Main() != 0 ) {

    6307. 

  6307. 				           throw new Exception();

    6308. 

  6308. 				       } else { 

    6309. 

  6309. 				           return Expression.Constant(0);

    6310. 

  6310. 				       }

    6311. 

  6311. 				    }

    6312. 

  6312. 					public     static int Main()

    6313. 

  6313. 					    {

    6314. 

  6314. 					        Ext.StartCapture();

    6315. 

  6315. 					        bool success = false;

    6316. 

  6316. 					        try

    6317. 

  6317. 					        {

    6318. 

  6318. 					            success = check27<C>();

    6319. 

  6319. 					        }

    6320. 

  6320. 					        finally

    6321. 

  6321. 					        {

    6322. 

  6322. 					            Ext.StopCapture();

    6323. 

  6323. 					        }

    6324. 

  6324. 					        return success ? 0 : 1;

    6325. 

  6325. 					    }

    6326. 

  6326. 					

    6327. 

  6327. 					    static bool check27<Tcn>() where Tcn : class, new() {

    6328. 

  6328. 					        foreach (Tcn val in new Tcn[] { null, default(Tcn), new Tcn() }) {

    6329. 

  6329. 					            if (!check27<Tcn>(val)) {

    6330. 

  6330. 					                return false;

    6331. 

  6331. 					            }

    6332. 

  6332. 					        }

    6333. 

  6333. 					        return true;

    6334. 

  6334. 					    }

    6335. 

  6335. 					

    6336. 

  6336. 					    static bool check27<Tcn>(Tcn val) where Tcn : class, new() {

    6337. 

  6337. 					        Expression<Func<Tcn>> e =

    6338. 

  6338. 					            Expression.Lambda<Func<Tcn>>(

    6339. 

  6339. 					                Expression.Constant(val, typeof(Tcn)),

    6340. 

  6340. 					                new System.Collections.Generic.List<ParameterExpression>());

    6341. 

  6341. 					        Func<Tcn> f = e.Compile();

    6342. 

  6342. 					        return object.Equals(f(), val);

    6343. 

  6343. 					    }

    6344. 

  6344. 					}

    6345. 

  6345. 				

    6346. 

  6346. 				

    6347. 

  6347. 				public  static class Ext {

    6348. 

  6348. 				    public static void StartCapture() {

    6349. 

  6349. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6350. 

  6350. 				//        m.Invoke(null, new object[] { "test.dll" });

    6351. 

  6351. 				    }

    6352. 

  6352. 				

    6353. 

  6353. 				    public static void StopCapture() {

    6354. 

  6354. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6355. 

  6355. 				//        m.Invoke(null, new object[0]);

    6356. 

  6356. 				    }

    6357. 

  6357. 				

    6358. 

  6358. 				    public static bool IsIntegralOrEnum(Type type) {

    6359. 

  6359. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6360. 

  6360. 				            case TypeCode.Byte:

    6361. 

  6361. 				            case TypeCode.SByte:

    6362. 

  6362. 				            case TypeCode.Int16:

    6363. 

  6363. 				            case TypeCode.Int32:

    6364. 

  6364. 				            case TypeCode.Int64:

    6365. 

  6365. 				            case TypeCode.UInt16:

    6366. 

  6366. 				            case TypeCode.UInt32:

    6367. 

  6367. 				            case TypeCode.UInt64:

    6368. 

  6368. 				                return true;

    6369. 

  6369. 				            default:

    6370. 

  6370. 				                return false;

    6371. 

  6371. 				        }

    6372. 

  6372. 				    }

    6373. 

  6373. 				

    6374. 

  6374. 				    public static bool IsFloating(Type type) {

    6375. 

  6375. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6376. 

  6376. 				            case TypeCode.Single:

    6377. 

  6377. 				            case TypeCode.Double:

    6378. 

  6378. 				                return true;

    6379. 

  6379. 				            default:

    6380. 

  6380. 				                return false;

    6381. 

  6381. 				        }

    6382. 

  6382. 				    }

    6383. 

  6383. 				

    6384. 

  6384. 				    public static Type GetNonNullableType(Type type) {

    6385. 

  6385. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    6386. 

  6386. 				                type.GetGenericArguments()[0] :

    6387. 

  6387. 				                type;

    6388. 

  6388. 				    }

    6389. 

  6389. 				}

    6390. 

  6390. 				

    6391. 

  6391. 			

    6392. 

  6392. 			

    6393. 

  6393. 			

    6394. 

  6394. 			public interface I {

    6395. 

  6395. 			  void M();

    6396. 

  6396. 			}

    6397. 

  6397. 			

    6398. 

  6398. 			public  class C : IEquatable<C>, I {

    6399. 

  6399. 			    void I.M() {

    6400. 

  6400. 			    }

    6401. 

  6401. 			

    6402. 

  6402. 			    public override bool Equals(object o) {

    6403. 

  6403. 			        return o is C && Equals((C) o);

    6404. 

  6404. 			    }

    6405. 

  6405. 			

    6406. 

  6406. 			    public bool Equals(C c) {

    6407. 

  6407. 			        return c != null;

    6408. 

  6408. 			    }

    6409. 

  6409. 			

    6410. 

  6410. 			    public override int GetHashCode() {

    6411. 

  6411. 			        return 0;

    6412. 

  6412. 			    }

    6413. 

  6413. 			}

    6414. 

  6414. 			

    6415. 

  6415. 			public  class D : C, IEquatable<D> {

    6416. 

  6416. 			    public int Val;

    6417. 

  6417. 			    public D() {

    6418. 

  6418. 			    }

    6419. 

  6419. 			    public D(int val) {

    6420. 

  6420. 			        Val = val;

    6421. 

  6421. 			    }

    6422. 

  6422. 			

    6423. 

  6423. 			    public override bool Equals(object o) {

    6424. 

  6424. 			        return o is D && Equals((D) o);

    6425. 

  6425. 			    }

    6426. 

  6426. 			

    6427. 

  6427. 			    public bool Equals(D d) {

    6428. 

  6428. 			        return d != null && d.Val == Val;

    6429. 

  6429. 			    }

    6430. 

  6430. 			

    6431. 

  6431. 			    public override int GetHashCode() {

    6432. 

  6432. 			        return Val;

    6433. 

  6433. 			    }

    6434. 

  6434. 			}

    6435. 

  6435. 			

    6436. 

  6436. 			public enum E {

    6437. 

  6437. 			  A=1, B=2

    6438. 

  6438. 			}

    6439. 

  6439. 			

    6440. 

  6440. 			public enum El : long {

    6441. 

  6441. 			  A, B, C

    6442. 

  6442. 			}

    6443. 

  6443. 			

    6444. 

  6444. 			public struct S : IEquatable<S> {

    6445. 

  6445. 			    public override bool Equals(object o) {

    6446. 

  6446. 			        return (o is S) && Equals((S) o);

    6447. 

  6447. 			    }

    6448. 

  6448. 			    public bool Equals(S other) {

    6449. 

  6449. 			        return true;

    6450. 

  6450. 			    }

    6451. 

  6451. 			    public override int GetHashCode() {

    6452. 

  6452. 			        return 0;

    6453. 

  6453. 			    }

    6454. 

  6454. 			}

    6455. 

  6455. 			

    6456. 

  6456. 			public struct Sp : IEquatable<Sp> {

    6457. 

  6457. 			    public Sp(int i, double d) {

    6458. 

  6458. 			        I = i;

    6459. 

  6459. 			        D = d;

    6460. 

  6460. 			    }

    6461. 

  6461. 			

    6462. 

  6462. 			    public int I;

    6463. 

  6463. 			    public double D;

    6464. 

  6464. 			

    6465. 

  6465. 			    public override bool Equals(object o) {

    6466. 

  6466. 			        return (o is Sp) && Equals((Sp) o);

    6467. 

  6467. 			    }

    6468. 

  6468. 			    public bool Equals(Sp other) {

    6469. 

  6469. 			        return other.I == I && other.D == D;

    6470. 

  6470. 			    }

    6471. 

  6471. 			    public override int GetHashCode() {

    6472. 

  6472. 			        return I.GetHashCode() ^ D.GetHashCode();

    6473. 

  6473. 			    }

    6474. 

  6474. 			}

    6475. 

  6475. 			

    6476. 

  6476. 			public struct Ss : IEquatable<Ss> {

    6477. 

  6477. 			    public Ss(S s) {

    6478. 

  6478. 			        Val = s;

    6479. 

  6479. 			    }

    6480. 

  6480. 			

    6481. 

  6481. 			    public S Val;

    6482. 

  6482. 			

    6483. 

  6483. 			    public override bool Equals(object o) {

    6484. 

  6484. 			        return (o is Ss) && Equals((Ss) o);

    6485. 

  6485. 			    }

    6486. 

  6486. 			    public bool Equals(Ss other) {

    6487. 

  6487. 			        return other.Val.Equals(Val);

    6488. 

  6488. 			    }

    6489. 

  6489. 			    public override int GetHashCode() {

    6490. 

  6490. 			        return Val.GetHashCode();

    6491. 

  6491. 			    }

    6492. 

  6492. 			}

    6493. 

  6493. 			

    6494. 

  6494. 			public struct Sc : IEquatable<Sc> {

    6495. 

  6495. 			    public Sc(string s) {

    6496. 

  6496. 			        S = s;

    6497. 

  6497. 			    }

    6498. 

  6498. 			

    6499. 

  6499. 			    public string S;

    6500. 

  6500. 			

    6501. 

  6501. 			    public override bool Equals(object o) {

    6502. 

  6502. 			        return (o is Sc) && Equals((Sc) o);

    6503. 

  6503. 			    }

    6504. 

  6504. 			    public bool Equals(Sc other) {

    6505. 

  6505. 			        return other.S == S;

    6506. 

  6506. 			    }

    6507. 

  6507. 			    public override int GetHashCode() {

    6508. 

  6508. 			        return S.GetHashCode();

    6509. 

  6509. 			    }

    6510. 

  6510. 			}

    6511. 

  6511. 			

    6512. 

  6512. 			public struct Scs : IEquatable<Scs> {

    6513. 

  6513. 			    public Scs(string s, S val) {

    6514. 

  6514. 			        S = s;

    6515. 

  6515. 			        Val = val;

    6516. 

  6516. 			    }

    6517. 

  6517. 			

    6518. 

  6518. 			    public string S;

    6519. 

  6519. 			    public S Val;

    6520. 

  6520. 			

    6521. 

  6521. 			    public override bool Equals(object o) {

    6522. 

  6522. 			        return (o is Scs) && Equals((Scs) o);

    6523. 

  6523. 			    }

    6524. 

  6524. 			    public bool Equals(Scs other) {

    6525. 

  6525. 			        return other.S == S && other.Val.Equals(Val);

    6526. 

  6526. 			    }

    6527. 

  6527. 			    public override int GetHashCode() {

    6528. 

  6528. 			        return S.GetHashCode() ^ Val.GetHashCode();

    6529. 

  6529. 			    }

    6530. 

  6530. 			}

    6531. 

  6531. 			

    6532. 

  6532. 		

    6533. 

  6533. 	}

    6534. 

  6534. 				

    6535. 

  6535. 				//-------- Scenario 1742

    6536. 

  6536. 				namespace Scenario1742{

    6537. 

  6537. 					

    6538. 

  6538. 					public class Test

    6539. 

  6539. 					{

    6540. 

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

    6541. 

  6541. 				    public static Expression check28_C___() {

    6542. 

  6542. 				       if(Main() != 0 ) {

    6543. 

  6543. 				           throw new Exception();

    6544. 

  6544. 				       } else { 

    6545. 

  6545. 				           return Expression.Constant(0);

    6546. 

  6546. 				       }

    6547. 

  6547. 				    }

    6548. 

  6548. 					public     static int Main()

    6549. 

  6549. 					    {

    6550. 

  6550. 					        Ext.StartCapture();

    6551. 

  6551. 					        bool success = false;

    6552. 

  6552. 					        try

    6553. 

  6553. 					        {

    6554. 

  6554. 					            success = check28<C>();

    6555. 

  6555. 					        }

    6556. 

  6556. 					        finally

    6557. 

  6557. 					        {

    6558. 

  6558. 					            Ext.StopCapture();

    6559. 

  6559. 					        }

    6560. 

  6560. 					        return success ? 0 : 1;

    6561. 

  6561. 					    }

    6562. 

  6562. 					

    6563. 

  6563. 					    static bool check28<TC>() where TC : C {

    6564. 

  6564. 					        foreach (TC val in new TC[] { null, default(TC), (TC) new C() }) {

    6565. 

  6565. 					            if (!check28<TC>(val)) {

    6566. 

  6566. 					                return false;

    6567. 

  6567. 					            }

    6568. 

  6568. 					        }

    6569. 

  6569. 					        return true;

    6570. 

  6570. 					    }

    6571. 

  6571. 					

    6572. 

  6572. 					    static bool check28<TC>(TC val) where TC : C {

    6573. 

  6573. 					        Expression<Func<TC>> e =

    6574. 

  6574. 					            Expression.Lambda<Func<TC>>(

    6575. 

  6575. 					                Expression.Constant(val, typeof(TC)),

    6576. 

  6576. 					                new System.Collections.Generic.List<ParameterExpression>());

    6577. 

  6577. 					        Func<TC> f = e.Compile();

    6578. 

  6578. 					        return object.Equals(f(), val);

    6579. 

  6579. 					    }

    6580. 

  6580. 					}

    6581. 

  6581. 				

    6582. 

  6582. 				

    6583. 

  6583. 				public  static class Ext {

    6584. 

  6584. 				    public static void StartCapture() {

    6585. 

  6585. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6586. 

  6586. 				//        m.Invoke(null, new object[] { "test.dll" });

    6587. 

  6587. 				    }

    6588. 

  6588. 				

    6589. 

  6589. 				    public static void StopCapture() {

    6590. 

  6590. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6591. 

  6591. 				//        m.Invoke(null, new object[0]);

    6592. 

  6592. 				    }

    6593. 

  6593. 				

    6594. 

  6594. 				    public static bool IsIntegralOrEnum(Type type) {

    6595. 

  6595. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6596. 

  6596. 				            case TypeCode.Byte:

    6597. 

  6597. 				            case TypeCode.SByte:

    6598. 

  6598. 				            case TypeCode.Int16:

    6599. 

  6599. 				            case TypeCode.Int32:

    6600. 

  6600. 				            case TypeCode.Int64:

    6601. 

  6601. 				            case TypeCode.UInt16:

    6602. 

  6602. 				            case TypeCode.UInt32:

    6603. 

  6603. 				            case TypeCode.UInt64:

    6604. 

  6604. 				                return true;

    6605. 

  6605. 				            default:

    6606. 

  6606. 				                return false;

    6607. 

  6607. 				        }

    6608. 

  6608. 				    }

    6609. 

  6609. 				

    6610. 

  6610. 				    public static bool IsFloating(Type type) {

    6611. 

  6611. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6612. 

  6612. 				            case TypeCode.Single:

    6613. 

  6613. 				            case TypeCode.Double:

    6614. 

  6614. 				                return true;

    6615. 

  6615. 				            default:

    6616. 

  6616. 				                return false;

    6617. 

  6617. 				        }

    6618. 

  6618. 				    }

    6619. 

  6619. 				

    6620. 

  6620. 				    public static Type GetNonNullableType(Type type) {

    6621. 

  6621. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    6622. 

  6622. 				                type.GetGenericArguments()[0] :

    6623. 

  6623. 				                type;

    6624. 

  6624. 				    }

    6625. 

  6625. 				}

    6626. 

  6626. 				

    6627. 

  6627. 			

    6628. 

  6628. 			

    6629. 

  6629. 			

    6630. 

  6630. 			public interface I {

    6631. 

  6631. 			  void M();

    6632. 

  6632. 			}

    6633. 

  6633. 			

    6634. 

  6634. 			public  class C : IEquatable<C>, I {

    6635. 

  6635. 			    void I.M() {

    6636. 

  6636. 			    }

    6637. 

  6637. 			

    6638. 

  6638. 			    public override bool Equals(object o) {

    6639. 

  6639. 			        return o is C && Equals((C) o);

    6640. 

  6640. 			    }

    6641. 

  6641. 			

    6642. 

  6642. 			    public bool Equals(C c) {

    6643. 

  6643. 			        return c != null;

    6644. 

  6644. 			    }

    6645. 

  6645. 			

    6646. 

  6646. 			    public override int GetHashCode() {

    6647. 

  6647. 			        return 0;

    6648. 

  6648. 			    }

    6649. 

  6649. 			}

    6650. 

  6650. 			

    6651. 

  6651. 			public  class D : C, IEquatable<D> {

    6652. 

  6652. 			    public int Val;

    6653. 

  6653. 			    public D() {

    6654. 

  6654. 			    }

    6655. 

  6655. 			    public D(int val) {

    6656. 

  6656. 			        Val = val;

    6657. 

  6657. 			    }

    6658. 

  6658. 			

    6659. 

  6659. 			    public override bool Equals(object o) {

    6660. 

  6660. 			        return o is D && Equals((D) o);

    6661. 

  6661. 			    }

    6662. 

  6662. 			

    6663. 

  6663. 			    public bool Equals(D d) {

    6664. 

  6664. 			        return d != null && d.Val == Val;

    6665. 

  6665. 			    }

    6666. 

  6666. 			

    6667. 

  6667. 			    public override int GetHashCode() {

    6668. 

  6668. 			        return Val;

    6669. 

  6669. 			    }

    6670. 

  6670. 			}

    6671. 

  6671. 			

    6672. 

  6672. 			public enum E {

    6673. 

  6673. 			  A=1, B=2

    6674. 

  6674. 			}

    6675. 

  6675. 			

    6676. 

  6676. 			public enum El : long {

    6677. 

  6677. 			  A, B, C

    6678. 

  6678. 			}

    6679. 

  6679. 			

    6680. 

  6680. 			public struct S : IEquatable<S> {

    6681. 

  6681. 			    public override bool Equals(object o) {

    6682. 

  6682. 			        return (o is S) && Equals((S) o);

    6683. 

  6683. 			    }

    6684. 

  6684. 			    public bool Equals(S other) {

    6685. 

  6685. 			        return true;

    6686. 

  6686. 			    }

    6687. 

  6687. 			    public override int GetHashCode() {

    6688. 

  6688. 			        return 0;

    6689. 

  6689. 			    }

    6690. 

  6690. 			}

    6691. 

  6691. 			

    6692. 

  6692. 			public struct Sp : IEquatable<Sp> {

    6693. 

  6693. 			    public Sp(int i, double d) {

    6694. 

  6694. 			        I = i;

    6695. 

  6695. 			        D = d;

    6696. 

  6696. 			    }

    6697. 

  6697. 			

    6698. 

  6698. 			    public int I;

    6699. 

  6699. 			    public double D;

    6700. 

  6700. 			

    6701. 

  6701. 			    public override bool Equals(object o) {

    6702. 

  6702. 			        return (o is Sp) && Equals((Sp) o);

    6703. 

  6703. 			    }

    6704. 

  6704. 			    public bool Equals(Sp other) {

    6705. 

  6705. 			        return other.I == I && other.D == D;

    6706. 

  6706. 			    }

    6707. 

  6707. 			    public override int GetHashCode() {

    6708. 

  6708. 			        return I.GetHashCode() ^ D.GetHashCode();

    6709. 

  6709. 			    }

    6710. 

  6710. 			}

    6711. 

  6711. 			

    6712. 

  6712. 			public struct Ss : IEquatable<Ss> {

    6713. 

  6713. 			    public Ss(S s) {

    6714. 

  6714. 			        Val = s;

    6715. 

  6715. 			    }

    6716. 

  6716. 			

    6717. 

  6717. 			    public S Val;

    6718. 

  6718. 			

    6719. 

  6719. 			    public override bool Equals(object o) {

    6720. 

  6720. 			        return (o is Ss) && Equals((Ss) o);

    6721. 

  6721. 			    }

    6722. 

  6722. 			    public bool Equals(Ss other) {

    6723. 

  6723. 			        return other.Val.Equals(Val);

    6724. 

  6724. 			    }

    6725. 

  6725. 			    public override int GetHashCode() {

    6726. 

  6726. 			        return Val.GetHashCode();

    6727. 

  6727. 			    }

    6728. 

  6728. 			}

    6729. 

  6729. 			

    6730. 

  6730. 			public struct Sc : IEquatable<Sc> {

    6731. 

  6731. 			    public Sc(string s) {

    6732. 

  6732. 			        S = s;

    6733. 

  6733. 			    }

    6734. 

  6734. 			

    6735. 

  6735. 			    public string S;

    6736. 

  6736. 			

    6737. 

  6737. 			    public override bool Equals(object o) {

    6738. 

  6738. 			        return (o is Sc) && Equals((Sc) o);

    6739. 

  6739. 			    }

    6740. 

  6740. 			    public bool Equals(Sc other) {

    6741. 

  6741. 			        return other.S == S;

    6742. 

  6742. 			    }

    6743. 

  6743. 			    public override int GetHashCode() {

    6744. 

  6744. 			        return S.GetHashCode();

    6745. 

  6745. 			    }

    6746. 

  6746. 			}

    6747. 

  6747. 			

    6748. 

  6748. 			public struct Scs : IEquatable<Scs> {

    6749. 

  6749. 			    public Scs(string s, S val) {

    6750. 

  6750. 			        S = s;

    6751. 

  6751. 			        Val = val;

    6752. 

  6752. 			    }

    6753. 

  6753. 			

    6754. 

  6754. 			    public string S;

    6755. 

  6755. 			    public S Val;

    6756. 

  6756. 			

    6757. 

  6757. 			    public override bool Equals(object o) {

    6758. 

  6758. 			        return (o is Scs) && Equals((Scs) o);

    6759. 

  6759. 			    }

    6760. 

  6760. 			    public bool Equals(Scs other) {

    6761. 

  6761. 			        return other.S == S && other.Val.Equals(Val);

    6762. 

  6762. 			    }

    6763. 

  6763. 			    public override int GetHashCode() {

    6764. 

  6764. 			        return S.GetHashCode() ^ Val.GetHashCode();

    6765. 

  6765. 			    }

    6766. 

  6766. 			}

    6767. 

  6767. 			

    6768. 

  6768. 		

    6769. 

  6769. 	}

    6770. 

  6770. 				

    6771. 

  6771. 				//-------- Scenario 1743

    6772. 

  6772. 				namespace Scenario1743{

    6773. 

  6773. 					

    6774. 

  6774. 					public class Test

    6775. 

  6775. 					{

    6776. 

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

    6777. 

  6777. 				    public static Expression check29_C___() {

    6778. 

  6778. 				       if(Main() != 0 ) {

    6779. 

  6779. 				           throw new Exception();

    6780. 

  6780. 				       } else { 

    6781. 

  6781. 				           return Expression.Constant(0);

    6782. 

  6782. 				       }

    6783. 

  6783. 				    }

    6784. 

  6784. 					public     static int Main()

    6785. 

  6785. 					    {

    6786. 

  6786. 					        Ext.StartCapture();

    6787. 

  6787. 					        bool success = false;

    6788. 

  6788. 					        try

    6789. 

  6789. 					        {

    6790. 

  6790. 					            success = check29<C>();

    6791. 

  6791. 					        }

    6792. 

  6792. 					        finally

    6793. 

  6793. 					        {

    6794. 

  6794. 					            Ext.StopCapture();

    6795. 

  6795. 					        }

    6796. 

  6796. 					        return success ? 0 : 1;

    6797. 

  6797. 					    }

    6798. 

  6798. 					

    6799. 

  6799. 					    static bool check29<TCn>() where TCn : C, new() {

    6800. 

  6800. 					        foreach (TCn val in new TCn[] { null, default(TCn), new TCn(), (TCn) new C() }) {

    6801. 

  6801. 					            if (!check29<TCn>(val)) {

    6802. 

  6802. 					                return false;

    6803. 

  6803. 					            }

    6804. 

  6804. 					        }

    6805. 

  6805. 					        return true;

    6806. 

  6806. 					    }

    6807. 

  6807. 					

    6808. 

  6808. 					    static bool check29<TCn>(TCn val) where TCn : C, new() {

    6809. 

  6809. 					        Expression<Func<TCn>> e =

    6810. 

  6810. 					            Expression.Lambda<Func<TCn>>(

    6811. 

  6811. 					                Expression.Constant(val, typeof(TCn)),

    6812. 

  6812. 					                new System.Collections.Generic.List<ParameterExpression>());

    6813. 

  6813. 					        Func<TCn> f = e.Compile();

    6814. 

  6814. 					        return object.Equals(f(), val);

    6815. 

  6815. 					    }

    6816. 

  6816. 					}

    6817. 

  6817. 				

    6818. 

  6818. 				

    6819. 

  6819. 				public  static class Ext {

    6820. 

  6820. 				    public static void StartCapture() {

    6821. 

  6821. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6822. 

  6822. 				//        m.Invoke(null, new object[] { "test.dll" });

    6823. 

  6823. 				    }

    6824. 

  6824. 				

    6825. 

  6825. 				    public static void StopCapture() {

    6826. 

  6826. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    6827. 

  6827. 				//        m.Invoke(null, new object[0]);

    6828. 

  6828. 				    }

    6829. 

  6829. 				

    6830. 

  6830. 				    public static bool IsIntegralOrEnum(Type type) {

    6831. 

  6831. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6832. 

  6832. 				            case TypeCode.Byte:

    6833. 

  6833. 				            case TypeCode.SByte:

    6834. 

  6834. 				            case TypeCode.Int16:

    6835. 

  6835. 				            case TypeCode.Int32:

    6836. 

  6836. 				            case TypeCode.Int64:

    6837. 

  6837. 				            case TypeCode.UInt16:

    6838. 

  6838. 				            case TypeCode.UInt32:

    6839. 

  6839. 				            case TypeCode.UInt64:

    6840. 

  6840. 				                return true;

    6841. 

  6841. 				            default:

    6842. 

  6842. 				                return false;

    6843. 

  6843. 				        }

    6844. 

  6844. 				    }

    6845. 

  6845. 				

    6846. 

  6846. 				    public static bool IsFloating(Type type) {

    6847. 

  6847. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    6848. 

  6848. 				            case TypeCode.Single:

    6849. 

  6849. 				            case TypeCode.Double:

    6850. 

  6850. 				                return true;

    6851. 

  6851. 				            default:

    6852. 

  6852. 				                return false;

    6853. 

  6853. 				        }

    6854. 

  6854. 				    }

    6855. 

  6855. 				

    6856. 

  6856. 				    public static Type GetNonNullableType(Type type) {

    6857. 

  6857. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    6858. 

  6858. 				                type.GetGenericArguments()[0] :

    6859. 

  6859. 				                type;

    6860. 

  6860. 				    }

    6861. 

  6861. 				}

    6862. 

  6862. 				

    6863. 

  6863. 			

    6864. 

  6864. 			

    6865. 

  6865. 			

    6866. 

  6866. 			public interface I {

    6867. 

  6867. 			  void M();

    6868. 

  6868. 			}

    6869. 

  6869. 			

    6870. 

  6870. 			public  class C : IEquatable<C>, I {

    6871. 

  6871. 			    void I.M() {

    6872. 

  6872. 			    }

    6873. 

  6873. 			

    6874. 

  6874. 			    public override bool Equals(object o) {

    6875. 

  6875. 			        return o is C && Equals((C) o);

    6876. 

  6876. 			    }

    6877. 

  6877. 			

    6878. 

  6878. 			    public bool Equals(C c) {

    6879. 

  6879. 			        return c != null;

    6880. 

  6880. 			    }

    6881. 

  6881. 			

    6882. 

  6882. 			    public override int GetHashCode() {

    6883. 

  6883. 			        return 0;

    6884. 

  6884. 			    }

    6885. 

  6885. 			}

    6886. 

  6886. 			

    6887. 

  6887. 			public  class D : C, IEquatable<D> {

    6888. 

  6888. 			    public int Val;

    6889. 

  6889. 			    public D() {

    6890. 

  6890. 			    }

    6891. 

  6891. 			    public D(int val) {

    6892. 

  6892. 			        Val = val;

    6893. 

  6893. 			    }

    6894. 

  6894. 			

    6895. 

  6895. 			    public override bool Equals(object o) {

    6896. 

  6896. 			        return o is D && Equals((D) o);

    6897. 

  6897. 			    }

    6898. 

  6898. 			

    6899. 

  6899. 			    public bool Equals(D d) {

    6900. 

  6900. 			        return d != null && d.Val == Val;

    6901. 

  6901. 			    }

    6902. 

  6902. 			

    6903. 

  6903. 			    public override int GetHashCode() {

    6904. 

  6904. 			        return Val;

    6905. 

  6905. 			    }

    6906. 

  6906. 			}

    6907. 

  6907. 			

    6908. 

  6908. 			public enum E {

    6909. 

  6909. 			  A=1, B=2

    6910. 

  6910. 			}

    6911. 

  6911. 			

    6912. 

  6912. 			public enum El : long {

    6913. 

  6913. 			  A, B, C

    6914. 

  6914. 			}

    6915. 

  6915. 			

    6916. 

  6916. 			public struct S : IEquatable<S> {

    6917. 

  6917. 			    public override bool Equals(object o) {

    6918. 

  6918. 			        return (o is S) && Equals((S) o);

    6919. 

  6919. 			    }

    6920. 

  6920. 			    public bool Equals(S other) {

    6921. 

  6921. 			        return true;

    6922. 

  6922. 			    }

    6923. 

  6923. 			    public override int GetHashCode() {

    6924. 

  6924. 			        return 0;

    6925. 

  6925. 			    }

    6926. 

  6926. 			}

    6927. 

  6927. 			

    6928. 

  6928. 			public struct Sp : IEquatable<Sp> {

    6929. 

  6929. 			    public Sp(int i, double d) {

    6930. 

  6930. 			        I = i;

    6931. 

  6931. 			        D = d;

    6932. 

  6932. 			    }

    6933. 

  6933. 			

    6934. 

  6934. 			    public int I;

    6935. 

  6935. 			    public double D;

    6936. 

  6936. 			

    6937. 

  6937. 			    public override bool Equals(object o) {

    6938. 

  6938. 			        return (o is Sp) && Equals((Sp) o);

    6939. 

  6939. 			    }

    6940. 

  6940. 			    public bool Equals(Sp other) {

    6941. 

  6941. 			        return other.I == I && other.D == D;

    6942. 

  6942. 			    }

    6943. 

  6943. 			    public override int GetHashCode() {

    6944. 

  6944. 			        return I.GetHashCode() ^ D.GetHashCode();

    6945. 

  6945. 			    }

    6946. 

  6946. 			}

    6947. 

  6947. 			

    6948. 

  6948. 			public struct Ss : IEquatable<Ss> {

    6949. 

  6949. 			    public Ss(S s) {

    6950. 

  6950. 			        Val = s;

    6951. 

  6951. 			    }

    6952. 

  6952. 			

    6953. 

  6953. 			    public S Val;

    6954. 

  6954. 			

    6955. 

  6955. 			    public override bool Equals(object o) {

    6956. 

  6956. 			        return (o is Ss) && Equals((Ss) o);

    6957. 

  6957. 			    }

    6958. 

  6958. 			    public bool Equals(Ss other) {

    6959. 

  6959. 			        return other.Val.Equals(Val);

    6960. 

  6960. 			    }

    6961. 

  6961. 			    public override int GetHashCode() {

    6962. 

  6962. 			        return Val.GetHashCode();

    6963. 

  6963. 			    }

    6964. 

  6964. 			}

    6965. 

  6965. 			

    6966. 

  6966. 			public struct Sc : IEquatable<Sc> {

    6967. 

  6967. 			    public Sc(string s) {

    6968. 

  6968. 			        S = s;

    6969. 

  6969. 			    }

    6970. 

  6970. 			

    6971. 

  6971. 			    public string S;

    6972. 

  6972. 			

    6973. 

  6973. 			    public override bool Equals(object o) {

    6974. 

  6974. 			        return (o is Sc) && Equals((Sc) o);

    6975. 

  6975. 			    }

    6976. 

  6976. 			    public bool Equals(Sc other) {

    6977. 

  6977. 			        return other.S == S;

    6978. 

  6978. 			    }

    6979. 

  6979. 			    public override int GetHashCode() {

    6980. 

  6980. 			        return S.GetHashCode();

    6981. 

  6981. 			    }

    6982. 

  6982. 			}

    6983. 

  6983. 			

    6984. 

  6984. 			public struct Scs : IEquatable<Scs> {

    6985. 

  6985. 			    public Scs(string s, S val) {

    6986. 

  6986. 			        S = s;

    6987. 

  6987. 			        Val = val;

    6988. 

  6988. 			    }

    6989. 

  6989. 			

    6990. 

  6990. 			    public string S;

    6991. 

  6991. 			    public S Val;

    6992. 

  6992. 			

    6993. 

  6993. 			    public override bool Equals(object o) {

    6994. 

  6994. 			        return (o is Scs) && Equals((Scs) o);

    6995. 

  6995. 			    }

    6996. 

  6996. 			    public bool Equals(Scs other) {

    6997. 

  6997. 			        return other.S == S && other.Val.Equals(Val);

    6998. 

  6998. 			    }

    6999. 

  6999. 			    public override int GetHashCode() {

    7000. 

  7000. 			        return S.GetHashCode() ^ Val.GetHashCode();

    7001. 

  7001. 			    }

    7002. 

  7002. 			}

    7003. 

  7003. 			

    7004. 

  7004. 		

    7005. 

  7005. 	}

    7006. 

  7006. 			

    7007. 

  7007. 			//-------- Scenario 1744

    7008. 

  7008. 			namespace Scenario1744{

    7009. 

  7009. 				

    7010. 

  7010. 				public class Test

    7011. 

  7011. 				{

    7012. 

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

    7013. 

  7013. 			    public static Expression check30__() {

    7014. 

  7014. 			       if(Main() != 0 ) {

    7015. 

  7015. 			           throw new Exception();

    7016. 

  7016. 			       } else { 

    7017. 

  7017. 			           return Expression.Constant(0);

    7018. 

  7018. 			       }

    7019. 

  7019. 			    }

    7020. 

  7020. 				public     static int Main()

    7021. 

  7021. 				    {

    7022. 

  7022. 				        Ext.StartCapture();

    7023. 

  7023. 				        bool success = false;

    7024. 

  7024. 				        try

    7025. 

  7025. 				        {

    7026. 

  7026. 				            success = check30();

    7027. 

  7027. 				        }

    7028. 

  7028. 				        finally

    7029. 

  7029. 				        {

    7030. 

  7030. 				            Ext.StopCapture();

    7031. 

  7031. 				        }

    7032. 

  7032. 				        return success ? 0 : 1;

    7033. 

  7033. 				    }

    7034. 

  7034. 				

    7035. 

  7035. 				    static bool check30() {

    7036. 

  7036. 				        foreach (Delegate val in new Delegate[] { null, (Func<object>) delegate() { return null; }, (Func<int, int>) delegate(int i) { return i+1; }, (Action<object>) delegate { } }) {

    7037. 

  7037. 				            if (!check30(val)) {

    7038. 

  7038. 				                return false;

    7039. 

  7039. 				            }

    7040. 

  7040. 				        }

    7041. 

  7041. 				        return true;

    7042. 

  7042. 				    }

    7043. 

  7043. 				

    7044. 

  7044. 				    static bool check30(Delegate val) {

    7045. 

  7045. 				        Expression<Func<Delegate>> e =

    7046. 

  7046. 				            Expression.Lambda<Func<Delegate>>(

    7047. 

  7047. 				                Expression.Constant(val, typeof(Delegate)),

    7048. 

  7048. 				                new System.Collections.Generic.List<ParameterExpression>());

    7049. 

  7049. 				        Func<Delegate> f = e.Compile();

    7050. 

  7050. 				        return object.Equals(f(), val);

    7051. 

  7051. 				    }

    7052. 

  7052. 				}

    7053. 

  7053. 			

    7054. 

  7054. 			

    7055. 

  7055. 			public  static class Ext {

    7056. 

  7056. 			    public static void StartCapture() {

    7057. 

  7057. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7058. 

  7058. 			//        m.Invoke(null, new object[] { "test.dll" });

    7059. 

  7059. 			    }

    7060. 

  7060. 			

    7061. 

  7061. 			    public static void StopCapture() {

    7062. 

  7062. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7063. 

  7063. 			//        m.Invoke(null, new object[0]);

    7064. 

  7064. 			    }

    7065. 

  7065. 			

    7066. 

  7066. 			    public static bool IsIntegralOrEnum(Type type) {

    7067. 

  7067. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7068. 

  7068. 			            case TypeCode.Byte:

    7069. 

  7069. 			            case TypeCode.SByte:

    7070. 

  7070. 			            case TypeCode.Int16:

    7071. 

  7071. 			            case TypeCode.Int32:

    7072. 

  7072. 			            case TypeCode.Int64:

    7073. 

  7073. 			            case TypeCode.UInt16:

    7074. 

  7074. 			            case TypeCode.UInt32:

    7075. 

  7075. 			            case TypeCode.UInt64:

    7076. 

  7076. 			                return true;

    7077. 

  7077. 			            default:

    7078. 

  7078. 			                return false;

    7079. 

  7079. 			        }

    7080. 

  7080. 			    }

    7081. 

  7081. 			

    7082. 

  7082. 			    public static bool IsFloating(Type type) {

    7083. 

  7083. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7084. 

  7084. 			            case TypeCode.Single:

    7085. 

  7085. 			            case TypeCode.Double:

    7086. 

  7086. 			                return true;

    7087. 

  7087. 			            default:

    7088. 

  7088. 			                return false;

    7089. 

  7089. 			        }

    7090. 

  7090. 			    }

    7091. 

  7091. 			

    7092. 

  7092. 			    public static Type GetNonNullableType(Type type) {

    7093. 

  7093. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7094. 

  7094. 			                type.GetGenericArguments()[0] :

    7095. 

  7095. 			                type;

    7096. 

  7096. 			    }

    7097. 

  7097. 			}

    7098. 

  7098. 			

    7099. 

  7099. 		

    7100. 

  7100. 	}

    7101. 

  7101. 			

    7102. 

  7102. 			//-------- Scenario 1745

    7103. 

  7103. 			namespace Scenario1745{

    7104. 

  7104. 				

    7105. 

  7105. 				public class Test

    7106. 

  7106. 				{

    7107. 

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

    7108. 

  7108. 			    public static Expression check31__() {

    7109. 

  7109. 			       if(Main() != 0 ) {

    7110. 

  7110. 			           throw new Exception();

    7111. 

  7111. 			       } else { 

    7112. 

  7112. 			           return Expression.Constant(0);

    7113. 

  7113. 			       }

    7114. 

  7114. 			    }

    7115. 

  7115. 				public     static int Main()

    7116. 

  7116. 				    {

    7117. 

  7117. 				        Ext.StartCapture();

    7118. 

  7118. 				        bool success = false;

    7119. 

  7119. 				        try

    7120. 

  7120. 				        {

    7121. 

  7121. 				            success = check31();

    7122. 

  7122. 				        }

    7123. 

  7123. 				        finally

    7124. 

  7124. 				        {

    7125. 

  7125. 				            Ext.StopCapture();

    7126. 

  7126. 				        }

    7127. 

  7127. 				        return success ? 0 : 1;

    7128. 

  7128. 				    }

    7129. 

  7129. 				

    7130. 

  7130. 				    static bool check31() {

    7131. 

  7131. 				        foreach (Func<object> val in new Func<object>[] { null, (Func<object>) delegate() { return null; } }) {

    7132. 

  7132. 				            if (!check31(val)) {

    7133. 

  7133. 				                return false;

    7134. 

  7134. 				            }

    7135. 

  7135. 				        }

    7136. 

  7136. 				        return true;

    7137. 

  7137. 				    }

    7138. 

  7138. 				

    7139. 

  7139. 				    static bool check31(Func<object> val) {

    7140. 

  7140. 				        Expression<Func<Func<object>>> e =

    7141. 

  7141. 				            Expression.Lambda<Func<Func<object>>>(

    7142. 

  7142. 				                Expression.Constant(val, typeof(Func<object>)),

    7143. 

  7143. 				                new System.Collections.Generic.List<ParameterExpression>());

    7144. 

  7144. 				        Func<Func<object>> f = e.Compile();

    7145. 

  7145. 				        return object.Equals(f(), val);

    7146. 

  7146. 				    }

    7147. 

  7147. 				}

    7148. 

  7148. 			

    7149. 

  7149. 			

    7150. 

  7150. 			public  static class Ext {

    7151. 

  7151. 			    public static void StartCapture() {

    7152. 

  7152. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7153. 

  7153. 			//        m.Invoke(null, new object[] { "test.dll" });

    7154. 

  7154. 			    }

    7155. 

  7155. 			

    7156. 

  7156. 			    public static void StopCapture() {

    7157. 

  7157. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7158. 

  7158. 			//        m.Invoke(null, new object[0]);

    7159. 

  7159. 			    }

    7160. 

  7160. 			

    7161. 

  7161. 			    public static bool IsIntegralOrEnum(Type type) {

    7162. 

  7162. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7163. 

  7163. 			            case TypeCode.Byte:

    7164. 

  7164. 			            case TypeCode.SByte:

    7165. 

  7165. 			            case TypeCode.Int16:

    7166. 

  7166. 			            case TypeCode.Int32:

    7167. 

  7167. 			            case TypeCode.Int64:

    7168. 

  7168. 			            case TypeCode.UInt16:

    7169. 

  7169. 			            case TypeCode.UInt32:

    7170. 

  7170. 			            case TypeCode.UInt64:

    7171. 

  7171. 			                return true;

    7172. 

  7172. 			            default:

    7173. 

  7173. 			                return false;

    7174. 

  7174. 			        }

    7175. 

  7175. 			    }

    7176. 

  7176. 			

    7177. 

  7177. 			    public static bool IsFloating(Type type) {

    7178. 

  7178. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7179. 

  7179. 			            case TypeCode.Single:

    7180. 

  7180. 			            case TypeCode.Double:

    7181. 

  7181. 			                return true;

    7182. 

  7182. 			            default:

    7183. 

  7183. 			                return false;

    7184. 

  7184. 			        }

    7185. 

  7185. 			    }

    7186. 

  7186. 			

    7187. 

  7187. 			    public static Type GetNonNullableType(Type type) {

    7188. 

  7188. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7189. 

  7189. 			                type.GetGenericArguments()[0] :

    7190. 

  7190. 			                type;

    7191. 

  7191. 			    }

    7192. 

  7192. 			}

    7193. 

  7193. 			

    7194. 

  7194. 		

    7195. 

  7195. 	}

    7196. 

  7196. 				

    7197. 

  7197. 				//-------- Scenario 1746

    7198. 

  7198. 				namespace Scenario1746{

    7199. 

  7199. 					

    7200. 

  7200. 					public class Test

    7201. 

  7201. 					{

    7202. 

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

    7203. 

  7203. 				    public static Expression check32__() {

    7204. 

  7204. 				       if(Main() != 0 ) {

    7205. 

  7205. 				           throw new Exception();

    7206. 

  7206. 				       } else { 

    7207. 

  7207. 				           return Expression.Constant(0);

    7208. 

  7208. 				       }

    7209. 

  7209. 				    }

    7210. 

  7210. 					public     static int Main()

    7211. 

  7211. 					    {

    7212. 

  7212. 					        Ext.StartCapture();

    7213. 

  7213. 					        bool success = false;

    7214. 

  7214. 					        try

    7215. 

  7215. 					        {

    7216. 

  7216. 					            success = check32();

    7217. 

  7217. 					        }

    7218. 

  7218. 					        finally

    7219. 

  7219. 					        {

    7220. 

  7220. 					            Ext.StopCapture();

    7221. 

  7221. 					        }

    7222. 

  7222. 					        return success ? 0 : 1;

    7223. 

  7223. 					    }

    7224. 

  7224. 					

    7225. 

  7225. 					    static bool check32() {

    7226. 

  7226. 					        foreach (IEquatable<C> val in new IEquatable<C>[] { null, new C(), new D(), new D(0), new D(5) }) {

    7227. 

  7227. 					            if (!check32(val)) {

    7228. 

  7228. 					                return false;

    7229. 

  7229. 					            }

    7230. 

  7230. 					        }

    7231. 

  7231. 					        return true;

    7232. 

  7232. 					    }

    7233. 

  7233. 					

    7234. 

  7234. 					    static bool check32(IEquatable<C> val) {

    7235. 

  7235. 					        Expression<Func<IEquatable<C>>> e =

    7236. 

  7236. 					            Expression.Lambda<Func<IEquatable<C>>>(

    7237. 

  7237. 					                Expression.Constant(val, typeof(IEquatable<C>)),

    7238. 

  7238. 					                new System.Collections.Generic.List<ParameterExpression>());

    7239. 

  7239. 					        Func<IEquatable<C>> f = e.Compile();

    7240. 

  7240. 					        return object.Equals(f(), val);

    7241. 

  7241. 					    }

    7242. 

  7242. 					}

    7243. 

  7243. 				

    7244. 

  7244. 				

    7245. 

  7245. 				public  static class Ext {

    7246. 

  7246. 				    public static void StartCapture() {

    7247. 

  7247. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7248. 

  7248. 				//        m.Invoke(null, new object[] { "test.dll" });

    7249. 

  7249. 				    }

    7250. 

  7250. 				

    7251. 

  7251. 				    public static void StopCapture() {

    7252. 

  7252. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7253. 

  7253. 				//        m.Invoke(null, new object[0]);

    7254. 

  7254. 				    }

    7255. 

  7255. 				

    7256. 

  7256. 				    public static bool IsIntegralOrEnum(Type type) {

    7257. 

  7257. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7258. 

  7258. 				            case TypeCode.Byte:

    7259. 

  7259. 				            case TypeCode.SByte:

    7260. 

  7260. 				            case TypeCode.Int16:

    7261. 

  7261. 				            case TypeCode.Int32:

    7262. 

  7262. 				            case TypeCode.Int64:

    7263. 

  7263. 				            case TypeCode.UInt16:

    7264. 

  7264. 				            case TypeCode.UInt32:

    7265. 

  7265. 				            case TypeCode.UInt64:

    7266. 

  7266. 				                return true;

    7267. 

  7267. 				            default:

    7268. 

  7268. 				                return false;

    7269. 

  7269. 				        }

    7270. 

  7270. 				    }

    7271. 

  7271. 				

    7272. 

  7272. 				    public static bool IsFloating(Type type) {

    7273. 

  7273. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7274. 

  7274. 				            case TypeCode.Single:

    7275. 

  7275. 				            case TypeCode.Double:

    7276. 

  7276. 				                return true;

    7277. 

  7277. 				            default:

    7278. 

  7278. 				                return false;

    7279. 

  7279. 				        }

    7280. 

  7280. 				    }

    7281. 

  7281. 				

    7282. 

  7282. 				    public static Type GetNonNullableType(Type type) {

    7283. 

  7283. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7284. 

  7284. 				                type.GetGenericArguments()[0] :

    7285. 

  7285. 				                type;

    7286. 

  7286. 				    }

    7287. 

  7287. 				}

    7288. 

  7288. 				

    7289. 

  7289. 			

    7290. 

  7290. 			

    7291. 

  7291. 			

    7292. 

  7292. 			public interface I {

    7293. 

  7293. 			  void M();

    7294. 

  7294. 			}

    7295. 

  7295. 			

    7296. 

  7296. 			public  class C : IEquatable<C>, I {

    7297. 

  7297. 			    void I.M() {

    7298. 

  7298. 			    }

    7299. 

  7299. 			

    7300. 

  7300. 			    public override bool Equals(object o) {

    7301. 

  7301. 			        return o is C && Equals((C) o);

    7302. 

  7302. 			    }

    7303. 

  7303. 			

    7304. 

  7304. 			    public bool Equals(C c) {

    7305. 

  7305. 			        return c != null;

    7306. 

  7306. 			    }

    7307. 

  7307. 			

    7308. 

  7308. 			    public override int GetHashCode() {

    7309. 

  7309. 			        return 0;

    7310. 

  7310. 			    }

    7311. 

  7311. 			}

    7312. 

  7312. 			

    7313. 

  7313. 			public  class D : C, IEquatable<D> {

    7314. 

  7314. 			    public int Val;

    7315. 

  7315. 			    public D() {

    7316. 

  7316. 			    }

    7317. 

  7317. 			    public D(int val) {

    7318. 

  7318. 			        Val = val;

    7319. 

  7319. 			    }

    7320. 

  7320. 			

    7321. 

  7321. 			    public override bool Equals(object o) {

    7322. 

  7322. 			        return o is D && Equals((D) o);

    7323. 

  7323. 			    }

    7324. 

  7324. 			

    7325. 

  7325. 			    public bool Equals(D d) {

    7326. 

  7326. 			        return d != null && d.Val == Val;

    7327. 

  7327. 			    }

    7328. 

  7328. 			

    7329. 

  7329. 			    public override int GetHashCode() {

    7330. 

  7330. 			        return Val;

    7331. 

  7331. 			    }

    7332. 

  7332. 			}

    7333. 

  7333. 			

    7334. 

  7334. 			public enum E {

    7335. 

  7335. 			  A=1, B=2

    7336. 

  7336. 			}

    7337. 

  7337. 			

    7338. 

  7338. 			public enum El : long {

    7339. 

  7339. 			  A, B, C

    7340. 

  7340. 			}

    7341. 

  7341. 			

    7342. 

  7342. 			public struct S : IEquatable<S> {

    7343. 

  7343. 			    public override bool Equals(object o) {

    7344. 

  7344. 			        return (o is S) && Equals((S) o);

    7345. 

  7345. 			    }

    7346. 

  7346. 			    public bool Equals(S other) {

    7347. 

  7347. 			        return true;

    7348. 

  7348. 			    }

    7349. 

  7349. 			    public override int GetHashCode() {

    7350. 

  7350. 			        return 0;

    7351. 

  7351. 			    }

    7352. 

  7352. 			}

    7353. 

  7353. 			

    7354. 

  7354. 			public struct Sp : IEquatable<Sp> {

    7355. 

  7355. 			    public Sp(int i, double d) {

    7356. 

  7356. 			        I = i;

    7357. 

  7357. 			        D = d;

    7358. 

  7358. 			    }

    7359. 

  7359. 			

    7360. 

  7360. 			    public int I;

    7361. 

  7361. 			    public double D;

    7362. 

  7362. 			

    7363. 

  7363. 			    public override bool Equals(object o) {

    7364. 

  7364. 			        return (o is Sp) && Equals((Sp) o);

    7365. 

  7365. 			    }

    7366. 

  7366. 			    public bool Equals(Sp other) {

    7367. 

  7367. 			        return other.I == I && other.D == D;

    7368. 

  7368. 			    }

    7369. 

  7369. 			    public override int GetHashCode() {

    7370. 

  7370. 			        return I.GetHashCode() ^ D.GetHashCode();

    7371. 

  7371. 			    }

    7372. 

  7372. 			}

    7373. 

  7373. 			

    7374. 

  7374. 			public struct Ss : IEquatable<Ss> {

    7375. 

  7375. 			    public Ss(S s) {

    7376. 

  7376. 			        Val = s;

    7377. 

  7377. 			    }

    7378. 

  7378. 			

    7379. 

  7379. 			    public S Val;

    7380. 

  7380. 			

    7381. 

  7381. 			    public override bool Equals(object o) {

    7382. 

  7382. 			        return (o is Ss) && Equals((Ss) o);

    7383. 

  7383. 			    }

    7384. 

  7384. 			    public bool Equals(Ss other) {

    7385. 

  7385. 			        return other.Val.Equals(Val);

    7386. 

  7386. 			    }

    7387. 

  7387. 			    public override int GetHashCode() {

    7388. 

  7388. 			        return Val.GetHashCode();

    7389. 

  7389. 			    }

    7390. 

  7390. 			}

    7391. 

  7391. 			

    7392. 

  7392. 			public struct Sc : IEquatable<Sc> {

    7393. 

  7393. 			    public Sc(string s) {

    7394. 

  7394. 			        S = s;

    7395. 

  7395. 			    }

    7396. 

  7396. 			

    7397. 

  7397. 			    public string S;

    7398. 

  7398. 			

    7399. 

  7399. 			    public override bool Equals(object o) {

    7400. 

  7400. 			        return (o is Sc) && Equals((Sc) o);

    7401. 

  7401. 			    }

    7402. 

  7402. 			    public bool Equals(Sc other) {

    7403. 

  7403. 			        return other.S == S;

    7404. 

  7404. 			    }

    7405. 

  7405. 			    public override int GetHashCode() {

    7406. 

  7406. 			        return S.GetHashCode();

    7407. 

  7407. 			    }

    7408. 

  7408. 			}

    7409. 

  7409. 			

    7410. 

  7410. 			public struct Scs : IEquatable<Scs> {

    7411. 

  7411. 			    public Scs(string s, S val) {

    7412. 

  7412. 			        S = s;

    7413. 

  7413. 			        Val = val;

    7414. 

  7414. 			    }

    7415. 

  7415. 			

    7416. 

  7416. 			    public string S;

    7417. 

  7417. 			    public S Val;

    7418. 

  7418. 			

    7419. 

  7419. 			    public override bool Equals(object o) {

    7420. 

  7420. 			        return (o is Scs) && Equals((Scs) o);

    7421. 

  7421. 			    }

    7422. 

  7422. 			    public bool Equals(Scs other) {

    7423. 

  7423. 			        return other.S == S && other.Val.Equals(Val);

    7424. 

  7424. 			    }

    7425. 

  7425. 			    public override int GetHashCode() {

    7426. 

  7426. 			        return S.GetHashCode() ^ Val.GetHashCode();

    7427. 

  7427. 			    }

    7428. 

  7428. 			}

    7429. 

  7429. 			

    7430. 

  7430. 		

    7431. 

  7431. 	}

    7432. 

  7432. 				

    7433. 

  7433. 				//-------- Scenario 1747

    7434. 

  7434. 				namespace Scenario1747{

    7435. 

  7435. 					

    7436. 

  7436. 					public class Test

    7437. 

  7437. 					{

    7438. 

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

    7439. 

  7439. 				    public static Expression check33__() {

    7440. 

  7440. 				       if(Main() != 0 ) {

    7441. 

  7441. 				           throw new Exception();

    7442. 

  7442. 				       } else { 

    7443. 

  7443. 				           return Expression.Constant(0);

    7444. 

  7444. 				       }

    7445. 

  7445. 				    }

    7446. 

  7446. 					public     static int Main()

    7447. 

  7447. 					    {

    7448. 

  7448. 					        Ext.StartCapture();

    7449. 

  7449. 					        bool success = false;

    7450. 

  7450. 					        try

    7451. 

  7451. 					        {

    7452. 

  7452. 					            success = check33();

    7453. 

  7453. 					        }

    7454. 

  7454. 					        finally

    7455. 

  7455. 					        {

    7456. 

  7456. 					            Ext.StopCapture();

    7457. 

  7457. 					        }

    7458. 

  7458. 					        return success ? 0 : 1;

    7459. 

  7459. 					    }

    7460. 

  7460. 					

    7461. 

  7461. 					    static bool check33() {

    7462. 

  7462. 					        foreach (IEquatable<D> val in new IEquatable<D>[] { null, new D(), new D(0), new D(5) }) {

    7463. 

  7463. 					            if (!check33(val)) {

    7464. 

  7464. 					                return false;

    7465. 

  7465. 					            }

    7466. 

  7466. 					        }

    7467. 

  7467. 					        return true;

    7468. 

  7468. 					    }

    7469. 

  7469. 					

    7470. 

  7470. 					    static bool check33(IEquatable<D> val) {

    7471. 

  7471. 					        Expression<Func<IEquatable<D>>> e =

    7472. 

  7472. 					            Expression.Lambda<Func<IEquatable<D>>>(

    7473. 

  7473. 					                Expression.Constant(val, typeof(IEquatable<D>)),

    7474. 

  7474. 					                new System.Collections.Generic.List<ParameterExpression>());

    7475. 

  7475. 					        Func<IEquatable<D>> f = e.Compile();

    7476. 

  7476. 					        return object.Equals(f(), val);

    7477. 

  7477. 					    }

    7478. 

  7478. 					}

    7479. 

  7479. 				

    7480. 

  7480. 				

    7481. 

  7481. 				public  static class Ext {

    7482. 

  7482. 				    public static void StartCapture() {

    7483. 

  7483. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7484. 

  7484. 				//        m.Invoke(null, new object[] { "test.dll" });

    7485. 

  7485. 				    }

    7486. 

  7486. 				

    7487. 

  7487. 				    public static void StopCapture() {

    7488. 

  7488. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7489. 

  7489. 				//        m.Invoke(null, new object[0]);

    7490. 

  7490. 				    }

    7491. 

  7491. 				

    7492. 

  7492. 				    public static bool IsIntegralOrEnum(Type type) {

    7493. 

  7493. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7494. 

  7494. 				            case TypeCode.Byte:

    7495. 

  7495. 				            case TypeCode.SByte:

    7496. 

  7496. 				            case TypeCode.Int16:

    7497. 

  7497. 				            case TypeCode.Int32:

    7498. 

  7498. 				            case TypeCode.Int64:

    7499. 

  7499. 				            case TypeCode.UInt16:

    7500. 

  7500. 				            case TypeCode.UInt32:

    7501. 

  7501. 				            case TypeCode.UInt64:

    7502. 

  7502. 				                return true;

    7503. 

  7503. 				            default:

    7504. 

  7504. 				                return false;

    7505. 

  7505. 				        }

    7506. 

  7506. 				    }

    7507. 

  7507. 				

    7508. 

  7508. 				    public static bool IsFloating(Type type) {

    7509. 

  7509. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7510. 

  7510. 				            case TypeCode.Single:

    7511. 

  7511. 				            case TypeCode.Double:

    7512. 

  7512. 				                return true;

    7513. 

  7513. 				            default:

    7514. 

  7514. 				                return false;

    7515. 

  7515. 				        }

    7516. 

  7516. 				    }

    7517. 

  7517. 				

    7518. 

  7518. 				    public static Type GetNonNullableType(Type type) {

    7519. 

  7519. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7520. 

  7520. 				                type.GetGenericArguments()[0] :

    7521. 

  7521. 				                type;

    7522. 

  7522. 				    }

    7523. 

  7523. 				}

    7524. 

  7524. 				

    7525. 

  7525. 			

    7526. 

  7526. 			

    7527. 

  7527. 			

    7528. 

  7528. 			public interface I {

    7529. 

  7529. 			  void M();

    7530. 

  7530. 			}

    7531. 

  7531. 			

    7532. 

  7532. 			public  class C : IEquatable<C>, I {

    7533. 

  7533. 			    void I.M() {

    7534. 

  7534. 			    }

    7535. 

  7535. 			

    7536. 

  7536. 			    public override bool Equals(object o) {

    7537. 

  7537. 			        return o is C && Equals((C) o);

    7538. 

  7538. 			    }

    7539. 

  7539. 			

    7540. 

  7540. 			    public bool Equals(C c) {

    7541. 

  7541. 			        return c != null;

    7542. 

  7542. 			    }

    7543. 

  7543. 			

    7544. 

  7544. 			    public override int GetHashCode() {

    7545. 

  7545. 			        return 0;

    7546. 

  7546. 			    }

    7547. 

  7547. 			}

    7548. 

  7548. 			

    7549. 

  7549. 			public  class D : C, IEquatable<D> {

    7550. 

  7550. 			    public int Val;

    7551. 

  7551. 			    public D() {

    7552. 

  7552. 			    }

    7553. 

  7553. 			    public D(int val) {

    7554. 

  7554. 			        Val = val;

    7555. 

  7555. 			    }

    7556. 

  7556. 			

    7557. 

  7557. 			    public override bool Equals(object o) {

    7558. 

  7558. 			        return o is D && Equals((D) o);

    7559. 

  7559. 			    }

    7560. 

  7560. 			

    7561. 

  7561. 			    public bool Equals(D d) {

    7562. 

  7562. 			        return d != null && d.Val == Val;

    7563. 

  7563. 			    }

    7564. 

  7564. 			

    7565. 

  7565. 			    public override int GetHashCode() {

    7566. 

  7566. 			        return Val;

    7567. 

  7567. 			    }

    7568. 

  7568. 			}

    7569. 

  7569. 			

    7570. 

  7570. 			public enum E {

    7571. 

  7571. 			  A=1, B=2

    7572. 

  7572. 			}

    7573. 

  7573. 			

    7574. 

  7574. 			public enum El : long {

    7575. 

  7575. 			  A, B, C

    7576. 

  7576. 			}

    7577. 

  7577. 			

    7578. 

  7578. 			public struct S : IEquatable<S> {

    7579. 

  7579. 			    public override bool Equals(object o) {

    7580. 

  7580. 			        return (o is S) && Equals((S) o);

    7581. 

  7581. 			    }

    7582. 

  7582. 			    public bool Equals(S other) {

    7583. 

  7583. 			        return true;

    7584. 

  7584. 			    }

    7585. 

  7585. 			    public override int GetHashCode() {

    7586. 

  7586. 			        return 0;

    7587. 

  7587. 			    }

    7588. 

  7588. 			}

    7589. 

  7589. 			

    7590. 

  7590. 			public struct Sp : IEquatable<Sp> {

    7591. 

  7591. 			    public Sp(int i, double d) {

    7592. 

  7592. 			        I = i;

    7593. 

  7593. 			        D = d;

    7594. 

  7594. 			    }

    7595. 

  7595. 			

    7596. 

  7596. 			    public int I;

    7597. 

  7597. 			    public double D;

    7598. 

  7598. 			

    7599. 

  7599. 			    public override bool Equals(object o) {

    7600. 

  7600. 			        return (o is Sp) && Equals((Sp) o);

    7601. 

  7601. 			    }

    7602. 

  7602. 			    public bool Equals(Sp other) {

    7603. 

  7603. 			        return other.I == I && other.D == D;

    7604. 

  7604. 			    }

    7605. 

  7605. 			    public override int GetHashCode() {

    7606. 

  7606. 			        return I.GetHashCode() ^ D.GetHashCode();

    7607. 

  7607. 			    }

    7608. 

  7608. 			}

    7609. 

  7609. 			

    7610. 

  7610. 			public struct Ss : IEquatable<Ss> {

    7611. 

  7611. 			    public Ss(S s) {

    7612. 

  7612. 			        Val = s;

    7613. 

  7613. 			    }

    7614. 

  7614. 			

    7615. 

  7615. 			    public S Val;

    7616. 

  7616. 			

    7617. 

  7617. 			    public override bool Equals(object o) {

    7618. 

  7618. 			        return (o is Ss) && Equals((Ss) o);

    7619. 

  7619. 			    }

    7620. 

  7620. 			    public bool Equals(Ss other) {

    7621. 

  7621. 			        return other.Val.Equals(Val);

    7622. 

  7622. 			    }

    7623. 

  7623. 			    public override int GetHashCode() {

    7624. 

  7624. 			        return Val.GetHashCode();

    7625. 

  7625. 			    }

    7626. 

  7626. 			}

    7627. 

  7627. 			

    7628. 

  7628. 			public struct Sc : IEquatable<Sc> {

    7629. 

  7629. 			    public Sc(string s) {

    7630. 

  7630. 			        S = s;

    7631. 

  7631. 			    }

    7632. 

  7632. 			

    7633. 

  7633. 			    public string S;

    7634. 

  7634. 			

    7635. 

  7635. 			    public override bool Equals(object o) {

    7636. 

  7636. 			        return (o is Sc) && Equals((Sc) o);

    7637. 

  7637. 			    }

    7638. 

  7638. 			    public bool Equals(Sc other) {

    7639. 

  7639. 			        return other.S == S;

    7640. 

  7640. 			    }

    7641. 

  7641. 			    public override int GetHashCode() {

    7642. 

  7642. 			        return S.GetHashCode();

    7643. 

  7643. 			    }

    7644. 

  7644. 			}

    7645. 

  7645. 			

    7646. 

  7646. 			public struct Scs : IEquatable<Scs> {

    7647. 

  7647. 			    public Scs(string s, S val) {

    7648. 

  7648. 			        S = s;

    7649. 

  7649. 			        Val = val;

    7650. 

  7650. 			    }

    7651. 

  7651. 			

    7652. 

  7652. 			    public string S;

    7653. 

  7653. 			    public S Val;

    7654. 

  7654. 			

    7655. 

  7655. 			    public override bool Equals(object o) {

    7656. 

  7656. 			        return (o is Scs) && Equals((Scs) o);

    7657. 

  7657. 			    }

    7658. 

  7658. 			    public bool Equals(Scs other) {

    7659. 

  7659. 			        return other.S == S && other.Val.Equals(Val);

    7660. 

  7660. 			    }

    7661. 

  7661. 			    public override int GetHashCode() {

    7662. 

  7662. 			        return S.GetHashCode() ^ Val.GetHashCode();

    7663. 

  7663. 			    }

    7664. 

  7664. 			}

    7665. 

  7665. 			

    7666. 

  7666. 		

    7667. 

  7667. 	}

    7668. 

  7668. 				

    7669. 

  7669. 				//-------- Scenario 1748

    7670. 

  7670. 				namespace Scenario1748{

    7671. 

  7671. 					

    7672. 

  7672. 					public class Test

    7673. 

  7673. 					{

    7674. 

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

    7675. 

  7675. 				    public static Expression check34__() {

    7676. 

  7676. 				       if(Main() != 0 ) {

    7677. 

  7677. 				           throw new Exception();

    7678. 

  7678. 				       } else { 

    7679. 

  7679. 				           return Expression.Constant(0);

    7680. 

  7680. 				       }

    7681. 

  7681. 				    }

    7682. 

  7682. 					public     static int Main()

    7683. 

  7683. 					    {

    7684. 

  7684. 					        Ext.StartCapture();

    7685. 

  7685. 					        bool success = false;

    7686. 

  7686. 					        try

    7687. 

  7687. 					        {

    7688. 

  7688. 					            success = check34();

    7689. 

  7689. 					        }

    7690. 

  7690. 					        finally

    7691. 

  7691. 					        {

    7692. 

  7692. 					            Ext.StopCapture();

    7693. 

  7693. 					        }

    7694. 

  7694. 					        return success ? 0 : 1;

    7695. 

  7695. 					    }

    7696. 

  7696. 					

    7697. 

  7697. 					    static bool check34() {

    7698. 

  7698. 					        foreach (I val in new I[] { null, new C(), new D(), new D(0), new D(5) }) {

    7699. 

  7699. 					            if (!check34(val)) {

    7700. 

  7700. 					                return false;

    7701. 

  7701. 					            }

    7702. 

  7702. 					        }

    7703. 

  7703. 					        return true;

    7704. 

  7704. 					    }

    7705. 

  7705. 					

    7706. 

  7706. 					    static bool check34(I val) {

    7707. 

  7707. 					        Expression<Func<I>> e =

    7708. 

  7708. 					            Expression.Lambda<Func<I>>(

    7709. 

  7709. 					                Expression.Constant(val, typeof(I)),

    7710. 

  7710. 					                new System.Collections.Generic.List<ParameterExpression>());

    7711. 

  7711. 					        Func<I> f = e.Compile();

    7712. 

  7712. 					        return object.Equals(f(), val);

    7713. 

  7713. 					    }

    7714. 

  7714. 					}

    7715. 

  7715. 				

    7716. 

  7716. 				

    7717. 

  7717. 				public  static class Ext {

    7718. 

  7718. 				    public static void StartCapture() {

    7719. 

  7719. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7720. 

  7720. 				//        m.Invoke(null, new object[] { "test.dll" });

    7721. 

  7721. 				    }

    7722. 

  7722. 				

    7723. 

  7723. 				    public static void StopCapture() {

    7724. 

  7724. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7725. 

  7725. 				//        m.Invoke(null, new object[0]);

    7726. 

  7726. 				    }

    7727. 

  7727. 				

    7728. 

  7728. 				    public static bool IsIntegralOrEnum(Type type) {

    7729. 

  7729. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7730. 

  7730. 				            case TypeCode.Byte:

    7731. 

  7731. 				            case TypeCode.SByte:

    7732. 

  7732. 				            case TypeCode.Int16:

    7733. 

  7733. 				            case TypeCode.Int32:

    7734. 

  7734. 				            case TypeCode.Int64:

    7735. 

  7735. 				            case TypeCode.UInt16:

    7736. 

  7736. 				            case TypeCode.UInt32:

    7737. 

  7737. 				            case TypeCode.UInt64:

    7738. 

  7738. 				                return true;

    7739. 

  7739. 				            default:

    7740. 

  7740. 				                return false;

    7741. 

  7741. 				        }

    7742. 

  7742. 				    }

    7743. 

  7743. 				

    7744. 

  7744. 				    public static bool IsFloating(Type type) {

    7745. 

  7745. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7746. 

  7746. 				            case TypeCode.Single:

    7747. 

  7747. 				            case TypeCode.Double:

    7748. 

  7748. 				                return true;

    7749. 

  7749. 				            default:

    7750. 

  7750. 				                return false;

    7751. 

  7751. 				        }

    7752. 

  7752. 				    }

    7753. 

  7753. 				

    7754. 

  7754. 				    public static Type GetNonNullableType(Type type) {

    7755. 

  7755. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7756. 

  7756. 				                type.GetGenericArguments()[0] :

    7757. 

  7757. 				                type;

    7758. 

  7758. 				    }

    7759. 

  7759. 				}

    7760. 

  7760. 				

    7761. 

  7761. 			

    7762. 

  7762. 			

    7763. 

  7763. 			

    7764. 

  7764. 			public interface I {

    7765. 

  7765. 			  void M();

    7766. 

  7766. 			}

    7767. 

  7767. 			

    7768. 

  7768. 			public  class C : IEquatable<C>, I {

    7769. 

  7769. 			    void I.M() {

    7770. 

  7770. 			    }

    7771. 

  7771. 			

    7772. 

  7772. 			    public override bool Equals(object o) {

    7773. 

  7773. 			        return o is C && Equals((C) o);

    7774. 

  7774. 			    }

    7775. 

  7775. 			

    7776. 

  7776. 			    public bool Equals(C c) {

    7777. 

  7777. 			        return c != null;

    7778. 

  7778. 			    }

    7779. 

  7779. 			

    7780. 

  7780. 			    public override int GetHashCode() {

    7781. 

  7781. 			        return 0;

    7782. 

  7782. 			    }

    7783. 

  7783. 			}

    7784. 

  7784. 			

    7785. 

  7785. 			public  class D : C, IEquatable<D> {

    7786. 

  7786. 			    public int Val;

    7787. 

  7787. 			    public D() {

    7788. 

  7788. 			    }

    7789. 

  7789. 			    public D(int val) {

    7790. 

  7790. 			        Val = val;

    7791. 

  7791. 			    }

    7792. 

  7792. 			

    7793. 

  7793. 			    public override bool Equals(object o) {

    7794. 

  7794. 			        return o is D && Equals((D) o);

    7795. 

  7795. 			    }

    7796. 

  7796. 			

    7797. 

  7797. 			    public bool Equals(D d) {

    7798. 

  7798. 			        return d != null && d.Val == Val;

    7799. 

  7799. 			    }

    7800. 

  7800. 			

    7801. 

  7801. 			    public override int GetHashCode() {

    7802. 

  7802. 			        return Val;

    7803. 

  7803. 			    }

    7804. 

  7804. 			}

    7805. 

  7805. 			

    7806. 

  7806. 			public enum E {

    7807. 

  7807. 			  A=1, B=2

    7808. 

  7808. 			}

    7809. 

  7809. 			

    7810. 

  7810. 			public enum El : long {

    7811. 

  7811. 			  A, B, C

    7812. 

  7812. 			}

    7813. 

  7813. 			

    7814. 

  7814. 			public struct S : IEquatable<S> {

    7815. 

  7815. 			    public override bool Equals(object o) {

    7816. 

  7816. 			        return (o is S) && Equals((S) o);

    7817. 

  7817. 			    }

    7818. 

  7818. 			    public bool Equals(S other) {

    7819. 

  7819. 			        return true;

    7820. 

  7820. 			    }

    7821. 

  7821. 			    public override int GetHashCode() {

    7822. 

  7822. 			        return 0;

    7823. 

  7823. 			    }

    7824. 

  7824. 			}

    7825. 

  7825. 			

    7826. 

  7826. 			public struct Sp : IEquatable<Sp> {

    7827. 

  7827. 			    public Sp(int i, double d) {

    7828. 

  7828. 			        I = i;

    7829. 

  7829. 			        D = d;

    7830. 

  7830. 			    }

    7831. 

  7831. 			

    7832. 

  7832. 			    public int I;

    7833. 

  7833. 			    public double D;

    7834. 

  7834. 			

    7835. 

  7835. 			    public override bool Equals(object o) {

    7836. 

  7836. 			        return (o is Sp) && Equals((Sp) o);

    7837. 

  7837. 			    }

    7838. 

  7838. 			    public bool Equals(Sp other) {

    7839. 

  7839. 			        return other.I == I && other.D == D;

    7840. 

  7840. 			    }

    7841. 

  7841. 			    public override int GetHashCode() {

    7842. 

  7842. 			        return I.GetHashCode() ^ D.GetHashCode();

    7843. 

  7843. 			    }

    7844. 

  7844. 			}

    7845. 

  7845. 			

    7846. 

  7846. 			public struct Ss : IEquatable<Ss> {

    7847. 

  7847. 			    public Ss(S s) {

    7848. 

  7848. 			        Val = s;

    7849. 

  7849. 			    }

    7850. 

  7850. 			

    7851. 

  7851. 			    public S Val;

    7852. 

  7852. 			

    7853. 

  7853. 			    public override bool Equals(object o) {

    7854. 

  7854. 			        return (o is Ss) && Equals((Ss) o);

    7855. 

  7855. 			    }

    7856. 

  7856. 			    public bool Equals(Ss other) {

    7857. 

  7857. 			        return other.Val.Equals(Val);

    7858. 

  7858. 			    }

    7859. 

  7859. 			    public override int GetHashCode() {

    7860. 

  7860. 			        return Val.GetHashCode();

    7861. 

  7861. 			    }

    7862. 

  7862. 			}

    7863. 

  7863. 			

    7864. 

  7864. 			public struct Sc : IEquatable<Sc> {

    7865. 

  7865. 			    public Sc(string s) {

    7866. 

  7866. 			        S = s;

    7867. 

  7867. 			    }

    7868. 

  7868. 			

    7869. 

  7869. 			    public string S;

    7870. 

  7870. 			

    7871. 

  7871. 			    public override bool Equals(object o) {

    7872. 

  7872. 			        return (o is Sc) && Equals((Sc) o);

    7873. 

  7873. 			    }

    7874. 

  7874. 			    public bool Equals(Sc other) {

    7875. 

  7875. 			        return other.S == S;

    7876. 

  7876. 			    }

    7877. 

  7877. 			    public override int GetHashCode() {

    7878. 

  7878. 			        return S.GetHashCode();

    7879. 

  7879. 			    }

    7880. 

  7880. 			}

    7881. 

  7881. 			

    7882. 

  7882. 			public struct Scs : IEquatable<Scs> {

    7883. 

  7883. 			    public Scs(string s, S val) {

    7884. 

  7884. 			        S = s;

    7885. 

  7885. 			        Val = val;

    7886. 

  7886. 			    }

    7887. 

  7887. 			

    7888. 

  7888. 			    public string S;

    7889. 

  7889. 			    public S Val;

    7890. 

  7890. 			

    7891. 

  7891. 			    public override bool Equals(object o) {

    7892. 

  7892. 			        return (o is Scs) && Equals((Scs) o);

    7893. 

  7893. 			    }

    7894. 

  7894. 			    public bool Equals(Scs other) {

    7895. 

  7895. 			        return other.S == S && other.Val.Equals(Val);

    7896. 

  7896. 			    }

    7897. 

  7897. 			    public override int GetHashCode() {

    7898. 

  7898. 			        return S.GetHashCode() ^ Val.GetHashCode();

    7899. 

  7899. 			    }

    7900. 

  7900. 			}

    7901. 

  7901. 			

    7902. 

  7902. 		

    7903. 

  7903. 	}

    7904. 

  7904. 			

    7905. 

  7905. 			//-------- Scenario 1749

    7906. 

  7906. 			namespace Scenario1749{

    7907. 

  7907. 				

    7908. 

  7908. 				public class Test

    7909. 

  7909. 				{

    7910. 

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

    7911. 

  7911. 			    public static Expression check35__() {

    7912. 

  7912. 			       if(Main() != 0 ) {

    7913. 

  7913. 			           throw new Exception();

    7914. 

  7914. 			       } else { 

    7915. 

  7915. 			           return Expression.Constant(0);

    7916. 

  7916. 			       }

    7917. 

  7917. 			    }

    7918. 

  7918. 				public     static int Main()

    7919. 

  7919. 				    {

    7920. 

  7920. 				        Ext.StartCapture();

    7921. 

  7921. 				        bool success = false;

    7922. 

  7922. 				        try

    7923. 

  7923. 				        {

    7924. 

  7924. 				            success = check35();

    7925. 

  7925. 				        }

    7926. 

  7926. 				        finally

    7927. 

  7927. 				        {

    7928. 

  7928. 				            Ext.StopCapture();

    7929. 

  7929. 				        }

    7930. 

  7930. 				        return success ? 0 : 1;

    7931. 

  7931. 				    }

    7932. 

  7932. 				

    7933. 

  7933. 				    static bool check35() {

    7934. 

  7934. 				        foreach (byte? val in new byte?[] { null, 0, 1, byte.MaxValue }) {

    7935. 

  7935. 				            if (!check35(val)) {

    7936. 

  7936. 				                return false;

    7937. 

  7937. 				            }

    7938. 

  7938. 				        }

    7939. 

  7939. 				        return true;

    7940. 

  7940. 				    }

    7941. 

  7941. 				

    7942. 

  7942. 				    static bool check35(byte? val) {

    7943. 

  7943. 				        Expression<Func<byte?>> e =

    7944. 

  7944. 				            Expression.Lambda<Func<byte?>>(

    7945. 

  7945. 				                Expression.Constant(val, typeof(byte?)),

    7946. 

  7946. 				                new System.Collections.Generic.List<ParameterExpression>());

    7947. 

  7947. 				        Func<byte?> f = e.Compile();

    7948. 

  7948. 				        return object.Equals(f(), val);

    7949. 

  7949. 				    }

    7950. 

  7950. 				}

    7951. 

  7951. 			

    7952. 

  7952. 			

    7953. 

  7953. 			public  static class Ext {

    7954. 

  7954. 			    public static void StartCapture() {

    7955. 

  7955. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7956. 

  7956. 			//        m.Invoke(null, new object[] { "test.dll" });

    7957. 

  7957. 			    }

    7958. 

  7958. 			

    7959. 

  7959. 			    public static void StopCapture() {

    7960. 

  7960. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    7961. 

  7961. 			//        m.Invoke(null, new object[0]);

    7962. 

  7962. 			    }

    7963. 

  7963. 			

    7964. 

  7964. 			    public static bool IsIntegralOrEnum(Type type) {

    7965. 

  7965. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7966. 

  7966. 			            case TypeCode.Byte:

    7967. 

  7967. 			            case TypeCode.SByte:

    7968. 

  7968. 			            case TypeCode.Int16:

    7969. 

  7969. 			            case TypeCode.Int32:

    7970. 

  7970. 			            case TypeCode.Int64:

    7971. 

  7971. 			            case TypeCode.UInt16:

    7972. 

  7972. 			            case TypeCode.UInt32:

    7973. 

  7973. 			            case TypeCode.UInt64:

    7974. 

  7974. 			                return true;

    7975. 

  7975. 			            default:

    7976. 

  7976. 			                return false;

    7977. 

  7977. 			        }

    7978. 

  7978. 			    }

    7979. 

  7979. 			

    7980. 

  7980. 			    public static bool IsFloating(Type type) {

    7981. 

  7981. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    7982. 

  7982. 			            case TypeCode.Single:

    7983. 

  7983. 			            case TypeCode.Double:

    7984. 

  7984. 			                return true;

    7985. 

  7985. 			            default:

    7986. 

  7986. 			                return false;

    7987. 

  7987. 			        }

    7988. 

  7988. 			    }

    7989. 

  7989. 			

    7990. 

  7990. 			    public static Type GetNonNullableType(Type type) {

    7991. 

  7991. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    7992. 

  7992. 			                type.GetGenericArguments()[0] :

    7993. 

  7993. 			                type;

    7994. 

  7994. 			    }

    7995. 

  7995. 			}

    7996. 

  7996. 			

    7997. 

  7997. 		

    7998. 

  7998. 	}

    7999. 

  7999. 			

    8000. 

  8000. 			//-------- Scenario 1750

    8001. 

  8001. 			namespace Scenario1750{

    8002. 

  8002. 				

    8003. 

  8003. 				public class Test

    8004. 

  8004. 				{

    8005. 

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

    8006. 

  8006. 			    public static Expression check36__() {

    8007. 

  8007. 			       if(Main() != 0 ) {

    8008. 

  8008. 			           throw new Exception();

    8009. 

  8009. 			       } else { 

    8010. 

  8010. 			           return Expression.Constant(0);

    8011. 

  8011. 			       }

    8012. 

  8012. 			    }

    8013. 

  8013. 				public     static int Main()

    8014. 

  8014. 				    {

    8015. 

  8015. 				        Ext.StartCapture();

    8016. 

  8016. 				        bool success = false;

    8017. 

  8017. 				        try

    8018. 

  8018. 				        {

    8019. 

  8019. 				            success = check36();

    8020. 

  8020. 				        }

    8021. 

  8021. 				        finally

    8022. 

  8022. 				        {

    8023. 

  8023. 				            Ext.StopCapture();

    8024. 

  8024. 				        }

    8025. 

  8025. 				        return success ? 0 : 1;

    8026. 

  8026. 				    }

    8027. 

  8027. 				

    8028. 

  8028. 				    static bool check36() {

    8029. 

  8029. 				        foreach (ushort? val in new ushort?[] { null, 0, 1, ushort.MaxValue }) {

    8030. 

  8030. 				            if (!check36(val)) {

    8031. 

  8031. 				                return false;

    8032. 

  8032. 				            }

    8033. 

  8033. 				        }

    8034. 

  8034. 				        return true;

    8035. 

  8035. 				    }

    8036. 

  8036. 				

    8037. 

  8037. 				    static bool check36(ushort? val) {

    8038. 

  8038. 				        Expression<Func<ushort?>> e =

    8039. 

  8039. 				            Expression.Lambda<Func<ushort?>>(

    8040. 

  8040. 				                Expression.Constant(val, typeof(ushort?)),

    8041. 

  8041. 				                new System.Collections.Generic.List<ParameterExpression>());

    8042. 

  8042. 				        Func<ushort?> f = e.Compile();

    8043. 

  8043. 				        return object.Equals(f(), val);

    8044. 

  8044. 				    }

    8045. 

  8045. 				}

    8046. 

  8046. 			

    8047. 

  8047. 			

    8048. 

  8048. 			public  static class Ext {

    8049. 

  8049. 			    public static void StartCapture() {

    8050. 

  8050. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8051. 

  8051. 			//        m.Invoke(null, new object[] { "test.dll" });

    8052. 

  8052. 			    }

    8053. 

  8053. 			

    8054. 

  8054. 			    public static void StopCapture() {

    8055. 

  8055. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8056. 

  8056. 			//        m.Invoke(null, new object[0]);

    8057. 

  8057. 			    }

    8058. 

  8058. 			

    8059. 

  8059. 			    public static bool IsIntegralOrEnum(Type type) {

    8060. 

  8060. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8061. 

  8061. 			            case TypeCode.Byte:

    8062. 

  8062. 			            case TypeCode.SByte:

    8063. 

  8063. 			            case TypeCode.Int16:

    8064. 

  8064. 			            case TypeCode.Int32:

    8065. 

  8065. 			            case TypeCode.Int64:

    8066. 

  8066. 			            case TypeCode.UInt16:

    8067. 

  8067. 			            case TypeCode.UInt32:

    8068. 

  8068. 			            case TypeCode.UInt64:

    8069. 

  8069. 			                return true;

    8070. 

  8070. 			            default:

    8071. 

  8071. 			                return false;

    8072. 

  8072. 			        }

    8073. 

  8073. 			    }

    8074. 

  8074. 			

    8075. 

  8075. 			    public static bool IsFloating(Type type) {

    8076. 

  8076. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8077. 

  8077. 			            case TypeCode.Single:

    8078. 

  8078. 			            case TypeCode.Double:

    8079. 

  8079. 			                return true;

    8080. 

  8080. 			            default:

    8081. 

  8081. 			                return false;

    8082. 

  8082. 			        }

    8083. 

  8083. 			    }

    8084. 

  8084. 			

    8085. 

  8085. 			    public static Type GetNonNullableType(Type type) {

    8086. 

  8086. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8087. 

  8087. 			                type.GetGenericArguments()[0] :

    8088. 

  8088. 			                type;

    8089. 

  8089. 			    }

    8090. 

  8090. 			}

    8091. 

  8091. 			

    8092. 

  8092. 		

    8093. 

  8093. 	}

    8094. 

  8094. 			

    8095. 

  8095. 			//-------- Scenario 1751

    8096. 

  8096. 			namespace Scenario1751{

    8097. 

  8097. 				

    8098. 

  8098. 				public class Test

    8099. 

  8099. 				{

    8100. 

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

    8101. 

  8101. 			    public static Expression check37__() {

    8102. 

  8102. 			       if(Main() != 0 ) {

    8103. 

  8103. 			           throw new Exception();

    8104. 

  8104. 			       } else { 

    8105. 

  8105. 			           return Expression.Constant(0);

    8106. 

  8106. 			       }

    8107. 

  8107. 			    }

    8108. 

  8108. 				public     static int Main()

    8109. 

  8109. 				    {

    8110. 

  8110. 				        Ext.StartCapture();

    8111. 

  8111. 				        bool success = false;

    8112. 

  8112. 				        try

    8113. 

  8113. 				        {

    8114. 

  8114. 				            success = check37();

    8115. 

  8115. 				        }

    8116. 

  8116. 				        finally

    8117. 

  8117. 				        {

    8118. 

  8118. 				            Ext.StopCapture();

    8119. 

  8119. 				        }

    8120. 

  8120. 				        return success ? 0 : 1;

    8121. 

  8121. 				    }

    8122. 

  8122. 				

    8123. 

  8123. 				    static bool check37() {

    8124. 

  8124. 				        foreach (uint? val in new uint?[] { null, 0, 1, uint.MaxValue }) {

    8125. 

  8125. 				            if (!check37(val)) {

    8126. 

  8126. 				                return false;

    8127. 

  8127. 				            }

    8128. 

  8128. 				        }

    8129. 

  8129. 				        return true;

    8130. 

  8130. 				    }

    8131. 

  8131. 				

    8132. 

  8132. 				    static bool check37(uint? val) {

    8133. 

  8133. 				        Expression<Func<uint?>> e =

    8134. 

  8134. 				            Expression.Lambda<Func<uint?>>(

    8135. 

  8135. 				                Expression.Constant(val, typeof(uint?)),

    8136. 

  8136. 				                new System.Collections.Generic.List<ParameterExpression>());

    8137. 

  8137. 				        Func<uint?> f = e.Compile();

    8138. 

  8138. 				        return object.Equals(f(), val);

    8139. 

  8139. 				    }

    8140. 

  8140. 				}

    8141. 

  8141. 			

    8142. 

  8142. 			

    8143. 

  8143. 			public  static class Ext {

    8144. 

  8144. 			    public static void StartCapture() {

    8145. 

  8145. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8146. 

  8146. 			//        m.Invoke(null, new object[] { "test.dll" });

    8147. 

  8147. 			    }

    8148. 

  8148. 			

    8149. 

  8149. 			    public static void StopCapture() {

    8150. 

  8150. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8151. 

  8151. 			//        m.Invoke(null, new object[0]);

    8152. 

  8152. 			    }

    8153. 

  8153. 			

    8154. 

  8154. 			    public static bool IsIntegralOrEnum(Type type) {

    8155. 

  8155. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8156. 

  8156. 			            case TypeCode.Byte:

    8157. 

  8157. 			            case TypeCode.SByte:

    8158. 

  8158. 			            case TypeCode.Int16:

    8159. 

  8159. 			            case TypeCode.Int32:

    8160. 

  8160. 			            case TypeCode.Int64:

    8161. 

  8161. 			            case TypeCode.UInt16:

    8162. 

  8162. 			            case TypeCode.UInt32:

    8163. 

  8163. 			            case TypeCode.UInt64:

    8164. 

  8164. 			                return true;

    8165. 

  8165. 			            default:

    8166. 

  8166. 			                return false;

    8167. 

  8167. 			        }

    8168. 

  8168. 			    }

    8169. 

  8169. 			

    8170. 

  8170. 			    public static bool IsFloating(Type type) {

    8171. 

  8171. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8172. 

  8172. 			            case TypeCode.Single:

    8173. 

  8173. 			            case TypeCode.Double:

    8174. 

  8174. 			                return true;

    8175. 

  8175. 			            default:

    8176. 

  8176. 			                return false;

    8177. 

  8177. 			        }

    8178. 

  8178. 			    }

    8179. 

  8179. 			

    8180. 

  8180. 			    public static Type GetNonNullableType(Type type) {

    8181. 

  8181. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8182. 

  8182. 			                type.GetGenericArguments()[0] :

    8183. 

  8183. 			                type;

    8184. 

  8184. 			    }

    8185. 

  8185. 			}

    8186. 

  8186. 			

    8187. 

  8187. 		

    8188. 

  8188. 	}

    8189. 

  8189. 			

    8190. 

  8190. 			//-------- Scenario 1752

    8191. 

  8191. 			namespace Scenario1752{

    8192. 

  8192. 				

    8193. 

  8193. 				public class Test

    8194. 

  8194. 				{

    8195. 

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

    8196. 

  8196. 			    public static Expression check38__() {

    8197. 

  8197. 			       if(Main() != 0 ) {

    8198. 

  8198. 			           throw new Exception();

    8199. 

  8199. 			       } else { 

    8200. 

  8200. 			           return Expression.Constant(0);

    8201. 

  8201. 			       }

    8202. 

  8202. 			    }

    8203. 

  8203. 				public     static int Main()

    8204. 

  8204. 				    {

    8205. 

  8205. 				        Ext.StartCapture();

    8206. 

  8206. 				        bool success = false;

    8207. 

  8207. 				        try

    8208. 

  8208. 				        {

    8209. 

  8209. 				            success = check38();

    8210. 

  8210. 				        }

    8211. 

  8211. 				        finally

    8212. 

  8212. 				        {

    8213. 

  8213. 				            Ext.StopCapture();

    8214. 

  8214. 				        }

    8215. 

  8215. 				        return success ? 0 : 1;

    8216. 

  8216. 				    }

    8217. 

  8217. 				

    8218. 

  8218. 				    static bool check38() {

    8219. 

  8219. 				        foreach (ulong? val in new ulong?[] { null, 0, 1, ulong.MaxValue }) {

    8220. 

  8220. 				            if (!check38(val)) {

    8221. 

  8221. 				                return false;

    8222. 

  8222. 				            }

    8223. 

  8223. 				        }

    8224. 

  8224. 				        return true;

    8225. 

  8225. 				    }

    8226. 

  8226. 				

    8227. 

  8227. 				    static bool check38(ulong? val) {

    8228. 

  8228. 				        Expression<Func<ulong?>> e =

    8229. 

  8229. 				            Expression.Lambda<Func<ulong?>>(

    8230. 

  8230. 				                Expression.Constant(val, typeof(ulong?)),

    8231. 

  8231. 				                new System.Collections.Generic.List<ParameterExpression>());

    8232. 

  8232. 				        Func<ulong?> f = e.Compile();

    8233. 

  8233. 				        return object.Equals(f(), val);

    8234. 

  8234. 				    }

    8235. 

  8235. 				}

    8236. 

  8236. 			

    8237. 

  8237. 			

    8238. 

  8238. 			public  static class Ext {

    8239. 

  8239. 			    public static void StartCapture() {

    8240. 

  8240. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8241. 

  8241. 			//        m.Invoke(null, new object[] { "test.dll" });

    8242. 

  8242. 			    }

    8243. 

  8243. 			

    8244. 

  8244. 			    public static void StopCapture() {

    8245. 

  8245. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8246. 

  8246. 			//        m.Invoke(null, new object[0]);

    8247. 

  8247. 			    }

    8248. 

  8248. 			

    8249. 

  8249. 			    public static bool IsIntegralOrEnum(Type type) {

    8250. 

  8250. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8251. 

  8251. 			            case TypeCode.Byte:

    8252. 

  8252. 			            case TypeCode.SByte:

    8253. 

  8253. 			            case TypeCode.Int16:

    8254. 

  8254. 			            case TypeCode.Int32:

    8255. 

  8255. 			            case TypeCode.Int64:

    8256. 

  8256. 			            case TypeCode.UInt16:

    8257. 

  8257. 			            case TypeCode.UInt32:

    8258. 

  8258. 			            case TypeCode.UInt64:

    8259. 

  8259. 			                return true;

    8260. 

  8260. 			            default:

    8261. 

  8261. 			                return false;

    8262. 

  8262. 			        }

    8263. 

  8263. 			    }

    8264. 

  8264. 			

    8265. 

  8265. 			    public static bool IsFloating(Type type) {

    8266. 

  8266. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8267. 

  8267. 			            case TypeCode.Single:

    8268. 

  8268. 			            case TypeCode.Double:

    8269. 

  8269. 			                return true;

    8270. 

  8270. 			            default:

    8271. 

  8271. 			                return false;

    8272. 

  8272. 			        }

    8273. 

  8273. 			    }

    8274. 

  8274. 			

    8275. 

  8275. 			    public static Type GetNonNullableType(Type type) {

    8276. 

  8276. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8277. 

  8277. 			                type.GetGenericArguments()[0] :

    8278. 

  8278. 			                type;

    8279. 

  8279. 			    }

    8280. 

  8280. 			}

    8281. 

  8281. 			

    8282. 

  8282. 		

    8283. 

  8283. 	}

    8284. 

  8284. 			

    8285. 

  8285. 			//-------- Scenario 1753

    8286. 

  8286. 			namespace Scenario1753{

    8287. 

  8287. 				

    8288. 

  8288. 				public class Test

    8289. 

  8289. 				{

    8290. 

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

    8291. 

  8291. 			    public static Expression check39__() {

    8292. 

  8292. 			       if(Main() != 0 ) {

    8293. 

  8293. 			           throw new Exception();

    8294. 

  8294. 			       } else { 

    8295. 

  8295. 			           return Expression.Constant(0);

    8296. 

  8296. 			       }

    8297. 

  8297. 			    }

    8298. 

  8298. 				public     static int Main()

    8299. 

  8299. 				    {

    8300. 

  8300. 				        Ext.StartCapture();

    8301. 

  8301. 				        bool success = false;

    8302. 

  8302. 				        try

    8303. 

  8303. 				        {

    8304. 

  8304. 				            success = check39();

    8305. 

  8305. 				        }

    8306. 

  8306. 				        finally

    8307. 

  8307. 				        {

    8308. 

  8308. 				            Ext.StopCapture();

    8309. 

  8309. 				        }

    8310. 

  8310. 				        return success ? 0 : 1;

    8311. 

  8311. 				    }

    8312. 

  8312. 				

    8313. 

  8313. 				    static bool check39() {

    8314. 

  8314. 				        foreach (sbyte? val in new sbyte?[] { null, 0, 1, -1, sbyte.MinValue, sbyte.MaxValue }) {

    8315. 

  8315. 				            if (!check39(val)) {

    8316. 

  8316. 				                return false;

    8317. 

  8317. 				            }

    8318. 

  8318. 				        }

    8319. 

  8319. 				        return true;

    8320. 

  8320. 				    }

    8321. 

  8321. 				

    8322. 

  8322. 				    static bool check39(sbyte? val) {

    8323. 

  8323. 				        Expression<Func<sbyte?>> e =

    8324. 

  8324. 				            Expression.Lambda<Func<sbyte?>>(

    8325. 

  8325. 				                Expression.Constant(val, typeof(sbyte?)),

    8326. 

  8326. 				                new System.Collections.Generic.List<ParameterExpression>());

    8327. 

  8327. 				        Func<sbyte?> f = e.Compile();

    8328. 

  8328. 				        return object.Equals(f(), val);

    8329. 

  8329. 				    }

    8330. 

  8330. 				}

    8331. 

  8331. 			

    8332. 

  8332. 			

    8333. 

  8333. 			public  static class Ext {

    8334. 

  8334. 			    public static void StartCapture() {

    8335. 

  8335. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8336. 

  8336. 			//        m.Invoke(null, new object[] { "test.dll" });

    8337. 

  8337. 			    }

    8338. 

  8338. 			

    8339. 

  8339. 			    public static void StopCapture() {

    8340. 

  8340. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8341. 

  8341. 			//        m.Invoke(null, new object[0]);

    8342. 

  8342. 			    }

    8343. 

  8343. 			

    8344. 

  8344. 			    public static bool IsIntegralOrEnum(Type type) {

    8345. 

  8345. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8346. 

  8346. 			            case TypeCode.Byte:

    8347. 

  8347. 			            case TypeCode.SByte:

    8348. 

  8348. 			            case TypeCode.Int16:

    8349. 

  8349. 			            case TypeCode.Int32:

    8350. 

  8350. 			            case TypeCode.Int64:

    8351. 

  8351. 			            case TypeCode.UInt16:

    8352. 

  8352. 			            case TypeCode.UInt32:

    8353. 

  8353. 			            case TypeCode.UInt64:

    8354. 

  8354. 			                return true;

    8355. 

  8355. 			            default:

    8356. 

  8356. 			                return false;

    8357. 

  8357. 			        }

    8358. 

  8358. 			    }

    8359. 

  8359. 			

    8360. 

  8360. 			    public static bool IsFloating(Type type) {

    8361. 

  8361. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8362. 

  8362. 			            case TypeCode.Single:

    8363. 

  8363. 			            case TypeCode.Double:

    8364. 

  8364. 			                return true;

    8365. 

  8365. 			            default:

    8366. 

  8366. 			                return false;

    8367. 

  8367. 			        }

    8368. 

  8368. 			    }

    8369. 

  8369. 			

    8370. 

  8370. 			    public static Type GetNonNullableType(Type type) {

    8371. 

  8371. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8372. 

  8372. 			                type.GetGenericArguments()[0] :

    8373. 

  8373. 			                type;

    8374. 

  8374. 			    }

    8375. 

  8375. 			}

    8376. 

  8376. 			

    8377. 

  8377. 		

    8378. 

  8378. 	}

    8379. 

  8379. 			

    8380. 

  8380. 			//-------- Scenario 1754

    8381. 

  8381. 			namespace Scenario1754{

    8382. 

  8382. 				

    8383. 

  8383. 				public class Test

    8384. 

  8384. 				{

    8385. 

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

    8386. 

  8386. 			    public static Expression check40__() {

    8387. 

  8387. 			       if(Main() != 0 ) {

    8388. 

  8388. 			           throw new Exception();

    8389. 

  8389. 			       } else { 

    8390. 

  8390. 			           return Expression.Constant(0);

    8391. 

  8391. 			       }

    8392. 

  8392. 			    }

    8393. 

  8393. 				public     static int Main()

    8394. 

  8394. 				    {

    8395. 

  8395. 				        Ext.StartCapture();

    8396. 

  8396. 				        bool success = false;

    8397. 

  8397. 				        try

    8398. 

  8398. 				        {

    8399. 

  8399. 				            success = check40();

    8400. 

  8400. 				        }

    8401. 

  8401. 				        finally

    8402. 

  8402. 				        {

    8403. 

  8403. 				            Ext.StopCapture();

    8404. 

  8404. 				        }

    8405. 

  8405. 				        return success ? 0 : 1;

    8406. 

  8406. 				    }

    8407. 

  8407. 				

    8408. 

  8408. 				    static bool check40() {

    8409. 

  8409. 				        foreach (short? val in new short?[] { null, 0, 1, -1, short.MinValue, short.MaxValue }) {

    8410. 

  8410. 				            if (!check40(val)) {

    8411. 

  8411. 				                return false;

    8412. 

  8412. 				            }

    8413. 

  8413. 				        }

    8414. 

  8414. 				        return true;

    8415. 

  8415. 				    }

    8416. 

  8416. 				

    8417. 

  8417. 				    static bool check40(short? val) {

    8418. 

  8418. 				        Expression<Func<short?>> e =

    8419. 

  8419. 				            Expression.Lambda<Func<short?>>(

    8420. 

  8420. 				                Expression.Constant(val, typeof(short?)),

    8421. 

  8421. 				                new System.Collections.Generic.List<ParameterExpression>());

    8422. 

  8422. 				        Func<short?> f = e.Compile();

    8423. 

  8423. 				        return object.Equals(f(), val);

    8424. 

  8424. 				    }

    8425. 

  8425. 				}

    8426. 

  8426. 			

    8427. 

  8427. 			

    8428. 

  8428. 			public  static class Ext {

    8429. 

  8429. 			    public static void StartCapture() {

    8430. 

  8430. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8431. 

  8431. 			//        m.Invoke(null, new object[] { "test.dll" });

    8432. 

  8432. 			    }

    8433. 

  8433. 			

    8434. 

  8434. 			    public static void StopCapture() {

    8435. 

  8435. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8436. 

  8436. 			//        m.Invoke(null, new object[0]);

    8437. 

  8437. 			    }

    8438. 

  8438. 			

    8439. 

  8439. 			    public static bool IsIntegralOrEnum(Type type) {

    8440. 

  8440. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8441. 

  8441. 			            case TypeCode.Byte:

    8442. 

  8442. 			            case TypeCode.SByte:

    8443. 

  8443. 			            case TypeCode.Int16:

    8444. 

  8444. 			            case TypeCode.Int32:

    8445. 

  8445. 			            case TypeCode.Int64:

    8446. 

  8446. 			            case TypeCode.UInt16:

    8447. 

  8447. 			            case TypeCode.UInt32:

    8448. 

  8448. 			            case TypeCode.UInt64:

    8449. 

  8449. 			                return true;

    8450. 

  8450. 			            default:

    8451. 

  8451. 			                return false;

    8452. 

  8452. 			        }

    8453. 

  8453. 			    }

    8454. 

  8454. 			

    8455. 

  8455. 			    public static bool IsFloating(Type type) {

    8456. 

  8456. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8457. 

  8457. 			            case TypeCode.Single:

    8458. 

  8458. 			            case TypeCode.Double:

    8459. 

  8459. 			                return true;

    8460. 

  8460. 			            default:

    8461. 

  8461. 			                return false;

    8462. 

  8462. 			        }

    8463. 

  8463. 			    }

    8464. 

  8464. 			

    8465. 

  8465. 			    public static Type GetNonNullableType(Type type) {

    8466. 

  8466. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8467. 

  8467. 			                type.GetGenericArguments()[0] :

    8468. 

  8468. 			                type;

    8469. 

  8469. 			    }

    8470. 

  8470. 			}

    8471. 

  8471. 			

    8472. 

  8472. 		

    8473. 

  8473. 	}

    8474. 

  8474. 			

    8475. 

  8475. 			//-------- Scenario 1755

    8476. 

  8476. 			namespace Scenario1755{

    8477. 

  8477. 				

    8478. 

  8478. 				public class Test

    8479. 

  8479. 				{

    8480. 

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

    8481. 

  8481. 			    public static Expression check41__() {

    8482. 

  8482. 			       if(Main() != 0 ) {

    8483. 

  8483. 			           throw new Exception();

    8484. 

  8484. 			       } else { 

    8485. 

  8485. 			           return Expression.Constant(0);

    8486. 

  8486. 			       }

    8487. 

  8487. 			    }

    8488. 

  8488. 				public     static int Main()

    8489. 

  8489. 				    {

    8490. 

  8490. 				        Ext.StartCapture();

    8491. 

  8491. 				        bool success = false;

    8492. 

  8492. 				        try

    8493. 

  8493. 				        {

    8494. 

  8494. 				            success = check41();

    8495. 

  8495. 				        }

    8496. 

  8496. 				        finally

    8497. 

  8497. 				        {

    8498. 

  8498. 				            Ext.StopCapture();

    8499. 

  8499. 				        }

    8500. 

  8500. 				        return success ? 0 : 1;

    8501. 

  8501. 				    }

    8502. 

  8502. 				

    8503. 

  8503. 				    static bool check41() {

    8504. 

  8504. 				        foreach (int? val in new int?[] { null, 0, 1, -1, int.MinValue, int.MaxValue }) {

    8505. 

  8505. 				            if (!check41(val)) {

    8506. 

  8506. 				                return false;

    8507. 

  8507. 				            }

    8508. 

  8508. 				        }

    8509. 

  8509. 				        return true;

    8510. 

  8510. 				    }

    8511. 

  8511. 				

    8512. 

  8512. 				    static bool check41(int? val) {

    8513. 

  8513. 				        Expression<Func<int?>> e =

    8514. 

  8514. 				            Expression.Lambda<Func<int?>>(

    8515. 

  8515. 				                Expression.Constant(val, typeof(int?)),

    8516. 

  8516. 				                new System.Collections.Generic.List<ParameterExpression>());

    8517. 

  8517. 				        Func<int?> f = e.Compile();

    8518. 

  8518. 				        return object.Equals(f(), val);

    8519. 

  8519. 				    }

    8520. 

  8520. 				}

    8521. 

  8521. 			

    8522. 

  8522. 			

    8523. 

  8523. 			public  static class Ext {

    8524. 

  8524. 			    public static void StartCapture() {

    8525. 

  8525. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8526. 

  8526. 			//        m.Invoke(null, new object[] { "test.dll" });

    8527. 

  8527. 			    }

    8528. 

  8528. 			

    8529. 

  8529. 			    public static void StopCapture() {

    8530. 

  8530. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8531. 

  8531. 			//        m.Invoke(null, new object[0]);

    8532. 

  8532. 			    }

    8533. 

  8533. 			

    8534. 

  8534. 			    public static bool IsIntegralOrEnum(Type type) {

    8535. 

  8535. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8536. 

  8536. 			            case TypeCode.Byte:

    8537. 

  8537. 			            case TypeCode.SByte:

    8538. 

  8538. 			            case TypeCode.Int16:

    8539. 

  8539. 			            case TypeCode.Int32:

    8540. 

  8540. 			            case TypeCode.Int64:

    8541. 

  8541. 			            case TypeCode.UInt16:

    8542. 

  8542. 			            case TypeCode.UInt32:

    8543. 

  8543. 			            case TypeCode.UInt64:

    8544. 

  8544. 			                return true;

    8545. 

  8545. 			            default:

    8546. 

  8546. 			                return false;

    8547. 

  8547. 			        }

    8548. 

  8548. 			    }

    8549. 

  8549. 			

    8550. 

  8550. 			    public static bool IsFloating(Type type) {

    8551. 

  8551. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8552. 

  8552. 			            case TypeCode.Single:

    8553. 

  8553. 			            case TypeCode.Double:

    8554. 

  8554. 			                return true;

    8555. 

  8555. 			            default:

    8556. 

  8556. 			                return false;

    8557. 

  8557. 			        }

    8558. 

  8558. 			    }

    8559. 

  8559. 			

    8560. 

  8560. 			    public static Type GetNonNullableType(Type type) {

    8561. 

  8561. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8562. 

  8562. 			                type.GetGenericArguments()[0] :

    8563. 

  8563. 			                type;

    8564. 

  8564. 			    }

    8565. 

  8565. 			}

    8566. 

  8566. 			

    8567. 

  8567. 		

    8568. 

  8568. 	}

    8569. 

  8569. 			

    8570. 

  8570. 			//-------- Scenario 1756

    8571. 

  8571. 			namespace Scenario1756{

    8572. 

  8572. 				

    8573. 

  8573. 				public class Test

    8574. 

  8574. 				{

    8575. 

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

    8576. 

  8576. 			    public static Expression check42__() {

    8577. 

  8577. 			       if(Main() != 0 ) {

    8578. 

  8578. 			           throw new Exception();

    8579. 

  8579. 			       } else { 

    8580. 

  8580. 			           return Expression.Constant(0);

    8581. 

  8581. 			       }

    8582. 

  8582. 			    }

    8583. 

  8583. 				public     static int Main()

    8584. 

  8584. 				    {

    8585. 

  8585. 				        Ext.StartCapture();

    8586. 

  8586. 				        bool success = false;

    8587. 

  8587. 				        try

    8588. 

  8588. 				        {

    8589. 

  8589. 				            success = check42();

    8590. 

  8590. 				        }

    8591. 

  8591. 				        finally

    8592. 

  8592. 				        {

    8593. 

  8593. 				            Ext.StopCapture();

    8594. 

  8594. 				        }

    8595. 

  8595. 				        return success ? 0 : 1;

    8596. 

  8596. 				    }

    8597. 

  8597. 				

    8598. 

  8598. 				    static bool check42() {

    8599. 

  8599. 				        foreach (long? val in new long?[] { null, 0, 1, -1, long.MinValue, long.MaxValue }) {

    8600. 

  8600. 				            if (!check42(val)) {

    8601. 

  8601. 				                return false;

    8602. 

  8602. 				            }

    8603. 

  8603. 				        }

    8604. 

  8604. 				        return true;

    8605. 

  8605. 				    }

    8606. 

  8606. 				

    8607. 

  8607. 				    static bool check42(long? val) {

    8608. 

  8608. 				        Expression<Func<long?>> e =

    8609. 

  8609. 				            Expression.Lambda<Func<long?>>(

    8610. 

  8610. 				                Expression.Constant(val, typeof(long?)),

    8611. 

  8611. 				                new System.Collections.Generic.List<ParameterExpression>());

    8612. 

  8612. 				        Func<long?> f = e.Compile();

    8613. 

  8613. 				        return object.Equals(f(), val);

    8614. 

  8614. 				    }

    8615. 

  8615. 				}

    8616. 

  8616. 			

    8617. 

  8617. 			

    8618. 

  8618. 			public  static class Ext {

    8619. 

  8619. 			    public static void StartCapture() {

    8620. 

  8620. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8621. 

  8621. 			//        m.Invoke(null, new object[] { "test.dll" });

    8622. 

  8622. 			    }

    8623. 

  8623. 			

    8624. 

  8624. 			    public static void StopCapture() {

    8625. 

  8625. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8626. 

  8626. 			//        m.Invoke(null, new object[0]);

    8627. 

  8627. 			    }

    8628. 

  8628. 			

    8629. 

  8629. 			    public static bool IsIntegralOrEnum(Type type) {

    8630. 

  8630. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8631. 

  8631. 			            case TypeCode.Byte:

    8632. 

  8632. 			            case TypeCode.SByte:

    8633. 

  8633. 			            case TypeCode.Int16:

    8634. 

  8634. 			            case TypeCode.Int32:

    8635. 

  8635. 			            case TypeCode.Int64:

    8636. 

  8636. 			            case TypeCode.UInt16:

    8637. 

  8637. 			            case TypeCode.UInt32:

    8638. 

  8638. 			            case TypeCode.UInt64:

    8639. 

  8639. 			                return true;

    8640. 

  8640. 			            default:

    8641. 

  8641. 			                return false;

    8642. 

  8642. 			        }

    8643. 

  8643. 			    }

    8644. 

  8644. 			

    8645. 

  8645. 			    public static bool IsFloating(Type type) {

    8646. 

  8646. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8647. 

  8647. 			            case TypeCode.Single:

    8648. 

  8648. 			            case TypeCode.Double:

    8649. 

  8649. 			                return true;

    8650. 

  8650. 			            default:

    8651. 

  8651. 			                return false;

    8652. 

  8652. 			        }

    8653. 

  8653. 			    }

    8654. 

  8654. 			

    8655. 

  8655. 			    public static Type GetNonNullableType(Type type) {

    8656. 

  8656. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8657. 

  8657. 			                type.GetGenericArguments()[0] :

    8658. 

  8658. 			                type;

    8659. 

  8659. 			    }

    8660. 

  8660. 			}

    8661. 

  8661. 			

    8662. 

  8662. 		

    8663. 

  8663. 	}

    8664. 

  8664. 			

    8665. 

  8665. 			//-------- Scenario 1757

    8666. 

  8666. 			namespace Scenario1757{

    8667. 

  8667. 				

    8668. 

  8668. 				public class Test

    8669. 

  8669. 				{

    8670. 

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

    8671. 

  8671. 			    public static Expression check43__() {

    8672. 

  8672. 			       if(Main() != 0 ) {

    8673. 

  8673. 			           throw new Exception();

    8674. 

  8674. 			       } else { 

    8675. 

  8675. 			           return Expression.Constant(0);

    8676. 

  8676. 			       }

    8677. 

  8677. 			    }

    8678. 

  8678. 				public     static int Main()

    8679. 

  8679. 				    {

    8680. 

  8680. 				        Ext.StartCapture();

    8681. 

  8681. 				        bool success = false;

    8682. 

  8682. 				        try

    8683. 

  8683. 				        {

    8684. 

  8684. 				            success = check43();

    8685. 

  8685. 				        }

    8686. 

  8686. 				        finally

    8687. 

  8687. 				        {

    8688. 

  8688. 				            Ext.StopCapture();

    8689. 

  8689. 				        }

    8690. 

  8690. 				        return success ? 0 : 1;

    8691. 

  8691. 				    }

    8692. 

  8692. 				

    8693. 

  8693. 				    static bool check43() {

    8694. 

  8694. 				        foreach (float? val in new float?[] { null, 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN }) {

    8695. 

  8695. 				            if (!check43(val)) {

    8696. 

  8696. 				                return false;

    8697. 

  8697. 				            }

    8698. 

  8698. 				        }

    8699. 

  8699. 				        return true;

    8700. 

  8700. 				    }

    8701. 

  8701. 				

    8702. 

  8702. 				    static bool check43(float? val) {

    8703. 

  8703. 				        Expression<Func<float?>> e =

    8704. 

  8704. 				            Expression.Lambda<Func<float?>>(

    8705. 

  8705. 				                Expression.Constant(val, typeof(float?)),

    8706. 

  8706. 				                new System.Collections.Generic.List<ParameterExpression>());

    8707. 

  8707. 				        Func<float?> f = e.Compile();

    8708. 

  8708. 				        return object.Equals(f(), val);

    8709. 

  8709. 				    }

    8710. 

  8710. 				}

    8711. 

  8711. 			

    8712. 

  8712. 			

    8713. 

  8713. 			public  static class Ext {

    8714. 

  8714. 			    public static void StartCapture() {

    8715. 

  8715. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8716. 

  8716. 			//        m.Invoke(null, new object[] { "test.dll" });

    8717. 

  8717. 			    }

    8718. 

  8718. 			

    8719. 

  8719. 			    public static void StopCapture() {

    8720. 

  8720. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8721. 

  8721. 			//        m.Invoke(null, new object[0]);

    8722. 

  8722. 			    }

    8723. 

  8723. 			

    8724. 

  8724. 			    public static bool IsIntegralOrEnum(Type type) {

    8725. 

  8725. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8726. 

  8726. 			            case TypeCode.Byte:

    8727. 

  8727. 			            case TypeCode.SByte:

    8728. 

  8728. 			            case TypeCode.Int16:

    8729. 

  8729. 			            case TypeCode.Int32:

    8730. 

  8730. 			            case TypeCode.Int64:

    8731. 

  8731. 			            case TypeCode.UInt16:

    8732. 

  8732. 			            case TypeCode.UInt32:

    8733. 

  8733. 			            case TypeCode.UInt64:

    8734. 

  8734. 			                return true;

    8735. 

  8735. 			            default:

    8736. 

  8736. 			                return false;

    8737. 

  8737. 			        }

    8738. 

  8738. 			    }

    8739. 

  8739. 			

    8740. 

  8740. 			    public static bool IsFloating(Type type) {

    8741. 

  8741. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8742. 

  8742. 			            case TypeCode.Single:

    8743. 

  8743. 			            case TypeCode.Double:

    8744. 

  8744. 			                return true;

    8745. 

  8745. 			            default:

    8746. 

  8746. 			                return false;

    8747. 

  8747. 			        }

    8748. 

  8748. 			    }

    8749. 

  8749. 			

    8750. 

  8750. 			    public static Type GetNonNullableType(Type type) {

    8751. 

  8751. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8752. 

  8752. 			                type.GetGenericArguments()[0] :

    8753. 

  8753. 			                type;

    8754. 

  8754. 			    }

    8755. 

  8755. 			}

    8756. 

  8756. 			

    8757. 

  8757. 		

    8758. 

  8758. 	}

    8759. 

  8759. 			

    8760. 

  8760. 			//-------- Scenario 1758

    8761. 

  8761. 			namespace Scenario1758{

    8762. 

  8762. 				

    8763. 

  8763. 				public class Test

    8764. 

  8764. 				{

    8765. 

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

    8766. 

  8766. 			    public static Expression check44__() {

    8767. 

  8767. 			       if(Main() != 0 ) {

    8768. 

  8768. 			           throw new Exception();

    8769. 

  8769. 			       } else { 

    8770. 

  8770. 			           return Expression.Constant(0);

    8771. 

  8771. 			       }

    8772. 

  8772. 			    }

    8773. 

  8773. 				public     static int Main()

    8774. 

  8774. 				    {

    8775. 

  8775. 				        Ext.StartCapture();

    8776. 

  8776. 				        bool success = false;

    8777. 

  8777. 				        try

    8778. 

  8778. 				        {

    8779. 

  8779. 				            success = check44();

    8780. 

  8780. 				        }

    8781. 

  8781. 				        finally

    8782. 

  8782. 				        {

    8783. 

  8783. 				            Ext.StopCapture();

    8784. 

  8784. 				        }

    8785. 

  8785. 				        return success ? 0 : 1;

    8786. 

  8786. 				    }

    8787. 

  8787. 				

    8788. 

  8788. 				    static bool check44() {

    8789. 

  8789. 				        foreach (double? val in new double?[] { null, 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN }) {

    8790. 

  8790. 				            if (!check44(val)) {

    8791. 

  8791. 				                return false;

    8792. 

  8792. 				            }

    8793. 

  8793. 				        }

    8794. 

  8794. 				        return true;

    8795. 

  8795. 				    }

    8796. 

  8796. 				

    8797. 

  8797. 				    static bool check44(double? val) {

    8798. 

  8798. 				        Expression<Func<double?>> e =

    8799. 

  8799. 				            Expression.Lambda<Func<double?>>(

    8800. 

  8800. 				                Expression.Constant(val, typeof(double?)),

    8801. 

  8801. 				                new System.Collections.Generic.List<ParameterExpression>());

    8802. 

  8802. 				        Func<double?> f = e.Compile();

    8803. 

  8803. 				        return object.Equals(f(), val);

    8804. 

  8804. 				    }

    8805. 

  8805. 				}

    8806. 

  8806. 			

    8807. 

  8807. 			

    8808. 

  8808. 			public  static class Ext {

    8809. 

  8809. 			    public static void StartCapture() {

    8810. 

  8810. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8811. 

  8811. 			//        m.Invoke(null, new object[] { "test.dll" });

    8812. 

  8812. 			    }

    8813. 

  8813. 			

    8814. 

  8814. 			    public static void StopCapture() {

    8815. 

  8815. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8816. 

  8816. 			//        m.Invoke(null, new object[0]);

    8817. 

  8817. 			    }

    8818. 

  8818. 			

    8819. 

  8819. 			    public static bool IsIntegralOrEnum(Type type) {

    8820. 

  8820. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8821. 

  8821. 			            case TypeCode.Byte:

    8822. 

  8822. 			            case TypeCode.SByte:

    8823. 

  8823. 			            case TypeCode.Int16:

    8824. 

  8824. 			            case TypeCode.Int32:

    8825. 

  8825. 			            case TypeCode.Int64:

    8826. 

  8826. 			            case TypeCode.UInt16:

    8827. 

  8827. 			            case TypeCode.UInt32:

    8828. 

  8828. 			            case TypeCode.UInt64:

    8829. 

  8829. 			                return true;

    8830. 

  8830. 			            default:

    8831. 

  8831. 			                return false;

    8832. 

  8832. 			        }

    8833. 

  8833. 			    }

    8834. 

  8834. 			

    8835. 

  8835. 			    public static bool IsFloating(Type type) {

    8836. 

  8836. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8837. 

  8837. 			            case TypeCode.Single:

    8838. 

  8838. 			            case TypeCode.Double:

    8839. 

  8839. 			                return true;

    8840. 

  8840. 			            default:

    8841. 

  8841. 			                return false;

    8842. 

  8842. 			        }

    8843. 

  8843. 			    }

    8844. 

  8844. 			

    8845. 

  8845. 			    public static Type GetNonNullableType(Type type) {

    8846. 

  8846. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8847. 

  8847. 			                type.GetGenericArguments()[0] :

    8848. 

  8848. 			                type;

    8849. 

  8849. 			    }

    8850. 

  8850. 			}

    8851. 

  8851. 			

    8852. 

  8852. 		

    8853. 

  8853. 	}

    8854. 

  8854. 			

    8855. 

  8855. 			//-------- Scenario 1759

    8856. 

  8856. 			namespace Scenario1759{

    8857. 

  8857. 				

    8858. 

  8858. 				public class Test

    8859. 

  8859. 				{

    8860. 

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

    8861. 

  8861. 			    public static Expression check45__() {

    8862. 

  8862. 			       if(Main() != 0 ) {

    8863. 

  8863. 			           throw new Exception();

    8864. 

  8864. 			       } else { 

    8865. 

  8865. 			           return Expression.Constant(0);

    8866. 

  8866. 			       }

    8867. 

  8867. 			    }

    8868. 

  8868. 				public     static int Main()

    8869. 

  8869. 				    {

    8870. 

  8870. 				        Ext.StartCapture();

    8871. 

  8871. 				        bool success = false;

    8872. 

  8872. 				        try

    8873. 

  8873. 				        {

    8874. 

  8874. 				            success = check45();

    8875. 

  8875. 				        }

    8876. 

  8876. 				        finally

    8877. 

  8877. 				        {

    8878. 

  8878. 				            Ext.StopCapture();

    8879. 

  8879. 				        }

    8880. 

  8880. 				        return success ? 0 : 1;

    8881. 

  8881. 				    }

    8882. 

  8882. 				

    8883. 

  8883. 				    static bool check45() {

    8884. 

  8884. 				        foreach (decimal? val in new decimal?[] { null, decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue }) {

    8885. 

  8885. 				            if (!check45(val)) {

    8886. 

  8886. 				                return false;

    8887. 

  8887. 				            }

    8888. 

  8888. 				        }

    8889. 

  8889. 				        return true;

    8890. 

  8890. 				    }

    8891. 

  8891. 				

    8892. 

  8892. 				    static bool check45(decimal? val) {

    8893. 

  8893. 				        Expression<Func<decimal?>> e =

    8894. 

  8894. 				            Expression.Lambda<Func<decimal?>>(

    8895. 

  8895. 				                Expression.Constant(val, typeof(decimal?)),

    8896. 

  8896. 				                new System.Collections.Generic.List<ParameterExpression>());

    8897. 

  8897. 				        Func<decimal?> f = e.Compile();

    8898. 

  8898. 				        return object.Equals(f(), val);

    8899. 

  8899. 				    }

    8900. 

  8900. 				}

    8901. 

  8901. 			

    8902. 

  8902. 			

    8903. 

  8903. 			public  static class Ext {

    8904. 

  8904. 			    public static void StartCapture() {

    8905. 

  8905. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8906. 

  8906. 			//        m.Invoke(null, new object[] { "test.dll" });

    8907. 

  8907. 			    }

    8908. 

  8908. 			

    8909. 

  8909. 			    public static void StopCapture() {

    8910. 

  8910. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    8911. 

  8911. 			//        m.Invoke(null, new object[0]);

    8912. 

  8912. 			    }

    8913. 

  8913. 			

    8914. 

  8914. 			    public static bool IsIntegralOrEnum(Type type) {

    8915. 

  8915. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8916. 

  8916. 			            case TypeCode.Byte:

    8917. 

  8917. 			            case TypeCode.SByte:

    8918. 

  8918. 			            case TypeCode.Int16:

    8919. 

  8919. 			            case TypeCode.Int32:

    8920. 

  8920. 			            case TypeCode.Int64:

    8921. 

  8921. 			            case TypeCode.UInt16:

    8922. 

  8922. 			            case TypeCode.UInt32:

    8923. 

  8923. 			            case TypeCode.UInt64:

    8924. 

  8924. 			                return true;

    8925. 

  8925. 			            default:

    8926. 

  8926. 			                return false;

    8927. 

  8927. 			        }

    8928. 

  8928. 			    }

    8929. 

  8929. 			

    8930. 

  8930. 			    public static bool IsFloating(Type type) {

    8931. 

  8931. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    8932. 

  8932. 			            case TypeCode.Single:

    8933. 

  8933. 			            case TypeCode.Double:

    8934. 

  8934. 			                return true;

    8935. 

  8935. 			            default:

    8936. 

  8936. 			                return false;

    8937. 

  8937. 			        }

    8938. 

  8938. 			    }

    8939. 

  8939. 			

    8940. 

  8940. 			    public static Type GetNonNullableType(Type type) {

    8941. 

  8941. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    8942. 

  8942. 			                type.GetGenericArguments()[0] :

    8943. 

  8943. 			                type;

    8944. 

  8944. 			    }

    8945. 

  8945. 			}

    8946. 

  8946. 			

    8947. 

  8947. 		

    8948. 

  8948. 	}

    8949. 

  8949. 			

    8950. 

  8950. 			//-------- Scenario 1760

    8951. 

  8951. 			namespace Scenario1760{

    8952. 

  8952. 				

    8953. 

  8953. 				public class Test

    8954. 

  8954. 				{

    8955. 

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

    8956. 

  8956. 			    public static Expression check46__() {

    8957. 

  8957. 			       if(Main() != 0 ) {

    8958. 

  8958. 			           throw new Exception();

    8959. 

  8959. 			       } else { 

    8960. 

  8960. 			           return Expression.Constant(0);

    8961. 

  8961. 			       }

    8962. 

  8962. 			    }

    8963. 

  8963. 				public     static int Main()

    8964. 

  8964. 				    {

    8965. 

  8965. 				        Ext.StartCapture();

    8966. 

  8966. 				        bool success = false;

    8967. 

  8967. 				        try

    8968. 

  8968. 				        {

    8969. 

  8969. 				            success = check46();

    8970. 

  8970. 				        }

    8971. 

  8971. 				        finally

    8972. 

  8972. 				        {

    8973. 

  8973. 				            Ext.StopCapture();

    8974. 

  8974. 				        }

    8975. 

  8975. 				        return success ? 0 : 1;

    8976. 

  8976. 				    }

    8977. 

  8977. 				

    8978. 

  8978. 				    static bool check46() {

    8979. 

  8979. 				        foreach (char? val in new char?[] { null, '\0', '\b', 'A', '\uffff' }) {

    8980. 

  8980. 				            if (!check46(val)) {

    8981. 

  8981. 				                return false;

    8982. 

  8982. 				            }

    8983. 

  8983. 				        }

    8984. 

  8984. 				        return true;

    8985. 

  8985. 				    }

    8986. 

  8986. 				

    8987. 

  8987. 				    static bool check46(char? val) {

    8988. 

  8988. 				        Expression<Func<char?>> e =

    8989. 

  8989. 				            Expression.Lambda<Func<char?>>(

    8990. 

  8990. 				                Expression.Constant(val, typeof(char?)),

    8991. 

  8991. 				                new System.Collections.Generic.List<ParameterExpression>());

    8992. 

  8992. 				        Func<char?> f = e.Compile();

    8993. 

  8993. 				        return object.Equals(f(), val);

    8994. 

  8994. 				    }

    8995. 

  8995. 				}

    8996. 

  8996. 			

    8997. 

  8997. 			

    8998. 

  8998. 			public  static class Ext {

    8999. 

  8999. 			    public static void StartCapture() {

    9000. 

  9000. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9001. 

  9001. 			//        m.Invoke(null, new object[] { "test.dll" });

    9002. 

  9002. 			    }

    9003. 

  9003. 			

    9004. 

  9004. 			    public static void StopCapture() {

    9005. 

  9005. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9006. 

  9006. 			//        m.Invoke(null, new object[0]);

    9007. 

  9007. 			    }

    9008. 

  9008. 			

    9009. 

  9009. 			    public static bool IsIntegralOrEnum(Type type) {

    9010. 

  9010. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9011. 

  9011. 			            case TypeCode.Byte:

    9012. 

  9012. 			            case TypeCode.SByte:

    9013. 

  9013. 			            case TypeCode.Int16:

    9014. 

  9014. 			            case TypeCode.Int32:

    9015. 

  9015. 			            case TypeCode.Int64:

    9016. 

  9016. 			            case TypeCode.UInt16:

    9017. 

  9017. 			            case TypeCode.UInt32:

    9018. 

  9018. 			            case TypeCode.UInt64:

    9019. 

  9019. 			                return true;

    9020. 

  9020. 			            default:

    9021. 

  9021. 			                return false;

    9022. 

  9022. 			        }

    9023. 

  9023. 			    }

    9024. 

  9024. 			

    9025. 

  9025. 			    public static bool IsFloating(Type type) {

    9026. 

  9026. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9027. 

  9027. 			            case TypeCode.Single:

    9028. 

  9028. 			            case TypeCode.Double:

    9029. 

  9029. 			                return true;

    9030. 

  9030. 			            default:

    9031. 

  9031. 			                return false;

    9032. 

  9032. 			        }

    9033. 

  9033. 			    }

    9034. 

  9034. 			

    9035. 

  9035. 			    public static Type GetNonNullableType(Type type) {

    9036. 

  9036. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9037. 

  9037. 			                type.GetGenericArguments()[0] :

    9038. 

  9038. 			                type;

    9039. 

  9039. 			    }

    9040. 

  9040. 			}

    9041. 

  9041. 			

    9042. 

  9042. 		

    9043. 

  9043. 	}

    9044. 

  9044. 			

    9045. 

  9045. 			//-------- Scenario 1761

    9046. 

  9046. 			namespace Scenario1761{

    9047. 

  9047. 				

    9048. 

  9048. 				public class Test

    9049. 

  9049. 				{

    9050. 

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

    9051. 

  9051. 			    public static Expression check47__() {

    9052. 

  9052. 			       if(Main() != 0 ) {

    9053. 

  9053. 			           throw new Exception();

    9054. 

  9054. 			       } else { 

    9055. 

  9055. 			           return Expression.Constant(0);

    9056. 

  9056. 			       }

    9057. 

  9057. 			    }

    9058. 

  9058. 				public     static int Main()

    9059. 

  9059. 				    {

    9060. 

  9060. 				        Ext.StartCapture();

    9061. 

  9061. 				        bool success = false;

    9062. 

  9062. 				        try

    9063. 

  9063. 				        {

    9064. 

  9064. 				            success = check47();

    9065. 

  9065. 				        }

    9066. 

  9066. 				        finally

    9067. 

  9067. 				        {

    9068. 

  9068. 				            Ext.StopCapture();

    9069. 

  9069. 				        }

    9070. 

  9070. 				        return success ? 0 : 1;

    9071. 

  9071. 				    }

    9072. 

  9072. 				

    9073. 

  9073. 				    static bool check47() {

    9074. 

  9074. 				        foreach (bool? val in new bool?[] { null, true, false }) {

    9075. 

  9075. 				            if (!check47(val)) {

    9076. 

  9076. 				                return false;

    9077. 

  9077. 				            }

    9078. 

  9078. 				        }

    9079. 

  9079. 				        return true;

    9080. 

  9080. 				    }

    9081. 

  9081. 				

    9082. 

  9082. 				    static bool check47(bool? val) {

    9083. 

  9083. 				        Expression<Func<bool?>> e =

    9084. 

  9084. 				            Expression.Lambda<Func<bool?>>(

    9085. 

  9085. 				                Expression.Constant(val, typeof(bool?)),

    9086. 

  9086. 				                new System.Collections.Generic.List<ParameterExpression>());

    9087. 

  9087. 				        Func<bool?> f = e.Compile();

    9088. 

  9088. 				        return object.Equals(f(), val);

    9089. 

  9089. 				    }

    9090. 

  9090. 				}

    9091. 

  9091. 			

    9092. 

  9092. 			

    9093. 

  9093. 			public  static class Ext {

    9094. 

  9094. 			    public static void StartCapture() {

    9095. 

  9095. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9096. 

  9096. 			//        m.Invoke(null, new object[] { "test.dll" });

    9097. 

  9097. 			    }

    9098. 

  9098. 			

    9099. 

  9099. 			    public static void StopCapture() {

    9100. 

  9100. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9101. 

  9101. 			//        m.Invoke(null, new object[0]);

    9102. 

  9102. 			    }

    9103. 

  9103. 			

    9104. 

  9104. 			    public static bool IsIntegralOrEnum(Type type) {

    9105. 

  9105. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9106. 

  9106. 			            case TypeCode.Byte:

    9107. 

  9107. 			            case TypeCode.SByte:

    9108. 

  9108. 			            case TypeCode.Int16:

    9109. 

  9109. 			            case TypeCode.Int32:

    9110. 

  9110. 			            case TypeCode.Int64:

    9111. 

  9111. 			            case TypeCode.UInt16:

    9112. 

  9112. 			            case TypeCode.UInt32:

    9113. 

  9113. 			            case TypeCode.UInt64:

    9114. 

  9114. 			                return true;

    9115. 

  9115. 			            default:

    9116. 

  9116. 			                return false;

    9117. 

  9117. 			        }

    9118. 

  9118. 			    }

    9119. 

  9119. 			

    9120. 

  9120. 			    public static bool IsFloating(Type type) {

    9121. 

  9121. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9122. 

  9122. 			            case TypeCode.Single:

    9123. 

  9123. 			            case TypeCode.Double:

    9124. 

  9124. 			                return true;

    9125. 

  9125. 			            default:

    9126. 

  9126. 			                return false;

    9127. 

  9127. 			        }

    9128. 

  9128. 			    }

    9129. 

  9129. 			

    9130. 

  9130. 			    public static Type GetNonNullableType(Type type) {

    9131. 

  9131. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9132. 

  9132. 			                type.GetGenericArguments()[0] :

    9133. 

  9133. 			                type;

    9134. 

  9134. 			    }

    9135. 

  9135. 			}

    9136. 

  9136. 			

    9137. 

  9137. 		

    9138. 

  9138. 	}

    9139. 

  9139. 				

    9140. 

  9140. 				//-------- Scenario 1762

    9141. 

  9141. 				namespace Scenario1762{

    9142. 

  9142. 					

    9143. 

  9143. 					public class Test

    9144. 

  9144. 					{

    9145. 

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

    9146. 

  9146. 				    public static Expression check48__() {

    9147. 

  9147. 				       if(Main() != 0 ) {

    9148. 

  9148. 				           throw new Exception();

    9149. 

  9149. 				       } else { 

    9150. 

  9150. 				           return Expression.Constant(0);

    9151. 

  9151. 				       }

    9152. 

  9152. 				    }

    9153. 

  9153. 					public     static int Main()

    9154. 

  9154. 					    {

    9155. 

  9155. 					        Ext.StartCapture();

    9156. 

  9156. 					        bool success = false;

    9157. 

  9157. 					        try

    9158. 

  9158. 					        {

    9159. 

  9159. 					            success = check48();

    9160. 

  9160. 					        }

    9161. 

  9161. 					        finally

    9162. 

  9162. 					        {

    9163. 

  9163. 					            Ext.StopCapture();

    9164. 

  9164. 					        }

    9165. 

  9165. 					        return success ? 0 : 1;

    9166. 

  9166. 					    }

    9167. 

  9167. 					

    9168. 

  9168. 					    static bool check48() {

    9169. 

  9169. 					        foreach (S? val in new S?[] { null, default(S), new S() }) {

    9170. 

  9170. 					            if (!check48(val)) {

    9171. 

  9171. 					                return false;

    9172. 

  9172. 					            }

    9173. 

  9173. 					        }

    9174. 

  9174. 					        return true;

    9175. 

  9175. 					    }

    9176. 

  9176. 					

    9177. 

  9177. 					    static bool check48(S? val) {

    9178. 

  9178. 					        Expression<Func<S?>> e =

    9179. 

  9179. 					            Expression.Lambda<Func<S?>>(

    9180. 

  9180. 					                Expression.Constant(val, typeof(S?)),

    9181. 

  9181. 					                new System.Collections.Generic.List<ParameterExpression>());

    9182. 

  9182. 					        Func<S?> f = e.Compile();

    9183. 

  9183. 					        return object.Equals(f(), val);

    9184. 

  9184. 					    }

    9185. 

  9185. 					}

    9186. 

  9186. 				

    9187. 

  9187. 				

    9188. 

  9188. 				public  static class Ext {

    9189. 

  9189. 				    public static void StartCapture() {

    9190. 

  9190. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9191. 

  9191. 				//        m.Invoke(null, new object[] { "test.dll" });

    9192. 

  9192. 				    }

    9193. 

  9193. 				

    9194. 

  9194. 				    public static void StopCapture() {

    9195. 

  9195. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9196. 

  9196. 				//        m.Invoke(null, new object[0]);

    9197. 

  9197. 				    }

    9198. 

  9198. 				

    9199. 

  9199. 				    public static bool IsIntegralOrEnum(Type type) {

    9200. 

  9200. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9201. 

  9201. 				            case TypeCode.Byte:

    9202. 

  9202. 				            case TypeCode.SByte:

    9203. 

  9203. 				            case TypeCode.Int16:

    9204. 

  9204. 				            case TypeCode.Int32:

    9205. 

  9205. 				            case TypeCode.Int64:

    9206. 

  9206. 				            case TypeCode.UInt16:

    9207. 

  9207. 				            case TypeCode.UInt32:

    9208. 

  9208. 				            case TypeCode.UInt64:

    9209. 

  9209. 				                return true;

    9210. 

  9210. 				            default:

    9211. 

  9211. 				                return false;

    9212. 

  9212. 				        }

    9213. 

  9213. 				    }

    9214. 

  9214. 				

    9215. 

  9215. 				    public static bool IsFloating(Type type) {

    9216. 

  9216. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9217. 

  9217. 				            case TypeCode.Single:

    9218. 

  9218. 				            case TypeCode.Double:

    9219. 

  9219. 				                return true;

    9220. 

  9220. 				            default:

    9221. 

  9221. 				                return false;

    9222. 

  9222. 				        }

    9223. 

  9223. 				    }

    9224. 

  9224. 				

    9225. 

  9225. 				    public static Type GetNonNullableType(Type type) {

    9226. 

  9226. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9227. 

  9227. 				                type.GetGenericArguments()[0] :

    9228. 

  9228. 				                type;

    9229. 

  9229. 				    }

    9230. 

  9230. 				}

    9231. 

  9231. 				

    9232. 

  9232. 			

    9233. 

  9233. 			

    9234. 

  9234. 			

    9235. 

  9235. 			public interface I {

    9236. 

  9236. 			  void M();

    9237. 

  9237. 			}

    9238. 

  9238. 			

    9239. 

  9239. 			public  class C : IEquatable<C>, I {

    9240. 

  9240. 			    void I.M() {

    9241. 

  9241. 			    }

    9242. 

  9242. 			

    9243. 

  9243. 			    public override bool Equals(object o) {

    9244. 

  9244. 			        return o is C && Equals((C) o);

    9245. 

  9245. 			    }

    9246. 

  9246. 			

    9247. 

  9247. 			    public bool Equals(C c) {

    9248. 

  9248. 			        return c != null;

    9249. 

  9249. 			    }

    9250. 

  9250. 			

    9251. 

  9251. 			    public override int GetHashCode() {

    9252. 

  9252. 			        return 0;

    9253. 

  9253. 			    }

    9254. 

  9254. 			}

    9255. 

  9255. 			

    9256. 

  9256. 			public  class D : C, IEquatable<D> {

    9257. 

  9257. 			    public int Val;

    9258. 

  9258. 			    public D() {

    9259. 

  9259. 			    }

    9260. 

  9260. 			    public D(int val) {

    9261. 

  9261. 			        Val = val;

    9262. 

  9262. 			    }

    9263. 

  9263. 			

    9264. 

  9264. 			    public override bool Equals(object o) {

    9265. 

  9265. 			        return o is D && Equals((D) o);

    9266. 

  9266. 			    }

    9267. 

  9267. 			

    9268. 

  9268. 			    public bool Equals(D d) {

    9269. 

  9269. 			        return d != null && d.Val == Val;

    9270. 

  9270. 			    }

    9271. 

  9271. 			

    9272. 

  9272. 			    public override int GetHashCode() {

    9273. 

  9273. 			        return Val;

    9274. 

  9274. 			    }

    9275. 

  9275. 			}

    9276. 

  9276. 			

    9277. 

  9277. 			public enum E {

    9278. 

  9278. 			  A=1, B=2

    9279. 

  9279. 			}

    9280. 

  9280. 			

    9281. 

  9281. 			public enum El : long {

    9282. 

  9282. 			  A, B, C

    9283. 

  9283. 			}

    9284. 

  9284. 			

    9285. 

  9285. 			public struct S : IEquatable<S> {

    9286. 

  9286. 			    public override bool Equals(object o) {

    9287. 

  9287. 			        return (o is S) && Equals((S) o);

    9288. 

  9288. 			    }

    9289. 

  9289. 			    public bool Equals(S other) {

    9290. 

  9290. 			        return true;

    9291. 

  9291. 			    }

    9292. 

  9292. 			    public override int GetHashCode() {

    9293. 

  9293. 			        return 0;

    9294. 

  9294. 			    }

    9295. 

  9295. 			}

    9296. 

  9296. 			

    9297. 

  9297. 			public struct Sp : IEquatable<Sp> {

    9298. 

  9298. 			    public Sp(int i, double d) {

    9299. 

  9299. 			        I = i;

    9300. 

  9300. 			        D = d;

    9301. 

  9301. 			    }

    9302. 

  9302. 			

    9303. 

  9303. 			    public int I;

    9304. 

  9304. 			    public double D;

    9305. 

  9305. 			

    9306. 

  9306. 			    public override bool Equals(object o) {

    9307. 

  9307. 			        return (o is Sp) && Equals((Sp) o);

    9308. 

  9308. 			    }

    9309. 

  9309. 			    public bool Equals(Sp other) {

    9310. 

  9310. 			        return other.I == I && other.D == D;

    9311. 

  9311. 			    }

    9312. 

  9312. 			    public override int GetHashCode() {

    9313. 

  9313. 			        return I.GetHashCode() ^ D.GetHashCode();

    9314. 

  9314. 			    }

    9315. 

  9315. 			}

    9316. 

  9316. 			

    9317. 

  9317. 			public struct Ss : IEquatable<Ss> {

    9318. 

  9318. 			    public Ss(S s) {

    9319. 

  9319. 			        Val = s;

    9320. 

  9320. 			    }

    9321. 

  9321. 			

    9322. 

  9322. 			    public S Val;

    9323. 

  9323. 			

    9324. 

  9324. 			    public override bool Equals(object o) {

    9325. 

  9325. 			        return (o is Ss) && Equals((Ss) o);

    9326. 

  9326. 			    }

    9327. 

  9327. 			    public bool Equals(Ss other) {

    9328. 

  9328. 			        return other.Val.Equals(Val);

    9329. 

  9329. 			    }

    9330. 

  9330. 			    public override int GetHashCode() {

    9331. 

  9331. 			        return Val.GetHashCode();

    9332. 

  9332. 			    }

    9333. 

  9333. 			}

    9334. 

  9334. 			

    9335. 

  9335. 			public struct Sc : IEquatable<Sc> {

    9336. 

  9336. 			    public Sc(string s) {

    9337. 

  9337. 			        S = s;

    9338. 

  9338. 			    }

    9339. 

  9339. 			

    9340. 

  9340. 			    public string S;

    9341. 

  9341. 			

    9342. 

  9342. 			    public override bool Equals(object o) {

    9343. 

  9343. 			        return (o is Sc) && Equals((Sc) o);

    9344. 

  9344. 			    }

    9345. 

  9345. 			    public bool Equals(Sc other) {

    9346. 

  9346. 			        return other.S == S;

    9347. 

  9347. 			    }

    9348. 

  9348. 			    public override int GetHashCode() {

    9349. 

  9349. 			        return S.GetHashCode();

    9350. 

  9350. 			    }

    9351. 

  9351. 			}

    9352. 

  9352. 			

    9353. 

  9353. 			public struct Scs : IEquatable<Scs> {

    9354. 

  9354. 			    public Scs(string s, S val) {

    9355. 

  9355. 			        S = s;

    9356. 

  9356. 			        Val = val;

    9357. 

  9357. 			    }

    9358. 

  9358. 			

    9359. 

  9359. 			    public string S;

    9360. 

  9360. 			    public S Val;

    9361. 

  9361. 			

    9362. 

  9362. 			    public override bool Equals(object o) {

    9363. 

  9363. 			        return (o is Scs) && Equals((Scs) o);

    9364. 

  9364. 			    }

    9365. 

  9365. 			    public bool Equals(Scs other) {

    9366. 

  9366. 			        return other.S == S && other.Val.Equals(Val);

    9367. 

  9367. 			    }

    9368. 

  9368. 			    public override int GetHashCode() {

    9369. 

  9369. 			        return S.GetHashCode() ^ Val.GetHashCode();

    9370. 

  9370. 			    }

    9371. 

  9371. 			}

    9372. 

  9372. 			

    9373. 

  9373. 		

    9374. 

  9374. 	}

    9375. 

  9375. 				

    9376. 

  9376. 				//-------- Scenario 1763

    9377. 

  9377. 				namespace Scenario1763{

    9378. 

  9378. 					

    9379. 

  9379. 					public class Test

    9380. 

  9380. 					{

    9381. 

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

    9382. 

  9382. 				    public static Expression check49__() {

    9383. 

  9383. 				       if(Main() != 0 ) {

    9384. 

  9384. 				           throw new Exception();

    9385. 

  9385. 				       } else { 

    9386. 

  9386. 				           return Expression.Constant(0);

    9387. 

  9387. 				       }

    9388. 

  9388. 				    }

    9389. 

  9389. 					public     static int Main()

    9390. 

  9390. 					    {

    9391. 

  9391. 					        Ext.StartCapture();

    9392. 

  9392. 					        bool success = false;

    9393. 

  9393. 					        try

    9394. 

  9394. 					        {

    9395. 

  9395. 					            success = check49();

    9396. 

  9396. 					        }

    9397. 

  9397. 					        finally

    9398. 

  9398. 					        {

    9399. 

  9399. 					            Ext.StopCapture();

    9400. 

  9400. 					        }

    9401. 

  9401. 					        return success ? 0 : 1;

    9402. 

  9402. 					    }

    9403. 

  9403. 					

    9404. 

  9404. 					    static bool check49() {

    9405. 

  9405. 					        foreach (Sp? val in new Sp?[] { null, default(Sp), new Sp(), new Sp(5,5.0) }) {

    9406. 

  9406. 					            if (!check49(val)) {

    9407. 

  9407. 					                return false;

    9408. 

  9408. 					            }

    9409. 

  9409. 					        }

    9410. 

  9410. 					        return true;

    9411. 

  9411. 					    }

    9412. 

  9412. 					

    9413. 

  9413. 					    static bool check49(Sp? val) {

    9414. 

  9414. 					        Expression<Func<Sp?>> e =

    9415. 

  9415. 					            Expression.Lambda<Func<Sp?>>(

    9416. 

  9416. 					                Expression.Constant(val, typeof(Sp?)),

    9417. 

  9417. 					                new System.Collections.Generic.List<ParameterExpression>());

    9418. 

  9418. 					        Func<Sp?> f = e.Compile();

    9419. 

  9419. 					        return object.Equals(f(), val);

    9420. 

  9420. 					    }

    9421. 

  9421. 					}

    9422. 

  9422. 				

    9423. 

  9423. 				

    9424. 

  9424. 				public  static class Ext {

    9425. 

  9425. 				    public static void StartCapture() {

    9426. 

  9426. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9427. 

  9427. 				//        m.Invoke(null, new object[] { "test.dll" });

    9428. 

  9428. 				    }

    9429. 

  9429. 				

    9430. 

  9430. 				    public static void StopCapture() {

    9431. 

  9431. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9432. 

  9432. 				//        m.Invoke(null, new object[0]);

    9433. 

  9433. 				    }

    9434. 

  9434. 				

    9435. 

  9435. 				    public static bool IsIntegralOrEnum(Type type) {

    9436. 

  9436. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9437. 

  9437. 				            case TypeCode.Byte:

    9438. 

  9438. 				            case TypeCode.SByte:

    9439. 

  9439. 				            case TypeCode.Int16:

    9440. 

  9440. 				            case TypeCode.Int32:

    9441. 

  9441. 				            case TypeCode.Int64:

    9442. 

  9442. 				            case TypeCode.UInt16:

    9443. 

  9443. 				            case TypeCode.UInt32:

    9444. 

  9444. 				            case TypeCode.UInt64:

    9445. 

  9445. 				                return true;

    9446. 

  9446. 				            default:

    9447. 

  9447. 				                return false;

    9448. 

  9448. 				        }

    9449. 

  9449. 				    }

    9450. 

  9450. 				

    9451. 

  9451. 				    public static bool IsFloating(Type type) {

    9452. 

  9452. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9453. 

  9453. 				            case TypeCode.Single:

    9454. 

  9454. 				            case TypeCode.Double:

    9455. 

  9455. 				                return true;

    9456. 

  9456. 				            default:

    9457. 

  9457. 				                return false;

    9458. 

  9458. 				        }

    9459. 

  9459. 				    }

    9460. 

  9460. 				

    9461. 

  9461. 				    public static Type GetNonNullableType(Type type) {

    9462. 

  9462. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9463. 

  9463. 				                type.GetGenericArguments()[0] :

    9464. 

  9464. 				                type;

    9465. 

  9465. 				    }

    9466. 

  9466. 				}

    9467. 

  9467. 				

    9468. 

  9468. 			

    9469. 

  9469. 			

    9470. 

  9470. 			

    9471. 

  9471. 			public interface I {

    9472. 

  9472. 			  void M();

    9473. 

  9473. 			}

    9474. 

  9474. 			

    9475. 

  9475. 			public  class C : IEquatable<C>, I {

    9476. 

  9476. 			    void I.M() {

    9477. 

  9477. 			    }

    9478. 

  9478. 			

    9479. 

  9479. 			    public override bool Equals(object o) {

    9480. 

  9480. 			        return o is C && Equals((C) o);

    9481. 

  9481. 			    }

    9482. 

  9482. 			

    9483. 

  9483. 			    public bool Equals(C c) {

    9484. 

  9484. 			        return c != null;

    9485. 

  9485. 			    }

    9486. 

  9486. 			

    9487. 

  9487. 			    public override int GetHashCode() {

    9488. 

  9488. 			        return 0;

    9489. 

  9489. 			    }

    9490. 

  9490. 			}

    9491. 

  9491. 			

    9492. 

  9492. 			public  class D : C, IEquatable<D> {

    9493. 

  9493. 			    public int Val;

    9494. 

  9494. 			    public D() {

    9495. 

  9495. 			    }

    9496. 

  9496. 			    public D(int val) {

    9497. 

  9497. 			        Val = val;

    9498. 

  9498. 			    }

    9499. 

  9499. 			

    9500. 

  9500. 			    public override bool Equals(object o) {

    9501. 

  9501. 			        return o is D && Equals((D) o);

    9502. 

  9502. 			    }

    9503. 

  9503. 			

    9504. 

  9504. 			    public bool Equals(D d) {

    9505. 

  9505. 			        return d != null && d.Val == Val;

    9506. 

  9506. 			    }

    9507. 

  9507. 			

    9508. 

  9508. 			    public override int GetHashCode() {

    9509. 

  9509. 			        return Val;

    9510. 

  9510. 			    }

    9511. 

  9511. 			}

    9512. 

  9512. 			

    9513. 

  9513. 			public enum E {

    9514. 

  9514. 			  A=1, B=2

    9515. 

  9515. 			}

    9516. 

  9516. 			

    9517. 

  9517. 			public enum El : long {

    9518. 

  9518. 			  A, B, C

    9519. 

  9519. 			}

    9520. 

  9520. 			

    9521. 

  9521. 			public struct S : IEquatable<S> {

    9522. 

  9522. 			    public override bool Equals(object o) {

    9523. 

  9523. 			        return (o is S) && Equals((S) o);

    9524. 

  9524. 			    }

    9525. 

  9525. 			    public bool Equals(S other) {

    9526. 

  9526. 			        return true;

    9527. 

  9527. 			    }

    9528. 

  9528. 			    public override int GetHashCode() {

    9529. 

  9529. 			        return 0;

    9530. 

  9530. 			    }

    9531. 

  9531. 			}

    9532. 

  9532. 			

    9533. 

  9533. 			public struct Sp : IEquatable<Sp> {

    9534. 

  9534. 			    public Sp(int i, double d) {

    9535. 

  9535. 			        I = i;

    9536. 

  9536. 			        D = d;

    9537. 

  9537. 			    }

    9538. 

  9538. 			

    9539. 

  9539. 			    public int I;

    9540. 

  9540. 			    public double D;

    9541. 

  9541. 			

    9542. 

  9542. 			    public override bool Equals(object o) {

    9543. 

  9543. 			        return (o is Sp) && Equals((Sp) o);

    9544. 

  9544. 			    }

    9545. 

  9545. 			    public bool Equals(Sp other) {

    9546. 

  9546. 			        return other.I == I && other.D == D;

    9547. 

  9547. 			    }

    9548. 

  9548. 			    public override int GetHashCode() {

    9549. 

  9549. 			        return I.GetHashCode() ^ D.GetHashCode();

    9550. 

  9550. 			    }

    9551. 

  9551. 			}

    9552. 

  9552. 			

    9553. 

  9553. 			public struct Ss : IEquatable<Ss> {

    9554. 

  9554. 			    public Ss(S s) {

    9555. 

  9555. 			        Val = s;

    9556. 

  9556. 			    }

    9557. 

  9557. 			

    9558. 

  9558. 			    public S Val;

    9559. 

  9559. 			

    9560. 

  9560. 			    public override bool Equals(object o) {

    9561. 

  9561. 			        return (o is Ss) && Equals((Ss) o);

    9562. 

  9562. 			    }

    9563. 

  9563. 			    public bool Equals(Ss other) {

    9564. 

  9564. 			        return other.Val.Equals(Val);

    9565. 

  9565. 			    }

    9566. 

  9566. 			    public override int GetHashCode() {

    9567. 

  9567. 			        return Val.GetHashCode();

    9568. 

  9568. 			    }

    9569. 

  9569. 			}

    9570. 

  9570. 			

    9571. 

  9571. 			public struct Sc : IEquatable<Sc> {

    9572. 

  9572. 			    public Sc(string s) {

    9573. 

  9573. 			        S = s;

    9574. 

  9574. 			    }

    9575. 

  9575. 			

    9576. 

  9576. 			    public string S;

    9577. 

  9577. 			

    9578. 

  9578. 			    public override bool Equals(object o) {

    9579. 

  9579. 			        return (o is Sc) && Equals((Sc) o);

    9580. 

  9580. 			    }

    9581. 

  9581. 			    public bool Equals(Sc other) {

    9582. 

  9582. 			        return other.S == S;

    9583. 

  9583. 			    }

    9584. 

  9584. 			    public override int GetHashCode() {

    9585. 

  9585. 			        return S.GetHashCode();

    9586. 

  9586. 			    }

    9587. 

  9587. 			}

    9588. 

  9588. 			

    9589. 

  9589. 			public struct Scs : IEquatable<Scs> {

    9590. 

  9590. 			    public Scs(string s, S val) {

    9591. 

  9591. 			        S = s;

    9592. 

  9592. 			        Val = val;

    9593. 

  9593. 			    }

    9594. 

  9594. 			

    9595. 

  9595. 			    public string S;

    9596. 

  9596. 			    public S Val;

    9597. 

  9597. 			

    9598. 

  9598. 			    public override bool Equals(object o) {

    9599. 

  9599. 			        return (o is Scs) && Equals((Scs) o);

    9600. 

  9600. 			    }

    9601. 

  9601. 			    public bool Equals(Scs other) {

    9602. 

  9602. 			        return other.S == S && other.Val.Equals(Val);

    9603. 

  9603. 			    }

    9604. 

  9604. 			    public override int GetHashCode() {

    9605. 

  9605. 			        return S.GetHashCode() ^ Val.GetHashCode();

    9606. 

  9606. 			    }

    9607. 

  9607. 			}

    9608. 

  9608. 			

    9609. 

  9609. 		

    9610. 

  9610. 	}

    9611. 

  9611. 				

    9612. 

  9612. 				//-------- Scenario 1764

    9613. 

  9613. 				namespace Scenario1764{

    9614. 

  9614. 					

    9615. 

  9615. 					public class Test

    9616. 

  9616. 					{

    9617. 

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

    9618. 

  9618. 				    public static Expression check50__() {

    9619. 

  9619. 				       if(Main() != 0 ) {

    9620. 

  9620. 				           throw new Exception();

    9621. 

  9621. 				       } else { 

    9622. 

  9622. 				           return Expression.Constant(0);

    9623. 

  9623. 				       }

    9624. 

  9624. 				    }

    9625. 

  9625. 					public     static int Main()

    9626. 

  9626. 					    {

    9627. 

  9627. 					        Ext.StartCapture();

    9628. 

  9628. 					        bool success = false;

    9629. 

  9629. 					        try

    9630. 

  9630. 					        {

    9631. 

  9631. 					            success = check50();

    9632. 

  9632. 					        }

    9633. 

  9633. 					        finally

    9634. 

  9634. 					        {

    9635. 

  9635. 					            Ext.StopCapture();

    9636. 

  9636. 					        }

    9637. 

  9637. 					        return success ? 0 : 1;

    9638. 

  9638. 					    }

    9639. 

  9639. 					

    9640. 

  9640. 					    static bool check50() {

    9641. 

  9641. 					        foreach (Ss? val in new Ss?[] { null, default(Ss), new Ss(), new Ss(new S()) }) {

    9642. 

  9642. 					            if (!check50(val)) {

    9643. 

  9643. 					                return false;

    9644. 

  9644. 					            }

    9645. 

  9645. 					        }

    9646. 

  9646. 					        return true;

    9647. 

  9647. 					    }

    9648. 

  9648. 					

    9649. 

  9649. 					    static bool check50(Ss? val) {

    9650. 

  9650. 					        Expression<Func<Ss?>> e =

    9651. 

  9651. 					            Expression.Lambda<Func<Ss?>>(

    9652. 

  9652. 					                Expression.Constant(val, typeof(Ss?)),

    9653. 

  9653. 					                new System.Collections.Generic.List<ParameterExpression>());

    9654. 

  9654. 					        Func<Ss?> f = e.Compile();

    9655. 

  9655. 					        return object.Equals(f(), val);

    9656. 

  9656. 					    }

    9657. 

  9657. 					}

    9658. 

  9658. 				

    9659. 

  9659. 				

    9660. 

  9660. 				public  static class Ext {

    9661. 

  9661. 				    public static void StartCapture() {

    9662. 

  9662. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9663. 

  9663. 				//        m.Invoke(null, new object[] { "test.dll" });

    9664. 

  9664. 				    }

    9665. 

  9665. 				

    9666. 

  9666. 				    public static void StopCapture() {

    9667. 

  9667. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9668. 

  9668. 				//        m.Invoke(null, new object[0]);

    9669. 

  9669. 				    }

    9670. 

  9670. 				

    9671. 

  9671. 				    public static bool IsIntegralOrEnum(Type type) {

    9672. 

  9672. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9673. 

  9673. 				            case TypeCode.Byte:

    9674. 

  9674. 				            case TypeCode.SByte:

    9675. 

  9675. 				            case TypeCode.Int16:

    9676. 

  9676. 				            case TypeCode.Int32:

    9677. 

  9677. 				            case TypeCode.Int64:

    9678. 

  9678. 				            case TypeCode.UInt16:

    9679. 

  9679. 				            case TypeCode.UInt32:

    9680. 

  9680. 				            case TypeCode.UInt64:

    9681. 

  9681. 				                return true;

    9682. 

  9682. 				            default:

    9683. 

  9683. 				                return false;

    9684. 

  9684. 				        }

    9685. 

  9685. 				    }

    9686. 

  9686. 				

    9687. 

  9687. 				    public static bool IsFloating(Type type) {

    9688. 

  9688. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9689. 

  9689. 				            case TypeCode.Single:

    9690. 

  9690. 				            case TypeCode.Double:

    9691. 

  9691. 				                return true;

    9692. 

  9692. 				            default:

    9693. 

  9693. 				                return false;

    9694. 

  9694. 				        }

    9695. 

  9695. 				    }

    9696. 

  9696. 				

    9697. 

  9697. 				    public static Type GetNonNullableType(Type type) {

    9698. 

  9698. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9699. 

  9699. 				                type.GetGenericArguments()[0] :

    9700. 

  9700. 				                type;

    9701. 

  9701. 				    }

    9702. 

  9702. 				}

    9703. 

  9703. 				

    9704. 

  9704. 			

    9705. 

  9705. 			

    9706. 

  9706. 			

    9707. 

  9707. 			public interface I {

    9708. 

  9708. 			  void M();

    9709. 

  9709. 			}

    9710. 

  9710. 			

    9711. 

  9711. 			public  class C : IEquatable<C>, I {

    9712. 

  9712. 			    void I.M() {

    9713. 

  9713. 			    }

    9714. 

  9714. 			

    9715. 

  9715. 			    public override bool Equals(object o) {

    9716. 

  9716. 			        return o is C && Equals((C) o);

    9717. 

  9717. 			    }

    9718. 

  9718. 			

    9719. 

  9719. 			    public bool Equals(C c) {

    9720. 

  9720. 			        return c != null;

    9721. 

  9721. 			    }

    9722. 

  9722. 			

    9723. 

  9723. 			    public override int GetHashCode() {

    9724. 

  9724. 			        return 0;

    9725. 

  9725. 			    }

    9726. 

  9726. 			}

    9727. 

  9727. 			

    9728. 

  9728. 			public  class D : C, IEquatable<D> {

    9729. 

  9729. 			    public int Val;

    9730. 

  9730. 			    public D() {

    9731. 

  9731. 			    }

    9732. 

  9732. 			    public D(int val) {

    9733. 

  9733. 			        Val = val;

    9734. 

  9734. 			    }

    9735. 

  9735. 			

    9736. 

  9736. 			    public override bool Equals(object o) {

    9737. 

  9737. 			        return o is D && Equals((D) o);

    9738. 

  9738. 			    }

    9739. 

  9739. 			

    9740. 

  9740. 			    public bool Equals(D d) {

    9741. 

  9741. 			        return d != null && d.Val == Val;

    9742. 

  9742. 			    }

    9743. 

  9743. 			

    9744. 

  9744. 			    public override int GetHashCode() {

    9745. 

  9745. 			        return Val;

    9746. 

  9746. 			    }

    9747. 

  9747. 			}

    9748. 

  9748. 			

    9749. 

  9749. 			public enum E {

    9750. 

  9750. 			  A=1, B=2

    9751. 

  9751. 			}

    9752. 

  9752. 			

    9753. 

  9753. 			public enum El : long {

    9754. 

  9754. 			  A, B, C

    9755. 

  9755. 			}

    9756. 

  9756. 			

    9757. 

  9757. 			public struct S : IEquatable<S> {

    9758. 

  9758. 			    public override bool Equals(object o) {

    9759. 

  9759. 			        return (o is S) && Equals((S) o);

    9760. 

  9760. 			    }

    9761. 

  9761. 			    public bool Equals(S other) {

    9762. 

  9762. 			        return true;

    9763. 

  9763. 			    }

    9764. 

  9764. 			    public override int GetHashCode() {

    9765. 

  9765. 			        return 0;

    9766. 

  9766. 			    }

    9767. 

  9767. 			}

    9768. 

  9768. 			

    9769. 

  9769. 			public struct Sp : IEquatable<Sp> {

    9770. 

  9770. 			    public Sp(int i, double d) {

    9771. 

  9771. 			        I = i;

    9772. 

  9772. 			        D = d;

    9773. 

  9773. 			    }

    9774. 

  9774. 			

    9775. 

  9775. 			    public int I;

    9776. 

  9776. 			    public double D;

    9777. 

  9777. 			

    9778. 

  9778. 			    public override bool Equals(object o) {

    9779. 

  9779. 			        return (o is Sp) && Equals((Sp) o);

    9780. 

  9780. 			    }

    9781. 

  9781. 			    public bool Equals(Sp other) {

    9782. 

  9782. 			        return other.I == I && other.D == D;

    9783. 

  9783. 			    }

    9784. 

  9784. 			    public override int GetHashCode() {

    9785. 

  9785. 			        return I.GetHashCode() ^ D.GetHashCode();

    9786. 

  9786. 			    }

    9787. 

  9787. 			}

    9788. 

  9788. 			

    9789. 

  9789. 			public struct Ss : IEquatable<Ss> {

    9790. 

  9790. 			    public Ss(S s) {

    9791. 

  9791. 			        Val = s;

    9792. 

  9792. 			    }

    9793. 

  9793. 			

    9794. 

  9794. 			    public S Val;

    9795. 

  9795. 			

    9796. 

  9796. 			    public override bool Equals(object o) {

    9797. 

  9797. 			        return (o is Ss) && Equals((Ss) o);

    9798. 

  9798. 			    }

    9799. 

  9799. 			    public bool Equals(Ss other) {

    9800. 

  9800. 			        return other.Val.Equals(Val);

    9801. 

  9801. 			    }

    9802. 

  9802. 			    public override int GetHashCode() {

    9803. 

  9803. 			        return Val.GetHashCode();

    9804. 

  9804. 			    }

    9805. 

  9805. 			}

    9806. 

  9806. 			

    9807. 

  9807. 			public struct Sc : IEquatable<Sc> {

    9808. 

  9808. 			    public Sc(string s) {

    9809. 

  9809. 			        S = s;

    9810. 

  9810. 			    }

    9811. 

  9811. 			

    9812. 

  9812. 			    public string S;

    9813. 

  9813. 			

    9814. 

  9814. 			    public override bool Equals(object o) {

    9815. 

  9815. 			        return (o is Sc) && Equals((Sc) o);

    9816. 

  9816. 			    }

    9817. 

  9817. 			    public bool Equals(Sc other) {

    9818. 

  9818. 			        return other.S == S;

    9819. 

  9819. 			    }

    9820. 

  9820. 			    public override int GetHashCode() {

    9821. 

  9821. 			        return S.GetHashCode();

    9822. 

  9822. 			    }

    9823. 

  9823. 			}

    9824. 

  9824. 			

    9825. 

  9825. 			public struct Scs : IEquatable<Scs> {

    9826. 

  9826. 			    public Scs(string s, S val) {

    9827. 

  9827. 			        S = s;

    9828. 

  9828. 			        Val = val;

    9829. 

  9829. 			    }

    9830. 

  9830. 			

    9831. 

  9831. 			    public string S;

    9832. 

  9832. 			    public S Val;

    9833. 

  9833. 			

    9834. 

  9834. 			    public override bool Equals(object o) {

    9835. 

  9835. 			        return (o is Scs) && Equals((Scs) o);

    9836. 

  9836. 			    }

    9837. 

  9837. 			    public bool Equals(Scs other) {

    9838. 

  9838. 			        return other.S == S && other.Val.Equals(Val);

    9839. 

  9839. 			    }

    9840. 

  9840. 			    public override int GetHashCode() {

    9841. 

  9841. 			        return S.GetHashCode() ^ Val.GetHashCode();

    9842. 

  9842. 			    }

    9843. 

  9843. 			}

    9844. 

  9844. 			

    9845. 

  9845. 		

    9846. 

  9846. 	}

    9847. 

  9847. 				

    9848. 

  9848. 				//-------- Scenario 1765

    9849. 

  9849. 				namespace Scenario1765{

    9850. 

  9850. 					

    9851. 

  9851. 					public class Test

    9852. 

  9852. 					{

    9853. 

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

    9854. 

  9854. 				    public static Expression check51__() {

    9855. 

  9855. 				       if(Main() != 0 ) {

    9856. 

  9856. 				           throw new Exception();

    9857. 

  9857. 				       } else { 

    9858. 

  9858. 				           return Expression.Constant(0);

    9859. 

  9859. 				       }

    9860. 

  9860. 				    }

    9861. 

  9861. 					public     static int Main()

    9862. 

  9862. 					    {

    9863. 

  9863. 					        Ext.StartCapture();

    9864. 

  9864. 					        bool success = false;

    9865. 

  9865. 					        try

    9866. 

  9866. 					        {

    9867. 

  9867. 					            success = check51();

    9868. 

  9868. 					        }

    9869. 

  9869. 					        finally

    9870. 

  9870. 					        {

    9871. 

  9871. 					            Ext.StopCapture();

    9872. 

  9872. 					        }

    9873. 

  9873. 					        return success ? 0 : 1;

    9874. 

  9874. 					    }

    9875. 

  9875. 					

    9876. 

  9876. 					    static bool check51() {

    9877. 

  9877. 					        foreach (Sc? val in new Sc?[] { null, default(Sc), new Sc(), new Sc(null) }) {

    9878. 

  9878. 					            if (!check51(val)) {

    9879. 

  9879. 					                return false;

    9880. 

  9880. 					            }

    9881. 

  9881. 					        }

    9882. 

  9882. 					        return true;

    9883. 

  9883. 					    }

    9884. 

  9884. 					

    9885. 

  9885. 					    static bool check51(Sc? val) {

    9886. 

  9886. 					        Expression<Func<Sc?>> e =

    9887. 

  9887. 					            Expression.Lambda<Func<Sc?>>(

    9888. 

  9888. 					                Expression.Constant(val, typeof(Sc?)),

    9889. 

  9889. 					                new System.Collections.Generic.List<ParameterExpression>());

    9890. 

  9890. 					        Func<Sc?> f = e.Compile();

    9891. 

  9891. 					        return object.Equals(f(), val);

    9892. 

  9892. 					    }

    9893. 

  9893. 					}

    9894. 

  9894. 				

    9895. 

  9895. 				

    9896. 

  9896. 				public  static class Ext {

    9897. 

  9897. 				    public static void StartCapture() {

    9898. 

  9898. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9899. 

  9899. 				//        m.Invoke(null, new object[] { "test.dll" });

    9900. 

  9900. 				    }

    9901. 

  9901. 				

    9902. 

  9902. 				    public static void StopCapture() {

    9903. 

  9903. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    9904. 

  9904. 				//        m.Invoke(null, new object[0]);

    9905. 

  9905. 				    }

    9906. 

  9906. 				

    9907. 

  9907. 				    public static bool IsIntegralOrEnum(Type type) {

    9908. 

  9908. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9909. 

  9909. 				            case TypeCode.Byte:

    9910. 

  9910. 				            case TypeCode.SByte:

    9911. 

  9911. 				            case TypeCode.Int16:

    9912. 

  9912. 				            case TypeCode.Int32:

    9913. 

  9913. 				            case TypeCode.Int64:

    9914. 

  9914. 				            case TypeCode.UInt16:

    9915. 

  9915. 				            case TypeCode.UInt32:

    9916. 

  9916. 				            case TypeCode.UInt64:

    9917. 

  9917. 				                return true;

    9918. 

  9918. 				            default:

    9919. 

  9919. 				                return false;

    9920. 

  9920. 				        }

    9921. 

  9921. 				    }

    9922. 

  9922. 				

    9923. 

  9923. 				    public static bool IsFloating(Type type) {

    9924. 

  9924. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    9925. 

  9925. 				            case TypeCode.Single:

    9926. 

  9926. 				            case TypeCode.Double:

    9927. 

  9927. 				                return true;

    9928. 

  9928. 				            default:

    9929. 

  9929. 				                return false;

    9930. 

  9930. 				        }

    9931. 

  9931. 				    }

    9932. 

  9932. 				

    9933. 

  9933. 				    public static Type GetNonNullableType(Type type) {

    9934. 

  9934. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    9935. 

  9935. 				                type.GetGenericArguments()[0] :

    9936. 

  9936. 				                type;

    9937. 

  9937. 				    }

    9938. 

  9938. 				}

    9939. 

  9939. 				

    9940. 

  9940. 			

    9941. 

  9941. 			

    9942. 

  9942. 			

    9943. 

  9943. 			public interface I {

    9944. 

  9944. 			  void M();

    9945. 

  9945. 			}

    9946. 

  9946. 			

    9947. 

  9947. 			public  class C : IEquatable<C>, I {

    9948. 

  9948. 			    void I.M() {

    9949. 

  9949. 			    }

    9950. 

  9950. 			

    9951. 

  9951. 			    public override bool Equals(object o) {

    9952. 

  9952. 			        return o is C && Equals((C) o);

    9953. 

  9953. 			    }

    9954. 

  9954. 			

    9955. 

  9955. 			    public bool Equals(C c) {

    9956. 

  9956. 			        return c != null;

    9957. 

  9957. 			    }

    9958. 

  9958. 			

    9959. 

  9959. 			    public override int GetHashCode() {

    9960. 

  9960. 			        return 0;

    9961. 

  9961. 			    }

    9962. 

  9962. 			}

    9963. 

  9963. 			

    9964. 

  9964. 			public  class D : C, IEquatable<D> {

    9965. 

  9965. 			    public int Val;

    9966. 

  9966. 			    public D() {

    9967. 

  9967. 			    }

    9968. 

  9968. 			    public D(int val) {

    9969. 

  9969. 			        Val = val;

    9970. 

  9970. 			    }

    9971. 

  9971. 			

    9972. 

  9972. 			    public override bool Equals(object o) {

    9973. 

  9973. 			        return o is D && Equals((D) o);

    9974. 

  9974. 			    }

    9975. 

  9975. 			

    9976. 

  9976. 			    public bool Equals(D d) {

    9977. 

  9977. 			        return d != null && d.Val == Val;

    9978. 

  9978. 			    }

    9979. 

  9979. 			

    9980. 

  9980. 			    public override int GetHashCode() {

    9981. 

  9981. 			        return Val;

    9982. 

  9982. 			    }

    9983. 

  9983. 			}

    9984. 

  9984. 			

    9985. 

  9985. 			public enum E {

    9986. 

  9986. 			  A=1, B=2

    9987. 

  9987. 			}

    9988. 

  9988. 			

    9989. 

  9989. 			public enum El : long {

    9990. 

  9990. 			  A, B, C

    9991. 

  9991. 			}

    9992. 

  9992. 			

    9993. 

  9993. 			public struct S : IEquatable<S> {

    9994. 

  9994. 			    public override bool Equals(object o) {

    9995. 

  9995. 			        return (o is S) && Equals((S) o);

    9996. 

  9996. 			    }

    9997. 

  9997. 			    public bool Equals(S other) {

    9998. 

  9998. 			        return true;

    9999. 

  9999. 			    }

    10000. 

  10000. 			    public override int GetHashCode() {

    10001. 

  10001. 			        return 0;

    10002. 

  10002. 			    }

    10003. 

  10003. 			}

    10004. 

  10004. 			

    10005. 

  10005. 			public struct Sp : IEquatable<Sp> {

    10006. 

  10006. 			    public Sp(int i, double d) {

    10007. 

  10007. 			        I = i;

    10008. 

  10008. 			        D = d;

    10009. 

  10009. 			    }

    10010. 

  10010. 			

    10011. 

  10011. 			    public int I;

    10012. 

  10012. 			    public double D;

    10013. 

  10013. 			

    10014. 

  10014. 			    public override bool Equals(object o) {

    10015. 

  10015. 			        return (o is Sp) && Equals((Sp) o);

    10016. 

  10016. 			    }

    10017. 

  10017. 			    public bool Equals(Sp other) {

    10018. 

  10018. 			        return other.I == I && other.D == D;

    10019. 

  10019. 			    }

    10020. 

  10020. 			    public override int GetHashCode() {

    10021. 

  10021. 			        return I.GetHashCode() ^ D.GetHashCode();

    10022. 

  10022. 			    }

    10023. 

  10023. 			}

    10024. 

  10024. 			

    10025. 

  10025. 			public struct Ss : IEquatable<Ss> {

    10026. 

  10026. 			    public Ss(S s) {

    10027. 

  10027. 			        Val = s;

    10028. 

  10028. 			    }

    10029. 

  10029. 			

    10030. 

  10030. 			    public S Val;

    10031. 

  10031. 			

    10032. 

  10032. 			    public override bool Equals(object o) {

    10033. 

  10033. 			        return (o is Ss) && Equals((Ss) o);

    10034. 

  10034. 			    }

    10035. 

  10035. 			    public bool Equals(Ss other) {

    10036. 

  10036. 			        return other.Val.Equals(Val);

    10037. 

  10037. 			    }

    10038. 

  10038. 			    public override int GetHashCode() {

    10039. 

  10039. 			        return Val.GetHashCode();

    10040. 

  10040. 			    }

    10041. 

  10041. 			}

    10042. 

  10042. 			

    10043. 

  10043. 			public struct Sc : IEquatable<Sc> {

    10044. 

  10044. 			    public Sc(string s) {

    10045. 

  10045. 			        S = s;

    10046. 

  10046. 			    }

    10047. 

  10047. 			

    10048. 

  10048. 			    public string S;

    10049. 

  10049. 			

    10050. 

  10050. 			    public override bool Equals(object o) {

    10051. 

  10051. 			        return (o is Sc) && Equals((Sc) o);

    10052. 

  10052. 			    }

    10053. 

  10053. 			    public bool Equals(Sc other) {

    10054. 

  10054. 			        return other.S == S;

    10055. 

  10055. 			    }

    10056. 

  10056. 			    public override int GetHashCode() {

    10057. 

  10057. 			        return S.GetHashCode();

    10058. 

  10058. 			    }

    10059. 

  10059. 			}

    10060. 

  10060. 			

    10061. 

  10061. 			public struct Scs : IEquatable<Scs> {

    10062. 

  10062. 			    public Scs(string s, S val) {

    10063. 

  10063. 			        S = s;

    10064. 

  10064. 			        Val = val;

    10065. 

  10065. 			    }

    10066. 

  10066. 			

    10067. 

  10067. 			    public string S;

    10068. 

  10068. 			    public S Val;

    10069. 

  10069. 			

    10070. 

  10070. 			    public override bool Equals(object o) {

    10071. 

  10071. 			        return (o is Scs) && Equals((Scs) o);

    10072. 

  10072. 			    }

    10073. 

  10073. 			    public bool Equals(Scs other) {

    10074. 

  10074. 			        return other.S == S && other.Val.Equals(Val);

    10075. 

  10075. 			    }

    10076. 

  10076. 			    public override int GetHashCode() {

    10077. 

  10077. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10078. 

  10078. 			    }

    10079. 

  10079. 			}

    10080. 

  10080. 			

    10081. 

  10081. 		

    10082. 

  10082. 	}

    10083. 

  10083. 				

    10084. 

  10084. 				//-------- Scenario 1766

    10085. 

  10085. 				namespace Scenario1766{

    10086. 

  10086. 					

    10087. 

  10087. 					public class Test

    10088. 

  10088. 					{

    10089. 

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

    10090. 

  10090. 				    public static Expression check52__() {

    10091. 

  10091. 				       if(Main() != 0 ) {

    10092. 

  10092. 				           throw new Exception();

    10093. 

  10093. 				       } else { 

    10094. 

  10094. 				           return Expression.Constant(0);

    10095. 

  10095. 				       }

    10096. 

  10096. 				    }

    10097. 

  10097. 					public     static int Main()

    10098. 

  10098. 					    {

    10099. 

  10099. 					        Ext.StartCapture();

    10100. 

  10100. 					        bool success = false;

    10101. 

  10101. 					        try

    10102. 

  10102. 					        {

    10103. 

  10103. 					            success = check52();

    10104. 

  10104. 					        }

    10105. 

  10105. 					        finally

    10106. 

  10106. 					        {

    10107. 

  10107. 					            Ext.StopCapture();

    10108. 

  10108. 					        }

    10109. 

  10109. 					        return success ? 0 : 1;

    10110. 

  10110. 					    }

    10111. 

  10111. 					

    10112. 

  10112. 					    static bool check52() {

    10113. 

  10113. 					        foreach (Scs? val in new Scs?[] { null, default(Scs), new Scs(), new Scs(null,new S()) }) {

    10114. 

  10114. 					            if (!check52(val)) {

    10115. 

  10115. 					                return false;

    10116. 

  10116. 					            }

    10117. 

  10117. 					        }

    10118. 

  10118. 					        return true;

    10119. 

  10119. 					    }

    10120. 

  10120. 					

    10121. 

  10121. 					    static bool check52(Scs? val) {

    10122. 

  10122. 					        Expression<Func<Scs?>> e =

    10123. 

  10123. 					            Expression.Lambda<Func<Scs?>>(

    10124. 

  10124. 					                Expression.Constant(val, typeof(Scs?)),

    10125. 

  10125. 					                new System.Collections.Generic.List<ParameterExpression>());

    10126. 

  10126. 					        Func<Scs?> f = e.Compile();

    10127. 

  10127. 					        return object.Equals(f(), val);

    10128. 

  10128. 					    }

    10129. 

  10129. 					}

    10130. 

  10130. 				

    10131. 

  10131. 				

    10132. 

  10132. 				public  static class Ext {

    10133. 

  10133. 				    public static void StartCapture() {

    10134. 

  10134. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10135. 

  10135. 				//        m.Invoke(null, new object[] { "test.dll" });

    10136. 

  10136. 				    }

    10137. 

  10137. 				

    10138. 

  10138. 				    public static void StopCapture() {

    10139. 

  10139. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10140. 

  10140. 				//        m.Invoke(null, new object[0]);

    10141. 

  10141. 				    }

    10142. 

  10142. 				

    10143. 

  10143. 				    public static bool IsIntegralOrEnum(Type type) {

    10144. 

  10144. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10145. 

  10145. 				            case TypeCode.Byte:

    10146. 

  10146. 				            case TypeCode.SByte:

    10147. 

  10147. 				            case TypeCode.Int16:

    10148. 

  10148. 				            case TypeCode.Int32:

    10149. 

  10149. 				            case TypeCode.Int64:

    10150. 

  10150. 				            case TypeCode.UInt16:

    10151. 

  10151. 				            case TypeCode.UInt32:

    10152. 

  10152. 				            case TypeCode.UInt64:

    10153. 

  10153. 				                return true;

    10154. 

  10154. 				            default:

    10155. 

  10155. 				                return false;

    10156. 

  10156. 				        }

    10157. 

  10157. 				    }

    10158. 

  10158. 				

    10159. 

  10159. 				    public static bool IsFloating(Type type) {

    10160. 

  10160. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10161. 

  10161. 				            case TypeCode.Single:

    10162. 

  10162. 				            case TypeCode.Double:

    10163. 

  10163. 				                return true;

    10164. 

  10164. 				            default:

    10165. 

  10165. 				                return false;

    10166. 

  10166. 				        }

    10167. 

  10167. 				    }

    10168. 

  10168. 				

    10169. 

  10169. 				    public static Type GetNonNullableType(Type type) {

    10170. 

  10170. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10171. 

  10171. 				                type.GetGenericArguments()[0] :

    10172. 

  10172. 				                type;

    10173. 

  10173. 				    }

    10174. 

  10174. 				}

    10175. 

  10175. 				

    10176. 

  10176. 			

    10177. 

  10177. 			

    10178. 

  10178. 			

    10179. 

  10179. 			public interface I {

    10180. 

  10180. 			  void M();

    10181. 

  10181. 			}

    10182. 

  10182. 			

    10183. 

  10183. 			public  class C : IEquatable<C>, I {

    10184. 

  10184. 			    void I.M() {

    10185. 

  10185. 			    }

    10186. 

  10186. 			

    10187. 

  10187. 			    public override bool Equals(object o) {

    10188. 

  10188. 			        return o is C && Equals((C) o);

    10189. 

  10189. 			    }

    10190. 

  10190. 			

    10191. 

  10191. 			    public bool Equals(C c) {

    10192. 

  10192. 			        return c != null;

    10193. 

  10193. 			    }

    10194. 

  10194. 			

    10195. 

  10195. 			    public override int GetHashCode() {

    10196. 

  10196. 			        return 0;

    10197. 

  10197. 			    }

    10198. 

  10198. 			}

    10199. 

  10199. 			

    10200. 

  10200. 			public  class D : C, IEquatable<D> {

    10201. 

  10201. 			    public int Val;

    10202. 

  10202. 			    public D() {

    10203. 

  10203. 			    }

    10204. 

  10204. 			    public D(int val) {

    10205. 

  10205. 			        Val = val;

    10206. 

  10206. 			    }

    10207. 

  10207. 			

    10208. 

  10208. 			    public override bool Equals(object o) {

    10209. 

  10209. 			        return o is D && Equals((D) o);

    10210. 

  10210. 			    }

    10211. 

  10211. 			

    10212. 

  10212. 			    public bool Equals(D d) {

    10213. 

  10213. 			        return d != null && d.Val == Val;

    10214. 

  10214. 			    }

    10215. 

  10215. 			

    10216. 

  10216. 			    public override int GetHashCode() {

    10217. 

  10217. 			        return Val;

    10218. 

  10218. 			    }

    10219. 

  10219. 			}

    10220. 

  10220. 			

    10221. 

  10221. 			public enum E {

    10222. 

  10222. 			  A=1, B=2

    10223. 

  10223. 			}

    10224. 

  10224. 			

    10225. 

  10225. 			public enum El : long {

    10226. 

  10226. 			  A, B, C

    10227. 

  10227. 			}

    10228. 

  10228. 			

    10229. 

  10229. 			public struct S : IEquatable<S> {

    10230. 

  10230. 			    public override bool Equals(object o) {

    10231. 

  10231. 			        return (o is S) && Equals((S) o);

    10232. 

  10232. 			    }

    10233. 

  10233. 			    public bool Equals(S other) {

    10234. 

  10234. 			        return true;

    10235. 

  10235. 			    }

    10236. 

  10236. 			    public override int GetHashCode() {

    10237. 

  10237. 			        return 0;

    10238. 

  10238. 			    }

    10239. 

  10239. 			}

    10240. 

  10240. 			

    10241. 

  10241. 			public struct Sp : IEquatable<Sp> {

    10242. 

  10242. 			    public Sp(int i, double d) {

    10243. 

  10243. 			        I = i;

    10244. 

  10244. 			        D = d;

    10245. 

  10245. 			    }

    10246. 

  10246. 			

    10247. 

  10247. 			    public int I;

    10248. 

  10248. 			    public double D;

    10249. 

  10249. 			

    10250. 

  10250. 			    public override bool Equals(object o) {

    10251. 

  10251. 			        return (o is Sp) && Equals((Sp) o);

    10252. 

  10252. 			    }

    10253. 

  10253. 			    public bool Equals(Sp other) {

    10254. 

  10254. 			        return other.I == I && other.D == D;

    10255. 

  10255. 			    }

    10256. 

  10256. 			    public override int GetHashCode() {

    10257. 

  10257. 			        return I.GetHashCode() ^ D.GetHashCode();

    10258. 

  10258. 			    }

    10259. 

  10259. 			}

    10260. 

  10260. 			

    10261. 

  10261. 			public struct Ss : IEquatable<Ss> {

    10262. 

  10262. 			    public Ss(S s) {

    10263. 

  10263. 			        Val = s;

    10264. 

  10264. 			    }

    10265. 

  10265. 			

    10266. 

  10266. 			    public S Val;

    10267. 

  10267. 			

    10268. 

  10268. 			    public override bool Equals(object o) {

    10269. 

  10269. 			        return (o is Ss) && Equals((Ss) o);

    10270. 

  10270. 			    }

    10271. 

  10271. 			    public bool Equals(Ss other) {

    10272. 

  10272. 			        return other.Val.Equals(Val);

    10273. 

  10273. 			    }

    10274. 

  10274. 			    public override int GetHashCode() {

    10275. 

  10275. 			        return Val.GetHashCode();

    10276. 

  10276. 			    }

    10277. 

  10277. 			}

    10278. 

  10278. 			

    10279. 

  10279. 			public struct Sc : IEquatable<Sc> {

    10280. 

  10280. 			    public Sc(string s) {

    10281. 

  10281. 			        S = s;

    10282. 

  10282. 			    }

    10283. 

  10283. 			

    10284. 

  10284. 			    public string S;

    10285. 

  10285. 			

    10286. 

  10286. 			    public override bool Equals(object o) {

    10287. 

  10287. 			        return (o is Sc) && Equals((Sc) o);

    10288. 

  10288. 			    }

    10289. 

  10289. 			    public bool Equals(Sc other) {

    10290. 

  10290. 			        return other.S == S;

    10291. 

  10291. 			    }

    10292. 

  10292. 			    public override int GetHashCode() {

    10293. 

  10293. 			        return S.GetHashCode();

    10294. 

  10294. 			    }

    10295. 

  10295. 			}

    10296. 

  10296. 			

    10297. 

  10297. 			public struct Scs : IEquatable<Scs> {

    10298. 

  10298. 			    public Scs(string s, S val) {

    10299. 

  10299. 			        S = s;

    10300. 

  10300. 			        Val = val;

    10301. 

  10301. 			    }

    10302. 

  10302. 			

    10303. 

  10303. 			    public string S;

    10304. 

  10304. 			    public S Val;

    10305. 

  10305. 			

    10306. 

  10306. 			    public override bool Equals(object o) {

    10307. 

  10307. 			        return (o is Scs) && Equals((Scs) o);

    10308. 

  10308. 			    }

    10309. 

  10309. 			    public bool Equals(Scs other) {

    10310. 

  10310. 			        return other.S == S && other.Val.Equals(Val);

    10311. 

  10311. 			    }

    10312. 

  10312. 			    public override int GetHashCode() {

    10313. 

  10313. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10314. 

  10314. 			    }

    10315. 

  10315. 			}

    10316. 

  10316. 			

    10317. 

  10317. 		

    10318. 

  10318. 	}

    10319. 

  10319. 				

    10320. 

  10320. 				//-------- Scenario 1767

    10321. 

  10321. 				namespace Scenario1767{

    10322. 

  10322. 					

    10323. 

  10323. 					public class Test

    10324. 

  10324. 					{

    10325. 

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

    10326. 

  10326. 				    public static Expression check53_S___() {

    10327. 

  10327. 				       if(Main() != 0 ) {

    10328. 

  10328. 				           throw new Exception();

    10329. 

  10329. 				       } else { 

    10330. 

  10330. 				           return Expression.Constant(0);

    10331. 

  10331. 				       }

    10332. 

  10332. 				    }

    10333. 

  10333. 					public     static int Main()

    10334. 

  10334. 					    {

    10335. 

  10335. 					        Ext.StartCapture();

    10336. 

  10336. 					        bool success = false;

    10337. 

  10337. 					        try

    10338. 

  10338. 					        {

    10339. 

  10339. 					            success = check53<S>();

    10340. 

  10340. 					        }

    10341. 

  10341. 					        finally

    10342. 

  10342. 					        {

    10343. 

  10343. 					            Ext.StopCapture();

    10344. 

  10344. 					        }

    10345. 

  10345. 					        return success ? 0 : 1;

    10346. 

  10346. 					    }

    10347. 

  10347. 					

    10348. 

  10348. 					    static bool check53<Ts>() where Ts : struct {

    10349. 

  10349. 					        foreach (Ts? val in new Ts?[] { null, default(Ts), new Ts() }) {

    10350. 

  10350. 					            if (!check53<Ts>(val)) {

    10351. 

  10351. 					                return false;

    10352. 

  10352. 					            }

    10353. 

  10353. 					        }

    10354. 

  10354. 					        return true;

    10355. 

  10355. 					    }

    10356. 

  10356. 					

    10357. 

  10357. 					    static bool check53<Ts>(Ts? val) where Ts : struct {

    10358. 

  10358. 					        Expression<Func<Ts?>> e =

    10359. 

  10359. 					            Expression.Lambda<Func<Ts?>>(

    10360. 

  10360. 					                Expression.Constant(val, typeof(Ts?)),

    10361. 

  10361. 					                new System.Collections.Generic.List<ParameterExpression>());

    10362. 

  10362. 					        Func<Ts?> f = e.Compile();

    10363. 

  10363. 					        return object.Equals(f(), val);

    10364. 

  10364. 					    }

    10365. 

  10365. 					}

    10366. 

  10366. 				

    10367. 

  10367. 				

    10368. 

  10368. 				public  static class Ext {

    10369. 

  10369. 				    public static void StartCapture() {

    10370. 

  10370. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10371. 

  10371. 				//        m.Invoke(null, new object[] { "test.dll" });

    10372. 

  10372. 				    }

    10373. 

  10373. 				

    10374. 

  10374. 				    public static void StopCapture() {

    10375. 

  10375. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10376. 

  10376. 				//        m.Invoke(null, new object[0]);

    10377. 

  10377. 				    }

    10378. 

  10378. 				

    10379. 

  10379. 				    public static bool IsIntegralOrEnum(Type type) {

    10380. 

  10380. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10381. 

  10381. 				            case TypeCode.Byte:

    10382. 

  10382. 				            case TypeCode.SByte:

    10383. 

  10383. 				            case TypeCode.Int16:

    10384. 

  10384. 				            case TypeCode.Int32:

    10385. 

  10385. 				            case TypeCode.Int64:

    10386. 

  10386. 				            case TypeCode.UInt16:

    10387. 

  10387. 				            case TypeCode.UInt32:

    10388. 

  10388. 				            case TypeCode.UInt64:

    10389. 

  10389. 				                return true;

    10390. 

  10390. 				            default:

    10391. 

  10391. 				                return false;

    10392. 

  10392. 				        }

    10393. 

  10393. 				    }

    10394. 

  10394. 				

    10395. 

  10395. 				    public static bool IsFloating(Type type) {

    10396. 

  10396. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10397. 

  10397. 				            case TypeCode.Single:

    10398. 

  10398. 				            case TypeCode.Double:

    10399. 

  10399. 				                return true;

    10400. 

  10400. 				            default:

    10401. 

  10401. 				                return false;

    10402. 

  10402. 				        }

    10403. 

  10403. 				    }

    10404. 

  10404. 				

    10405. 

  10405. 				    public static Type GetNonNullableType(Type type) {

    10406. 

  10406. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10407. 

  10407. 				                type.GetGenericArguments()[0] :

    10408. 

  10408. 				                type;

    10409. 

  10409. 				    }

    10410. 

  10410. 				}

    10411. 

  10411. 				

    10412. 

  10412. 			

    10413. 

  10413. 			

    10414. 

  10414. 			

    10415. 

  10415. 			public interface I {

    10416. 

  10416. 			  void M();

    10417. 

  10417. 			}

    10418. 

  10418. 			

    10419. 

  10419. 			public  class C : IEquatable<C>, I {

    10420. 

  10420. 			    void I.M() {

    10421. 

  10421. 			    }

    10422. 

  10422. 			

    10423. 

  10423. 			    public override bool Equals(object o) {

    10424. 

  10424. 			        return o is C && Equals((C) o);

    10425. 

  10425. 			    }

    10426. 

  10426. 			

    10427. 

  10427. 			    public bool Equals(C c) {

    10428. 

  10428. 			        return c != null;

    10429. 

  10429. 			    }

    10430. 

  10430. 			

    10431. 

  10431. 			    public override int GetHashCode() {

    10432. 

  10432. 			        return 0;

    10433. 

  10433. 			    }

    10434. 

  10434. 			}

    10435. 

  10435. 			

    10436. 

  10436. 			public  class D : C, IEquatable<D> {

    10437. 

  10437. 			    public int Val;

    10438. 

  10438. 			    public D() {

    10439. 

  10439. 			    }

    10440. 

  10440. 			    public D(int val) {

    10441. 

  10441. 			        Val = val;

    10442. 

  10442. 			    }

    10443. 

  10443. 			

    10444. 

  10444. 			    public override bool Equals(object o) {

    10445. 

  10445. 			        return o is D && Equals((D) o);

    10446. 

  10446. 			    }

    10447. 

  10447. 			

    10448. 

  10448. 			    public bool Equals(D d) {

    10449. 

  10449. 			        return d != null && d.Val == Val;

    10450. 

  10450. 			    }

    10451. 

  10451. 			

    10452. 

  10452. 			    public override int GetHashCode() {

    10453. 

  10453. 			        return Val;

    10454. 

  10454. 			    }

    10455. 

  10455. 			}

    10456. 

  10456. 			

    10457. 

  10457. 			public enum E {

    10458. 

  10458. 			  A=1, B=2

    10459. 

  10459. 			}

    10460. 

  10460. 			

    10461. 

  10461. 			public enum El : long {

    10462. 

  10462. 			  A, B, C

    10463. 

  10463. 			}

    10464. 

  10464. 			

    10465. 

  10465. 			public struct S : IEquatable<S> {

    10466. 

  10466. 			    public override bool Equals(object o) {

    10467. 

  10467. 			        return (o is S) && Equals((S) o);

    10468. 

  10468. 			    }

    10469. 

  10469. 			    public bool Equals(S other) {

    10470. 

  10470. 			        return true;

    10471. 

  10471. 			    }

    10472. 

  10472. 			    public override int GetHashCode() {

    10473. 

  10473. 			        return 0;

    10474. 

  10474. 			    }

    10475. 

  10475. 			}

    10476. 

  10476. 			

    10477. 

  10477. 			public struct Sp : IEquatable<Sp> {

    10478. 

  10478. 			    public Sp(int i, double d) {

    10479. 

  10479. 			        I = i;

    10480. 

  10480. 			        D = d;

    10481. 

  10481. 			    }

    10482. 

  10482. 			

    10483. 

  10483. 			    public int I;

    10484. 

  10484. 			    public double D;

    10485. 

  10485. 			

    10486. 

  10486. 			    public override bool Equals(object o) {

    10487. 

  10487. 			        return (o is Sp) && Equals((Sp) o);

    10488. 

  10488. 			    }

    10489. 

  10489. 			    public bool Equals(Sp other) {

    10490. 

  10490. 			        return other.I == I && other.D == D;

    10491. 

  10491. 			    }

    10492. 

  10492. 			    public override int GetHashCode() {

    10493. 

  10493. 			        return I.GetHashCode() ^ D.GetHashCode();

    10494. 

  10494. 			    }

    10495. 

  10495. 			}

    10496. 

  10496. 			

    10497. 

  10497. 			public struct Ss : IEquatable<Ss> {

    10498. 

  10498. 			    public Ss(S s) {

    10499. 

  10499. 			        Val = s;

    10500. 

  10500. 			    }

    10501. 

  10501. 			

    10502. 

  10502. 			    public S Val;

    10503. 

  10503. 			

    10504. 

  10504. 			    public override bool Equals(object o) {

    10505. 

  10505. 			        return (o is Ss) && Equals((Ss) o);

    10506. 

  10506. 			    }

    10507. 

  10507. 			    public bool Equals(Ss other) {

    10508. 

  10508. 			        return other.Val.Equals(Val);

    10509. 

  10509. 			    }

    10510. 

  10510. 			    public override int GetHashCode() {

    10511. 

  10511. 			        return Val.GetHashCode();

    10512. 

  10512. 			    }

    10513. 

  10513. 			}

    10514. 

  10514. 			

    10515. 

  10515. 			public struct Sc : IEquatable<Sc> {

    10516. 

  10516. 			    public Sc(string s) {

    10517. 

  10517. 			        S = s;

    10518. 

  10518. 			    }

    10519. 

  10519. 			

    10520. 

  10520. 			    public string S;

    10521. 

  10521. 			

    10522. 

  10522. 			    public override bool Equals(object o) {

    10523. 

  10523. 			        return (o is Sc) && Equals((Sc) o);

    10524. 

  10524. 			    }

    10525. 

  10525. 			    public bool Equals(Sc other) {

    10526. 

  10526. 			        return other.S == S;

    10527. 

  10527. 			    }

    10528. 

  10528. 			    public override int GetHashCode() {

    10529. 

  10529. 			        return S.GetHashCode();

    10530. 

  10530. 			    }

    10531. 

  10531. 			}

    10532. 

  10532. 			

    10533. 

  10533. 			public struct Scs : IEquatable<Scs> {

    10534. 

  10534. 			    public Scs(string s, S val) {

    10535. 

  10535. 			        S = s;

    10536. 

  10536. 			        Val = val;

    10537. 

  10537. 			    }

    10538. 

  10538. 			

    10539. 

  10539. 			    public string S;

    10540. 

  10540. 			    public S Val;

    10541. 

  10541. 			

    10542. 

  10542. 			    public override bool Equals(object o) {

    10543. 

  10543. 			        return (o is Scs) && Equals((Scs) o);

    10544. 

  10544. 			    }

    10545. 

  10545. 			    public bool Equals(Scs other) {

    10546. 

  10546. 			        return other.S == S && other.Val.Equals(Val);

    10547. 

  10547. 			    }

    10548. 

  10548. 			    public override int GetHashCode() {

    10549. 

  10549. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10550. 

  10550. 			    }

    10551. 

  10551. 			}

    10552. 

  10552. 			

    10553. 

  10553. 		

    10554. 

  10554. 	}

    10555. 

  10555. 				

    10556. 

  10556. 				//-------- Scenario 1768

    10557. 

  10557. 				namespace Scenario1768{

    10558. 

  10558. 					

    10559. 

  10559. 					public class Test

    10560. 

  10560. 					{

    10561. 

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

    10562. 

  10562. 				    public static Expression check53_Scs___() {

    10563. 

  10563. 				       if(Main() != 0 ) {

    10564. 

  10564. 				           throw new Exception();

    10565. 

  10565. 				       } else { 

    10566. 

  10566. 				           return Expression.Constant(0);

    10567. 

  10567. 				       }

    10568. 

  10568. 				    }

    10569. 

  10569. 					public     static int Main()

    10570. 

  10570. 					    {

    10571. 

  10571. 					        Ext.StartCapture();

    10572. 

  10572. 					        bool success = false;

    10573. 

  10573. 					        try

    10574. 

  10574. 					        {

    10575. 

  10575. 					            success = check53<Scs>();

    10576. 

  10576. 					        }

    10577. 

  10577. 					        finally

    10578. 

  10578. 					        {

    10579. 

  10579. 					            Ext.StopCapture();

    10580. 

  10580. 					        }

    10581. 

  10581. 					        return success ? 0 : 1;

    10582. 

  10582. 					    }

    10583. 

  10583. 					

    10584. 

  10584. 					    static bool check53<Ts>() where Ts : struct {

    10585. 

  10585. 					        foreach (Ts? val in new Ts?[] { null, default(Ts), new Ts() }) {

    10586. 

  10586. 					            if (!check53<Ts>(val)) {

    10587. 

  10587. 					                return false;

    10588. 

  10588. 					            }

    10589. 

  10589. 					        }

    10590. 

  10590. 					        return true;

    10591. 

  10591. 					    }

    10592. 

  10592. 					

    10593. 

  10593. 					    static bool check53<Ts>(Ts? val) where Ts : struct {

    10594. 

  10594. 					        Expression<Func<Ts?>> e =

    10595. 

  10595. 					            Expression.Lambda<Func<Ts?>>(

    10596. 

  10596. 					                Expression.Constant(val, typeof(Ts?)),

    10597. 

  10597. 					                new System.Collections.Generic.List<ParameterExpression>());

    10598. 

  10598. 					        Func<Ts?> f = e.Compile();

    10599. 

  10599. 					        return object.Equals(f(), val);

    10600. 

  10600. 					    }

    10601. 

  10601. 					}

    10602. 

  10602. 				

    10603. 

  10603. 				

    10604. 

  10604. 				public  static class Ext {

    10605. 

  10605. 				    public static void StartCapture() {

    10606. 

  10606. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10607. 

  10607. 				//        m.Invoke(null, new object[] { "test.dll" });

    10608. 

  10608. 				    }

    10609. 

  10609. 				

    10610. 

  10610. 				    public static void StopCapture() {

    10611. 

  10611. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10612. 

  10612. 				//        m.Invoke(null, new object[0]);

    10613. 

  10613. 				    }

    10614. 

  10614. 				

    10615. 

  10615. 				    public static bool IsIntegralOrEnum(Type type) {

    10616. 

  10616. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10617. 

  10617. 				            case TypeCode.Byte:

    10618. 

  10618. 				            case TypeCode.SByte:

    10619. 

  10619. 				            case TypeCode.Int16:

    10620. 

  10620. 				            case TypeCode.Int32:

    10621. 

  10621. 				            case TypeCode.Int64:

    10622. 

  10622. 				            case TypeCode.UInt16:

    10623. 

  10623. 				            case TypeCode.UInt32:

    10624. 

  10624. 				            case TypeCode.UInt64:

    10625. 

  10625. 				                return true;

    10626. 

  10626. 				            default:

    10627. 

  10627. 				                return false;

    10628. 

  10628. 				        }

    10629. 

  10629. 				    }

    10630. 

  10630. 				

    10631. 

  10631. 				    public static bool IsFloating(Type type) {

    10632. 

  10632. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10633. 

  10633. 				            case TypeCode.Single:

    10634. 

  10634. 				            case TypeCode.Double:

    10635. 

  10635. 				                return true;

    10636. 

  10636. 				            default:

    10637. 

  10637. 				                return false;

    10638. 

  10638. 				        }

    10639. 

  10639. 				    }

    10640. 

  10640. 				

    10641. 

  10641. 				    public static Type GetNonNullableType(Type type) {

    10642. 

  10642. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10643. 

  10643. 				                type.GetGenericArguments()[0] :

    10644. 

  10644. 				                type;

    10645. 

  10645. 				    }

    10646. 

  10646. 				}

    10647. 

  10647. 				

    10648. 

  10648. 			

    10649. 

  10649. 			

    10650. 

  10650. 			

    10651. 

  10651. 			public interface I {

    10652. 

  10652. 			  void M();

    10653. 

  10653. 			}

    10654. 

  10654. 			

    10655. 

  10655. 			public  class C : IEquatable<C>, I {

    10656. 

  10656. 			    void I.M() {

    10657. 

  10657. 			    }

    10658. 

  10658. 			

    10659. 

  10659. 			    public override bool Equals(object o) {

    10660. 

  10660. 			        return o is C && Equals((C) o);

    10661. 

  10661. 			    }

    10662. 

  10662. 			

    10663. 

  10663. 			    public bool Equals(C c) {

    10664. 

  10664. 			        return c != null;

    10665. 

  10665. 			    }

    10666. 

  10666. 			

    10667. 

  10667. 			    public override int GetHashCode() {

    10668. 

  10668. 			        return 0;

    10669. 

  10669. 			    }

    10670. 

  10670. 			}

    10671. 

  10671. 			

    10672. 

  10672. 			public  class D : C, IEquatable<D> {

    10673. 

  10673. 			    public int Val;

    10674. 

  10674. 			    public D() {

    10675. 

  10675. 			    }

    10676. 

  10676. 			    public D(int val) {

    10677. 

  10677. 			        Val = val;

    10678. 

  10678. 			    }

    10679. 

  10679. 			

    10680. 

  10680. 			    public override bool Equals(object o) {

    10681. 

  10681. 			        return o is D && Equals((D) o);

    10682. 

  10682. 			    }

    10683. 

  10683. 			

    10684. 

  10684. 			    public bool Equals(D d) {

    10685. 

  10685. 			        return d != null && d.Val == Val;

    10686. 

  10686. 			    }

    10687. 

  10687. 			

    10688. 

  10688. 			    public override int GetHashCode() {

    10689. 

  10689. 			        return Val;

    10690. 

  10690. 			    }

    10691. 

  10691. 			}

    10692. 

  10692. 			

    10693. 

  10693. 			public enum E {

    10694. 

  10694. 			  A=1, B=2

    10695. 

  10695. 			}

    10696. 

  10696. 			

    10697. 

  10697. 			public enum El : long {

    10698. 

  10698. 			  A, B, C

    10699. 

  10699. 			}

    10700. 

  10700. 			

    10701. 

  10701. 			public struct S : IEquatable<S> {

    10702. 

  10702. 			    public override bool Equals(object o) {

    10703. 

  10703. 			        return (o is S) && Equals((S) o);

    10704. 

  10704. 			    }

    10705. 

  10705. 			    public bool Equals(S other) {

    10706. 

  10706. 			        return true;

    10707. 

  10707. 			    }

    10708. 

  10708. 			    public override int GetHashCode() {

    10709. 

  10709. 			        return 0;

    10710. 

  10710. 			    }

    10711. 

  10711. 			}

    10712. 

  10712. 			

    10713. 

  10713. 			public struct Sp : IEquatable<Sp> {

    10714. 

  10714. 			    public Sp(int i, double d) {

    10715. 

  10715. 			        I = i;

    10716. 

  10716. 			        D = d;

    10717. 

  10717. 			    }

    10718. 

  10718. 			

    10719. 

  10719. 			    public int I;

    10720. 

  10720. 			    public double D;

    10721. 

  10721. 			

    10722. 

  10722. 			    public override bool Equals(object o) {

    10723. 

  10723. 			        return (o is Sp) && Equals((Sp) o);

    10724. 

  10724. 			    }

    10725. 

  10725. 			    public bool Equals(Sp other) {

    10726. 

  10726. 			        return other.I == I && other.D == D;

    10727. 

  10727. 			    }

    10728. 

  10728. 			    public override int GetHashCode() {

    10729. 

  10729. 			        return I.GetHashCode() ^ D.GetHashCode();

    10730. 

  10730. 			    }

    10731. 

  10731. 			}

    10732. 

  10732. 			

    10733. 

  10733. 			public struct Ss : IEquatable<Ss> {

    10734. 

  10734. 			    public Ss(S s) {

    10735. 

  10735. 			        Val = s;

    10736. 

  10736. 			    }

    10737. 

  10737. 			

    10738. 

  10738. 			    public S Val;

    10739. 

  10739. 			

    10740. 

  10740. 			    public override bool Equals(object o) {

    10741. 

  10741. 			        return (o is Ss) && Equals((Ss) o);

    10742. 

  10742. 			    }

    10743. 

  10743. 			    public bool Equals(Ss other) {

    10744. 

  10744. 			        return other.Val.Equals(Val);

    10745. 

  10745. 			    }

    10746. 

  10746. 			    public override int GetHashCode() {

    10747. 

  10747. 			        return Val.GetHashCode();

    10748. 

  10748. 			    }

    10749. 

  10749. 			}

    10750. 

  10750. 			

    10751. 

  10751. 			public struct Sc : IEquatable<Sc> {

    10752. 

  10752. 			    public Sc(string s) {

    10753. 

  10753. 			        S = s;

    10754. 

  10754. 			    }

    10755. 

  10755. 			

    10756. 

  10756. 			    public string S;

    10757. 

  10757. 			

    10758. 

  10758. 			    public override bool Equals(object o) {

    10759. 

  10759. 			        return (o is Sc) && Equals((Sc) o);

    10760. 

  10760. 			    }

    10761. 

  10761. 			    public bool Equals(Sc other) {

    10762. 

  10762. 			        return other.S == S;

    10763. 

  10763. 			    }

    10764. 

  10764. 			    public override int GetHashCode() {

    10765. 

  10765. 			        return S.GetHashCode();

    10766. 

  10766. 			    }

    10767. 

  10767. 			}

    10768. 

  10768. 			

    10769. 

  10769. 			public struct Scs : IEquatable<Scs> {

    10770. 

  10770. 			    public Scs(string s, S val) {

    10771. 

  10771. 			        S = s;

    10772. 

  10772. 			        Val = val;

    10773. 

  10773. 			    }

    10774. 

  10774. 			

    10775. 

  10775. 			    public string S;

    10776. 

  10776. 			    public S Val;

    10777. 

  10777. 			

    10778. 

  10778. 			    public override bool Equals(object o) {

    10779. 

  10779. 			        return (o is Scs) && Equals((Scs) o);

    10780. 

  10780. 			    }

    10781. 

  10781. 			    public bool Equals(Scs other) {

    10782. 

  10782. 			        return other.S == S && other.Val.Equals(Val);

    10783. 

  10783. 			    }

    10784. 

  10784. 			    public override int GetHashCode() {

    10785. 

  10785. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10786. 

  10786. 			    }

    10787. 

  10787. 			}

    10788. 

  10788. 			

    10789. 

  10789. 		

    10790. 

  10790. 	}

    10791. 

  10791. 				

    10792. 

  10792. 				//-------- Scenario 1769

    10793. 

  10793. 				namespace Scenario1769{

    10794. 

  10794. 					

    10795. 

  10795. 					public class Test

    10796. 

  10796. 					{

    10797. 

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

    10798. 

  10798. 				    public static Expression check53_E___() {

    10799. 

  10799. 				       if(Main() != 0 ) {

    10800. 

  10800. 				           throw new Exception();

    10801. 

  10801. 				       } else { 

    10802. 

  10802. 				           return Expression.Constant(0);

    10803. 

  10803. 				       }

    10804. 

  10804. 				    }

    10805. 

  10805. 					public     static int Main()

    10806. 

  10806. 					    {

    10807. 

  10807. 					        Ext.StartCapture();

    10808. 

  10808. 					        bool success = false;

    10809. 

  10809. 					        try

    10810. 

  10810. 					        {

    10811. 

  10811. 					            success = check53<E>();

    10812. 

  10812. 					        }

    10813. 

  10813. 					        finally

    10814. 

  10814. 					        {

    10815. 

  10815. 					            Ext.StopCapture();

    10816. 

  10816. 					        }

    10817. 

  10817. 					        return success ? 0 : 1;

    10818. 

  10818. 					    }

    10819. 

  10819. 					

    10820. 

  10820. 					    static bool check53<Ts>() where Ts : struct {

    10821. 

  10821. 					        foreach (Ts? val in new Ts?[] { null, default(Ts), new Ts() }) {

    10822. 

  10822. 					            if (!check53<Ts>(val)) {

    10823. 

  10823. 					                return false;

    10824. 

  10824. 					            }

    10825. 

  10825. 					        }

    10826. 

  10826. 					        return true;

    10827. 

  10827. 					    }

    10828. 

  10828. 					

    10829. 

  10829. 					    static bool check53<Ts>(Ts? val) where Ts : struct {

    10830. 

  10830. 					        Expression<Func<Ts?>> e =

    10831. 

  10831. 					            Expression.Lambda<Func<Ts?>>(

    10832. 

  10832. 					                Expression.Constant(val, typeof(Ts?)),

    10833. 

  10833. 					                new System.Collections.Generic.List<ParameterExpression>());

    10834. 

  10834. 					        Func<Ts?> f = e.Compile();

    10835. 

  10835. 					        return object.Equals(f(), val);

    10836. 

  10836. 					    }

    10837. 

  10837. 					}

    10838. 

  10838. 				

    10839. 

  10839. 				

    10840. 

  10840. 				public  static class Ext {

    10841. 

  10841. 				    public static void StartCapture() {

    10842. 

  10842. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10843. 

  10843. 				//        m.Invoke(null, new object[] { "test.dll" });

    10844. 

  10844. 				    }

    10845. 

  10845. 				

    10846. 

  10846. 				    public static void StopCapture() {

    10847. 

  10847. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10848. 

  10848. 				//        m.Invoke(null, new object[0]);

    10849. 

  10849. 				    }

    10850. 

  10850. 				

    10851. 

  10851. 				    public static bool IsIntegralOrEnum(Type type) {

    10852. 

  10852. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10853. 

  10853. 				            case TypeCode.Byte:

    10854. 

  10854. 				            case TypeCode.SByte:

    10855. 

  10855. 				            case TypeCode.Int16:

    10856. 

  10856. 				            case TypeCode.Int32:

    10857. 

  10857. 				            case TypeCode.Int64:

    10858. 

  10858. 				            case TypeCode.UInt16:

    10859. 

  10859. 				            case TypeCode.UInt32:

    10860. 

  10860. 				            case TypeCode.UInt64:

    10861. 

  10861. 				                return true;

    10862. 

  10862. 				            default:

    10863. 

  10863. 				                return false;

    10864. 

  10864. 				        }

    10865. 

  10865. 				    }

    10866. 

  10866. 				

    10867. 

  10867. 				    public static bool IsFloating(Type type) {

    10868. 

  10868. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10869. 

  10869. 				            case TypeCode.Single:

    10870. 

  10870. 				            case TypeCode.Double:

    10871. 

  10871. 				                return true;

    10872. 

  10872. 				            default:

    10873. 

  10873. 				                return false;

    10874. 

  10874. 				        }

    10875. 

  10875. 				    }

    10876. 

  10876. 				

    10877. 

  10877. 				    public static Type GetNonNullableType(Type type) {

    10878. 

  10878. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10879. 

  10879. 				                type.GetGenericArguments()[0] :

    10880. 

  10880. 				                type;

    10881. 

  10881. 				    }

    10882. 

  10882. 				}

    10883. 

  10883. 				

    10884. 

  10884. 			

    10885. 

  10885. 			

    10886. 

  10886. 			

    10887. 

  10887. 			public interface I {

    10888. 

  10888. 			  void M();

    10889. 

  10889. 			}

    10890. 

  10890. 			

    10891. 

  10891. 			public  class C : IEquatable<C>, I {

    10892. 

  10892. 			    void I.M() {

    10893. 

  10893. 			    }

    10894. 

  10894. 			

    10895. 

  10895. 			    public override bool Equals(object o) {

    10896. 

  10896. 			        return o is C && Equals((C) o);

    10897. 

  10897. 			    }

    10898. 

  10898. 			

    10899. 

  10899. 			    public bool Equals(C c) {

    10900. 

  10900. 			        return c != null;

    10901. 

  10901. 			    }

    10902. 

  10902. 			

    10903. 

  10903. 			    public override int GetHashCode() {

    10904. 

  10904. 			        return 0;

    10905. 

  10905. 			    }

    10906. 

  10906. 			}

    10907. 

  10907. 			

    10908. 

  10908. 			public  class D : C, IEquatable<D> {

    10909. 

  10909. 			    public int Val;

    10910. 

  10910. 			    public D() {

    10911. 

  10911. 			    }

    10912. 

  10912. 			    public D(int val) {

    10913. 

  10913. 			        Val = val;

    10914. 

  10914. 			    }

    10915. 

  10915. 			

    10916. 

  10916. 			    public override bool Equals(object o) {

    10917. 

  10917. 			        return o is D && Equals((D) o);

    10918. 

  10918. 			    }

    10919. 

  10919. 			

    10920. 

  10920. 			    public bool Equals(D d) {

    10921. 

  10921. 			        return d != null && d.Val == Val;

    10922. 

  10922. 			    }

    10923. 

  10923. 			

    10924. 

  10924. 			    public override int GetHashCode() {

    10925. 

  10925. 			        return Val;

    10926. 

  10926. 			    }

    10927. 

  10927. 			}

    10928. 

  10928. 			

    10929. 

  10929. 			public enum E {

    10930. 

  10930. 			  A=1, B=2

    10931. 

  10931. 			}

    10932. 

  10932. 			

    10933. 

  10933. 			public enum El : long {

    10934. 

  10934. 			  A, B, C

    10935. 

  10935. 			}

    10936. 

  10936. 			

    10937. 

  10937. 			public struct S : IEquatable<S> {

    10938. 

  10938. 			    public override bool Equals(object o) {

    10939. 

  10939. 			        return (o is S) && Equals((S) o);

    10940. 

  10940. 			    }

    10941. 

  10941. 			    public bool Equals(S other) {

    10942. 

  10942. 			        return true;

    10943. 

  10943. 			    }

    10944. 

  10944. 			    public override int GetHashCode() {

    10945. 

  10945. 			        return 0;

    10946. 

  10946. 			    }

    10947. 

  10947. 			}

    10948. 

  10948. 			

    10949. 

  10949. 			public struct Sp : IEquatable<Sp> {

    10950. 

  10950. 			    public Sp(int i, double d) {

    10951. 

  10951. 			        I = i;

    10952. 

  10952. 			        D = d;

    10953. 

  10953. 			    }

    10954. 

  10954. 			

    10955. 

  10955. 			    public int I;

    10956. 

  10956. 			    public double D;

    10957. 

  10957. 			

    10958. 

  10958. 			    public override bool Equals(object o) {

    10959. 

  10959. 			        return (o is Sp) && Equals((Sp) o);

    10960. 

  10960. 			    }

    10961. 

  10961. 			    public bool Equals(Sp other) {

    10962. 

  10962. 			        return other.I == I && other.D == D;

    10963. 

  10963. 			    }

    10964. 

  10964. 			    public override int GetHashCode() {

    10965. 

  10965. 			        return I.GetHashCode() ^ D.GetHashCode();

    10966. 

  10966. 			    }

    10967. 

  10967. 			}

    10968. 

  10968. 			

    10969. 

  10969. 			public struct Ss : IEquatable<Ss> {

    10970. 

  10970. 			    public Ss(S s) {

    10971. 

  10971. 			        Val = s;

    10972. 

  10972. 			    }

    10973. 

  10973. 			

    10974. 

  10974. 			    public S Val;

    10975. 

  10975. 			

    10976. 

  10976. 			    public override bool Equals(object o) {

    10977. 

  10977. 			        return (o is Ss) && Equals((Ss) o);

    10978. 

  10978. 			    }

    10979. 

  10979. 			    public bool Equals(Ss other) {

    10980. 

  10980. 			        return other.Val.Equals(Val);

    10981. 

  10981. 			    }

    10982. 

  10982. 			    public override int GetHashCode() {

    10983. 

  10983. 			        return Val.GetHashCode();

    10984. 

  10984. 			    }

    10985. 

  10985. 			}

    10986. 

  10986. 			

    10987. 

  10987. 			public struct Sc : IEquatable<Sc> {

    10988. 

  10988. 			    public Sc(string s) {

    10989. 

  10989. 			        S = s;

    10990. 

  10990. 			    }

    10991. 

  10991. 			

    10992. 

  10992. 			    public string S;

    10993. 

  10993. 			

    10994. 

  10994. 			    public override bool Equals(object o) {

    10995. 

  10995. 			        return (o is Sc) && Equals((Sc) o);

    10996. 

  10996. 			    }

    10997. 

  10997. 			    public bool Equals(Sc other) {

    10998. 

  10998. 			        return other.S == S;

    10999. 

  10999. 			    }

    11000. 

  11000. 			    public override int GetHashCode() {

    11001. 

  11001. 			        return S.GetHashCode();

    11002. 

  11002. 			    }

    11003. 

  11003. 			}

    11004. 

  11004. 			

    11005. 

  11005. 			public struct Scs : IEquatable<Scs> {

    11006. 

  11006. 			    public Scs(string s, S val) {

    11007. 

  11007. 			        S = s;

    11008. 

  11008. 			        Val = val;

    11009. 

  11009. 			    }

    11010. 

  11010. 			

    11011. 

  11011. 			    public string S;

    11012. 

  11012. 			    public S Val;

    11013. 

  11013. 			

    11014. 

  11014. 			    public override bool Equals(object o) {

    11015. 

  11015. 			        return (o is Scs) && Equals((Scs) o);

    11016. 

  11016. 			    }

    11017. 

  11017. 			    public bool Equals(Scs other) {

    11018. 

  11018. 			        return other.S == S && other.Val.Equals(Val);

    11019. 

  11019. 			    }

    11020. 

  11020. 			    public override int GetHashCode() {

    11021. 

  11021. 			        return S.GetHashCode() ^ Val.GetHashCode();

    11022. 

  11022. 			    }

    11023. 

  11023. 			}

    11024. 

  11024. 			

    11025. 

  11025. 		

    11026. 

  11026. 	}

    11027. 

  11027. 				

    11028. 

  11028. 				//-------- Scenario 1770

    11029. 

  11029. 				namespace Scenario1770{

    11030. 

  11030. 					

    11031. 

  11031. 					public class Test

    11032. 

  11032. 					{

    11033. 

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

    11034. 

  11034. 				    public static Expression check54__() {

    11035. 

  11035. 				       if(Main() != 0 ) {

    11036. 

  11036. 				           throw new Exception();

    11037. 

  11037. 				       } else { 

    11038. 

  11038. 				           return Expression.Constant(0);

    11039. 

  11039. 				       }

    11040. 

  11040. 				    }

    11041. 

  11041. 					public     static int Main()

    11042. 

  11042. 					    {

    11043. 

  11043. 					        Ext.StartCapture();

    11044. 

  11044. 					        bool success = false;

    11045. 

  11045. 					        try

    11046. 

  11046. 					        {

    11047. 

  11047. 					            success = check54();

    11048. 

  11048. 					        }

    11049. 

  11049. 					        finally

    11050. 

  11050. 					        {

    11051. 

  11051. 					            Ext.StopCapture();

    11052. 

  11052. 					        }

    11053. 

  11053. 					        return success ? 0 : 1;

    11054. 

  11054. 					    }

    11055. 

  11055. 					

    11056. 

  11056. 					    static bool check54() {

    11057. 

  11057. 					        foreach (E? val in new E?[] { null, (E) 0, E.A, E.B, (E) int.MaxValue, (E) int.MinValue }) {

    11058. 

  11058. 					            if (!check54(val)) {

    11059. 

  11059. 					                return false;

    11060. 

  11060. 					            }

    11061. 

  11061. 					        }

    11062. 

  11062. 					        return true;

    11063. 

  11063. 					    }

    11064. 

  11064. 					

    11065. 

  11065. 					    static bool check54(E? val) {

    11066. 

  11066. 					        Expression<Func<E?>> e =

    11067. 

  11067. 					            Expression.Lambda<Func<E?>>(

    11068. 

  11068. 					                Expression.Constant(val, typeof(E?)),

    11069. 

  11069. 					                new System.Collections.Generic.List<ParameterExpression>());

    11070. 

  11070. 					        Func<E?> f = e.Compile();

    11071. 

  11071. 					        return object.Equals(f(), val);

    11072. 

  11072. 					    }

    11073. 

  11073. 					}

    11074. 

  11074. 				

    11075. 

  11075. 				

    11076. 

  11076. 				public  static class Ext {

    11077. 

  11077. 				    public static void StartCapture() {

    11078. 

  11078. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11079. 

  11079. 				//        m.Invoke(null, new object[] { "test.dll" });

    11080. 

  11080. 				    }

    11081. 

  11081. 				

    11082. 

  11082. 				    public static void StopCapture() {

    11083. 

  11083. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11084. 

  11084. 				//        m.Invoke(null, new object[0]);

    11085. 

  11085. 				    }

    11086. 

  11086. 				

    11087. 

  11087. 				    public static bool IsIntegralOrEnum(Type type) {

    11088. 

  11088. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11089. 

  11089. 				            case TypeCode.Byte:

    11090. 

  11090. 				            case TypeCode.SByte:

    11091. 

  11091. 				            case TypeCode.Int16:

    11092. 

  11092. 				            case TypeCode.Int32:

    11093. 

  11093. 				            case TypeCode.Int64:

    11094. 

  11094. 				            case TypeCode.UInt16:

    11095. 

  11095. 				            case TypeCode.UInt32:

    11096. 

  11096. 				            case TypeCode.UInt64:

    11097. 

  11097. 				                return true;

    11098. 

  11098. 				            default:

    11099. 

  11099. 				                return false;

    11100. 

  11100. 				        }

    11101. 

  11101. 				    }

    11102. 

  11102. 				

    11103. 

  11103. 				    public static bool IsFloating(Type type) {

    11104. 

  11104. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11105. 

  11105. 				            case TypeCode.Single:

    11106. 

  11106. 				            case TypeCode.Double:

    11107. 

  11107. 				                return true;

    11108. 

  11108. 				            default:

    11109. 

  11109. 				                return false;

    11110. 

  11110. 				        }

    11111. 

  11111. 				    }

    11112. 

  11112. 				

    11113. 

  11113. 				    public static Type GetNonNullableType(Type type) {

    11114. 

  11114. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11115. 

  11115. 				                type.GetGenericArguments()[0] :

    11116. 

  11116. 				                type;

    11117. 

  11117. 				    }

    11118. 

  11118. 				}

    11119. 

  11119. 				

    11120. 

  11120. 			

    11121. 

  11121. 			

    11122. 

  11122. 			

    11123. 

  11123. 			public interface I {

    11124. 

  11124. 			  void M();

    11125. 

  11125. 			}

    11126. 

  11126. 			

    11127. 

  11127. 			public  class C : IEquatable<C>, I {

    11128. 

  11128. 			    void I.M() {

    11129. 

  11129. 			    }

    11130. 

  11130. 			

    11131. 

  11131. 			    public override bool Equals(object o) {

    11132. 

  11132. 			        return o is C && Equals((C) o);

    11133. 

  11133. 			    }

    11134. 

  11134. 			

    11135. 

  11135. 			    public bool Equals(C c) {

    11136. 

  11136. 			        return c != null;

    11137. 

  11137. 			    }

    11138. 

  11138. 			

    11139. 

  11139. 			    public override int GetHashCode() {

    11140. 

  11140. 			        return 0;

    11141. 

  11141. 			    }

    11142. 

  11142. 			}

    11143. 

  11143. 			

    11144. 

  11144. 			public  class D : C, IEquatable<D> {

    11145. 

  11145. 			    public int Val;

    11146. 

  11146. 			    public D() {

    11147. 

  11147. 			    }

    11148. 

  11148. 			    public D(int val) {

    11149. 

  11149. 			        Val = val;

    11150. 

  11150. 			    }

    11151. 

  11151. 			

    11152. 

  11152. 			    public override bool Equals(object o) {

    11153. 

  11153. 			        return o is D && Equals((D) o);

    11154. 

  11154. 			    }

    11155. 

  11155. 			

    11156. 

  11156. 			    public bool Equals(D d) {

    11157. 

  11157. 			        return d != null && d.Val == Val;

    11158. 

  11158. 			    }

    11159. 

  11159. 			

    11160. 

  11160. 			    public override int GetHashCode() {

    11161. 

  11161. 			        return Val;

    11162. 

  11162. 			    }

    11163. 

  11163. 			}

    11164. 

  11164. 			

    11165. 

  11165. 			public enum E {

    11166. 

  11166. 			  A=1, B=2

    11167. 

  11167. 			}

    11168. 

  11168. 			

    11169. 

  11169. 			public enum El : long {

    11170. 

  11170. 			  A, B, C

    11171. 

  11171. 			}

    11172. 

  11172. 			

    11173. 

  11173. 			public struct S : IEquatable<S> {

    11174. 

  11174. 			    public override bool Equals(object o) {

    11175. 

  11175. 			        return (o is S) && Equals((S) o);

    11176. 

  11176. 			    }

    11177. 

  11177. 			    public bool Equals(S other) {

    11178. 

  11178. 			        return true;

    11179. 

  11179. 			    }

    11180. 

  11180. 			    public override int GetHashCode() {

    11181. 

  11181. 			        return 0;

    11182. 

  11182. 			    }

    11183. 

  11183. 			}

    11184. 

  11184. 			

    11185. 

  11185. 			public struct Sp : IEquatable<Sp> {

    11186. 

  11186. 			    public Sp(int i, double d) {

    11187. 

  11187. 			        I = i;

    11188. 

  11188. 			        D = d;

    11189. 

  11189. 			    }

    11190. 

  11190. 			

    11191. 

  11191. 			    public int I;

    11192. 

  11192. 			    public double D;

    11193. 

  11193. 			

    11194. 

  11194. 			    public override bool Equals(object o) {

    11195. 

  11195. 			        return (o is Sp) && Equals((Sp) o);

    11196. 

  11196. 			    }

    11197. 

  11197. 			    public bool Equals(Sp other) {

    11198. 

  11198. 			        return other.I == I && other.D == D;

    11199. 

  11199. 			    }

    11200. 

  11200. 			    public override int GetHashCode() {

    11201. 

  11201. 			        return I.GetHashCode() ^ D.GetHashCode();

    11202. 

  11202. 			    }

    11203. 

  11203. 			}

    11204. 

  11204. 			

    11205. 

  11205. 			public struct Ss : IEquatable<Ss> {

    11206. 

  11206. 			    public Ss(S s) {

    11207. 

  11207. 			        Val = s;

    11208. 

  11208. 			    }

    11209. 

  11209. 			

    11210. 

  11210. 			    public S Val;

    11211. 

  11211. 			

    11212. 

  11212. 			    public override bool Equals(object o) {

    11213. 

  11213. 			        return (o is Ss) && Equals((Ss) o);

    11214. 

  11214. 			    }

    11215. 

  11215. 			    public bool Equals(Ss other) {

    11216. 

  11216. 			        return other.Val.Equals(Val);

    11217. 

  11217. 			    }

    11218. 

  11218. 			    public override int GetHashCode() {

    11219. 

  11219. 			        return Val.GetHashCode();

    11220. 

  11220. 			    }

    11221. 

  11221. 			}

    11222. 

  11222. 			

    11223. 

  11223. 			public struct Sc : IEquatable<Sc> {

    11224. 

  11224. 			    public Sc(string s) {

    11225. 

  11225. 			        S = s;

    11226. 

  11226. 			    }

    11227. 

  11227. 			

    11228. 

  11228. 			    public string S;

    11229. 

  11229. 			

    11230. 

  11230. 			    public override bool Equals(object o) {

    11231. 

  11231. 			        return (o is Sc) && Equals((Sc) o);

    11232. 

  11232. 			    }

    11233. 

  11233. 			    public bool Equals(Sc other) {

    11234. 

  11234. 			        return other.S == S;

    11235. 

  11235. 			    }

    11236. 

  11236. 			    public override int GetHashCode() {

    11237. 

  11237. 			        return S.GetHashCode();

    11238. 

  11238. 			    }

    11239. 

  11239. 			}

    11240. 

  11240. 			

    11241. 

  11241. 			public struct Scs : IEquatable<Scs> {

    11242. 

  11242. 			    public Scs(string s, S val) {

    11243. 

  11243. 			        S = s;

    11244. 

  11244. 			        Val = val;

    11245. 

  11245. 			    }

    11246. 

  11246. 			

    11247. 

  11247. 			    public string S;

    11248. 

  11248. 			    public S Val;

    11249. 

  11249. 			

    11250. 

  11250. 			    public override bool Equals(object o) {

    11251. 

  11251. 			        return (o is Scs) && Equals((Scs) o);

    11252. 

  11252. 			    }

    11253. 

  11253. 			    public bool Equals(Scs other) {

    11254. 

  11254. 			        return other.S == S && other.Val.Equals(Val);

    11255. 

  11255. 			    }

    11256. 

  11256. 			    public override int GetHashCode() {

    11257. 

  11257. 			        return S.GetHashCode() ^ Val.GetHashCode();

    11258. 

  11258. 			    }

    11259. 

  11259. 			}

    11260. 

  11260. 			

    11261. 

  11261. 		

    11262. 

  11262. 	}

    11263. 

  11263. 				

    11264. 

  11264. 				//-------- Scenario 1771

    11265. 

  11265. 				namespace Scenario1771{

    11266. 

  11266. 					

    11267. 

  11267. 					public class Test

    11268. 

  11268. 					{

    11269. 

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

    11270. 

  11270. 				    public static Expression check55__() {

    11271. 

  11271. 				       if(Main() != 0 ) {

    11272. 

  11272. 				           throw new Exception();

    11273. 

  11273. 				       } else { 

    11274. 

  11274. 				           return Expression.Constant(0);

    11275. 

  11275. 				       }

    11276. 

  11276. 				    }

    11277. 

  11277. 					public     static int Main()

    11278. 

  11278. 					    {

    11279. 

  11279. 					        Ext.StartCapture();

    11280. 

  11280. 					        bool success = false;

    11281. 

  11281. 					        try

    11282. 

  11282. 					        {

    11283. 

  11283. 					            success = check55();

    11284. 

  11284. 					        }

    11285. 

  11285. 					        finally

    11286. 

  11286. 					        {

    11287. 

  11287. 					            Ext.StopCapture();

    11288. 

  11288. 					        }

    11289. 

  11289. 					        return success ? 0 : 1;

    11290. 

  11290. 					    }

    11291. 

  11291. 					

    11292. 

  11292. 					    static bool check55() {

    11293. 

  11293. 					        foreach (El? val in new El?[] { null, (El) 0, El.A, El.B, (El) long.MaxValue, (El) long.MinValue }) {

    11294. 

  11294. 					            if (!check55(val)) {

    11295. 

  11295. 					                return false;

    11296. 

  11296. 					            }

    11297. 

  11297. 					        }

    11298. 

  11298. 					        return true;

    11299. 

  11299. 					    }

    11300. 

  11300. 					

    11301. 

  11301. 					    static bool check55(El? val) {

    11302. 

  11302. 					        Expression<Func<El?>> e =

    11303. 

  11303. 					            Expression.Lambda<Func<El?>>(

    11304. 

  11304. 					                Expression.Constant(val, typeof(El?)),

    11305. 

  11305. 					                new System.Collections.Generic.List<ParameterExpression>());

    11306. 

  11306. 					        Func<El?> f = e.Compile();

    11307. 

  11307. 					        return object.Equals(f(), val);

    11308. 

  11308. 					    }

    11309. 

  11309. 					}

    11310. 

  11310. 				

    11311. 

  11311. 				

    11312. 

  11312. 				public  static class Ext {

    11313. 

  11313. 				    public static void StartCapture() {

    11314. 

  11314. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11315. 

  11315. 				//        m.Invoke(null, new object[] { "test.dll" });

    11316. 

  11316. 				    }

    11317. 

  11317. 				

    11318. 

  11318. 				    public static void StopCapture() {

    11319. 

  11319. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11320. 

  11320. 				//        m.Invoke(null, new object[0]);

    11321. 

  11321. 				    }

    11322. 

  11322. 				

    11323. 

  11323. 				    public static bool IsIntegralOrEnum(Type type) {

    11324. 

  11324. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11325. 

  11325. 				            case TypeCode.Byte:

    11326. 

  11326. 				            case TypeCode.SByte:

    11327. 

  11327. 				            case TypeCode.Int16:

    11328. 

  11328. 				            case TypeCode.Int32:

    11329. 

  11329. 				            case TypeCode.Int64:

    11330. 

  11330. 				            case TypeCode.UInt16:

    11331. 

  11331. 				            case TypeCode.UInt32:

    11332. 

  11332. 				            case TypeCode.UInt64:

    11333. 

  11333. 				                return true;

    11334. 

  11334. 				            default:

    11335. 

  11335. 				                return false;

    11336. 

  11336. 				        }

    11337. 

  11337. 				    }

    11338. 

  11338. 				

    11339. 

  11339. 				    public static bool IsFloating(Type type) {

    11340. 

  11340. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11341. 

  11341. 				            case TypeCode.Single:

    11342. 

  11342. 				            case TypeCode.Double:

    11343. 

  11343. 				                return true;

    11344. 

  11344. 				            default:

    11345. 

  11345. 				                return false;

    11346. 

  11346. 				        }

    11347. 

  11347. 				    }

    11348. 

  11348. 				

    11349. 

  11349. 				    public static Type GetNonNullableType(Type type) {

    11350. 

  11350. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11351. 

  11351. 				                type.GetGenericArguments()[0] :

    11352. 

  11352. 				                type;

    11353. 

  11353. 				    }

    11354. 

  11354. 				}

    11355. 

  11355. 				

    11356. 

  11356. 			

    11357. 

  11357. 			

    11358. 

  11358. 			

    11359. 

  11359. 			public interface I {

    11360. 

  11360. 			  void M();

    11361. 

  11361. 			}

    11362. 

  11362. 			

    11363. 

  11363. 			public  class C : IEquatable<C>, I {

    11364. 

  11364. 			    void I.M() {

    11365. 

  11365. 			    }

    11366. 

  11366. 			

    11367. 

  11367. 			    public override bool Equals(object o) {

    11368. 

  11368. 			        return o is C && Equals((C) o);

    11369. 

  11369. 			    }

    11370. 

  11370. 			

    11371. 

  11371. 			    public bool Equals(C c) {

    11372. 

  11372. 			        return c != null;

    11373. 

  11373. 			    }

    11374. 

  11374. 			

    11375. 

  11375. 			    public override int GetHashCode() {

    11376. 

  11376. 			        return 0;

    11377. 

  11377. 			    }

    11378. 

  11378. 			}

    11379. 

  11379. 			

    11380. 

  11380. 			public  class D : C, IEquatable<D> {

    11381. 

  11381. 			    public int Val;

    11382. 

  11382. 			    public D() {

    11383. 

  11383. 			    }

    11384. 

  11384. 			    public D(int val) {

    11385. 

  11385. 			        Val = val;

    11386. 

  11386. 			    }

    11387. 

  11387. 			

    11388. 

  11388. 			    public override bool Equals(object o) {

    11389. 

  11389. 			        return o is D && Equals((D) o);

    11390. 

  11390. 			    }

    11391. 

  11391. 			

    11392. 

  11392. 			    public bool Equals(D d) {

    11393. 

  11393. 			        return d != null && d.Val == Val;

    11394. 

  11394. 			    }

    11395. 

  11395. 			

    11396. 

  11396. 			    public override int GetHashCode() {

    11397. 

  11397. 			        return Val;

    11398. 

  11398. 			    }

    11399. 

  11399. 			}

    11400. 

  11400. 			

    11401. 

  11401. 			public enum E {

    11402. 

  11402. 			  A=1, B=2

    11403. 

  11403. 			}

    11404. 

  11404. 			

    11405. 

  11405. 			public enum El : long {

    11406. 

  11406. 			  A, B, C

    11407. 

  11407. 			}

    11408. 

  11408. 			

    11409. 

  11409. 			public struct S : IEquatable<S> {

    11410. 

  11410. 			    public override bool Equals(object o) {

    11411. 

  11411. 			        return (o is S) && Equals((S) o);

    11412. 

  11412. 			    }

    11413. 

  11413. 			    public bool Equals(S other) {

    11414. 

  11414. 			        return true;

    11415. 

  11415. 			    }

    11416. 

  11416. 			    public override int GetHashCode() {

    11417. 

  11417. 			        return 0;

    11418. 

  11418. 			    }

    11419. 

  11419. 			}

    11420. 

  11420. 			

    11421. 

  11421. 			public struct Sp : IEquatable<Sp> {

    11422. 

  11422. 			    public Sp(int i, double d) {

    11423. 

  11423. 			        I = i;

    11424. 

  11424. 			        D = d;

    11425. 

  11425. 			    }

    11426. 

  11426. 			

    11427. 

  11427. 			    public int I;

    11428. 

  11428. 			    public double D;

    11429. 

  11429. 			

    11430. 

  11430. 			    public override bool Equals(object o) {

    11431. 

  11431. 			        return (o is Sp) && Equals((Sp) o);

    11432. 

  11432. 			    }

    11433. 

  11433. 			    public bool Equals(Sp other) {

    11434. 

  11434. 			        return other.I == I && other.D == D;

    11435. 

  11435. 			    }

    11436. 

  11436. 			    public override int GetHashCode() {

    11437. 

  11437. 			        return I.GetHashCode() ^ D.GetHashCode();

    11438. 

  11438. 			    }

    11439. 

  11439. 			}

    11440. 

  11440. 			

    11441. 

  11441. 			public struct Ss : IEquatable<Ss> {

    11442. 

  11442. 			    public Ss(S s) {

    11443. 

  11443. 			        Val = s;

    11444. 

  11444. 			    }

    11445. 

  11445. 			

    11446. 

  11446. 			    public S Val;

    11447. 

  11447. 			

    11448. 

  11448. 			    public override bool Equals(object o) {

    11449. 

  11449. 			        return (o is Ss) && Equals((Ss) o);

    11450. 

  11450. 			    }

    11451. 

  11451. 			    public bool Equals(Ss other) {

    11452. 

  11452. 			        return other.Val.Equals(Val);

    11453. 

  11453. 			    }

    11454. 

  11454. 			    public override int GetHashCode() {

    11455. 

  11455. 			        return Val.GetHashCode();

    11456. 

  11456. 			    }

    11457. 

  11457. 			}

    11458. 

  11458. 			

    11459. 

  11459. 			public struct Sc : IEquatable<Sc> {

    11460. 

  11460. 			    public Sc(string s) {

    11461. 

  11461. 			        S = s;

    11462. 

  11462. 			    }

    11463. 

  11463. 			

    11464. 

  11464. 			    public string S;

    11465. 

  11465. 			

    11466. 

  11466. 			    public override bool Equals(object o) {

    11467. 

  11467. 			        return (o is Sc) && Equals((Sc) o);

    11468. 

  11468. 			    }

    11469. 

  11469. 			    public bool Equals(Sc other) {

    11470. 

  11470. 			        return other.S == S;

    11471. 

  11471. 			    }

    11472. 

  11472. 			    public override int GetHashCode() {

    11473. 

  11473. 			        return S.GetHashCode();

    11474. 

  11474. 			    }

    11475. 

  11475. 			}

    11476. 

  11476. 			

    11477. 

  11477. 			public struct Scs : IEquatable<Scs> {

    11478. 

  11478. 			    public Scs(string s, S val) {

    11479. 

  11479. 			        S = s;

    11480. 

  11480. 			        Val = val;

    11481. 

  11481. 			    }

    11482. 

  11482. 			

    11483. 

  11483. 			    public string S;

    11484. 

  11484. 			    public S Val;

    11485. 

  11485. 			

    11486. 

  11486. 			    public override bool Equals(object o) {

    11487. 

  11487. 			        return (o is Scs) && Equals((Scs) o);

    11488. 

  11488. 			    }

    11489. 

  11489. 			    public bool Equals(Scs other) {

    11490. 

  11490. 			        return other.S == S && other.Val.Equals(Val);

    11491. 

  11491. 			    }

    11492. 

  11492. 			    public override int GetHashCode() {

    11493. 

  11493. 			        return S.GetHashCode() ^ Val.GetHashCode();

    11494. 

  11494. 			    }

    11495. 

  11495. 			}

    11496. 

  11496. 			

    11497. 

  11497. 		

    11498. 

  11498. 	}

    11499. 

  11499. 			

    11500. 

  11500. 			//-------- Scenario 1772

    11501. 

  11501. 			namespace Scenario1772{

    11502. 

  11502. 				

    11503. 

  11503. 				public class Test

    11504. 

  11504. 				{

    11505. 

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

    11506. 

  11506. 			    public static Expression check56__() {

    11507. 

  11507. 			       if(Main() != 0 ) {

    11508. 

  11508. 			           throw new Exception();

    11509. 

  11509. 			       } else { 

    11510. 

  11510. 			           return Expression.Constant(0);

    11511. 

  11511. 			       }

    11512. 

  11512. 			    }

    11513. 

  11513. 				public     static int Main()

    11514. 

  11514. 				    {

    11515. 

  11515. 				        Ext.StartCapture();

    11516. 

  11516. 				        bool success = false;

    11517. 

  11517. 				        try

    11518. 

  11518. 				        {

    11519. 

  11519. 				            success = check56();

    11520. 

  11520. 				        }

    11521. 

  11521. 				        finally

    11522. 

  11522. 				        {

    11523. 

  11523. 				            Ext.StopCapture();

    11524. 

  11524. 				        }

    11525. 

  11525. 				        return success ? 0 : 1;

    11526. 

  11526. 				    }

    11527. 

  11527. 				

    11528. 

  11528. 				    static bool check56() {

    11529. 

  11529. 				        foreach (byte[] val in new byte[][] { null, new byte[0], new byte[] { 0, 1, byte.MaxValue }, new byte[100] }) {

    11530. 

  11530. 				            if (!check56(val)) {

    11531. 

  11531. 				                return false;

    11532. 

  11532. 				            }

    11533. 

  11533. 				        }

    11534. 

  11534. 				        return true;

    11535. 

  11535. 				    }

    11536. 

  11536. 				

    11537. 

  11537. 				    static bool check56(byte[] val) {

    11538. 

  11538. 				        Expression<Func<byte[]>> e =

    11539. 

  11539. 				            Expression.Lambda<Func<byte[]>>(

    11540. 

  11540. 				                Expression.Constant(val, typeof(byte[])),

    11541. 

  11541. 				                new System.Collections.Generic.List<ParameterExpression>());

    11542. 

  11542. 				        Func<byte[]> f = e.Compile();

    11543. 

  11543. 				        return object.Equals(f(), val);

    11544. 

  11544. 				    }

    11545. 

  11545. 				}

    11546. 

  11546. 			

    11547. 

  11547. 			

    11548. 

  11548. 			public  static class Ext {

    11549. 

  11549. 			    public static void StartCapture() {

    11550. 

  11550. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11551. 

  11551. 			//        m.Invoke(null, new object[] { "test.dll" });

    11552. 

  11552. 			    }

    11553. 

  11553. 			

    11554. 

  11554. 			    public static void StopCapture() {

    11555. 

  11555. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11556. 

  11556. 			//        m.Invoke(null, new object[0]);

    11557. 

  11557. 			    }

    11558. 

  11558. 			

    11559. 

  11559. 			    public static bool IsIntegralOrEnum(Type type) {

    11560. 

  11560. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11561. 

  11561. 			            case TypeCode.Byte:

    11562. 

  11562. 			            case TypeCode.SByte:

    11563. 

  11563. 			            case TypeCode.Int16:

    11564. 

  11564. 			            case TypeCode.Int32:

    11565. 

  11565. 			            case TypeCode.Int64:

    11566. 

  11566. 			            case TypeCode.UInt16:

    11567. 

  11567. 			            case TypeCode.UInt32:

    11568. 

  11568. 			            case TypeCode.UInt64:

    11569. 

  11569. 			                return true;

    11570. 

  11570. 			            default:

    11571. 

  11571. 			                return false;

    11572. 

  11572. 			        }

    11573. 

  11573. 			    }

    11574. 

  11574. 			

    11575. 

  11575. 			    public static bool IsFloating(Type type) {

    11576. 

  11576. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11577. 

  11577. 			            case TypeCode.Single:

    11578. 

  11578. 			            case TypeCode.Double:

    11579. 

  11579. 			                return true;

    11580. 

  11580. 			            default:

    11581. 

  11581. 			                return false;

    11582. 

  11582. 			        }

    11583. 

  11583. 			    }

    11584. 

  11584. 			

    11585. 

  11585. 			    public static Type GetNonNullableType(Type type) {

    11586. 

  11586. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11587. 

  11587. 			                type.GetGenericArguments()[0] :

    11588. 

  11588. 			                type;

    11589. 

  11589. 			    }

    11590. 

  11590. 			}

    11591. 

  11591. 			

    11592. 

  11592. 		

    11593. 

  11593. 	}

    11594. 

  11594. 			

    11595. 

  11595. 			//-------- Scenario 1773

    11596. 

  11596. 			namespace Scenario1773{

    11597. 

  11597. 				

    11598. 

  11598. 				public class Test

    11599. 

  11599. 				{

    11600. 

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

    11601. 

  11601. 			    public static Expression check57__() {

    11602. 

  11602. 			       if(Main() != 0 ) {

    11603. 

  11603. 			           throw new Exception();

    11604. 

  11604. 			       } else { 

    11605. 

  11605. 			           return Expression.Constant(0);

    11606. 

  11606. 			       }

    11607. 

  11607. 			    }

    11608. 

  11608. 				public     static int Main()

    11609. 

  11609. 				    {

    11610. 

  11610. 				        Ext.StartCapture();

    11611. 

  11611. 				        bool success = false;

    11612. 

  11612. 				        try

    11613. 

  11613. 				        {

    11614. 

  11614. 				            success = check57();

    11615. 

  11615. 				        }

    11616. 

  11616. 				        finally

    11617. 

  11617. 				        {

    11618. 

  11618. 				            Ext.StopCapture();

    11619. 

  11619. 				        }

    11620. 

  11620. 				        return success ? 0 : 1;

    11621. 

  11621. 				    }

    11622. 

  11622. 				

    11623. 

  11623. 				    static bool check57() {

    11624. 

  11624. 				        foreach (ushort[] val in new ushort[][] { null, new ushort[0], new ushort[] { 0, 1, ushort.MaxValue }, new ushort[100] }) {

    11625. 

  11625. 				            if (!check57(val)) {

    11626. 

  11626. 				                return false;

    11627. 

  11627. 				            }

    11628. 

  11628. 				        }

    11629. 

  11629. 				        return true;

    11630. 

  11630. 				    }

    11631. 

  11631. 				

    11632. 

  11632. 				    static bool check57(ushort[] val) {

    11633. 

  11633. 				        Expression<Func<ushort[]>> e =

    11634. 

  11634. 				            Expression.Lambda<Func<ushort[]>>(

    11635. 

  11635. 				                Expression.Constant(val, typeof(ushort[])),

    11636. 

  11636. 				                new System.Collections.Generic.List<ParameterExpression>());

    11637. 

  11637. 				        Func<ushort[]> f = e.Compile();

    11638. 

  11638. 				        return object.Equals(f(), val);

    11639. 

  11639. 				    }

    11640. 

  11640. 				}

    11641. 

  11641. 			

    11642. 

  11642. 			

    11643. 

  11643. 			public  static class Ext {

    11644. 

  11644. 			    public static void StartCapture() {

    11645. 

  11645. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11646. 

  11646. 			//        m.Invoke(null, new object[] { "test.dll" });

    11647. 

  11647. 			    }

    11648. 

  11648. 			

    11649. 

  11649. 			    public static void StopCapture() {

    11650. 

  11650. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11651. 

  11651. 			//        m.Invoke(null, new object[0]);

    11652. 

  11652. 			    }

    11653. 

  11653. 			

    11654. 

  11654. 			    public static bool IsIntegralOrEnum(Type type) {

    11655. 

  11655. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11656. 

  11656. 			            case TypeCode.Byte:

    11657. 

  11657. 			            case TypeCode.SByte:

    11658. 

  11658. 			            case TypeCode.Int16:

    11659. 

  11659. 			            case TypeCode.Int32:

    11660. 

  11660. 			            case TypeCode.Int64:

    11661. 

  11661. 			            case TypeCode.UInt16:

    11662. 

  11662. 			            case TypeCode.UInt32:

    11663. 

  11663. 			            case TypeCode.UInt64:

    11664. 

  11664. 			                return true;

    11665. 

  11665. 			            default:

    11666. 

  11666. 			                return false;

    11667. 

  11667. 			        }

    11668. 

  11668. 			    }

    11669. 

  11669. 			

    11670. 

  11670. 			    public static bool IsFloating(Type type) {

    11671. 

  11671. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11672. 

  11672. 			            case TypeCode.Single:

    11673. 

  11673. 			            case TypeCode.Double:

    11674. 

  11674. 			                return true;

    11675. 

  11675. 			            default:

    11676. 

  11676. 			                return false;

    11677. 

  11677. 			        }

    11678. 

  11678. 			    }

    11679. 

  11679. 			

    11680. 

  11680. 			    public static Type GetNonNullableType(Type type) {

    11681. 

  11681. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11682. 

  11682. 			                type.GetGenericArguments()[0] :

    11683. 

  11683. 			                type;

    11684. 

  11684. 			    }

    11685. 

  11685. 			}

    11686. 

  11686. 			

    11687. 

  11687. 		

    11688. 

  11688. 	}

    11689. 

  11689. 			

    11690. 

  11690. 			//-------- Scenario 1774

    11691. 

  11691. 			namespace Scenario1774{

    11692. 

  11692. 				

    11693. 

  11693. 				public class Test

    11694. 

  11694. 				{

    11695. 

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

    11696. 

  11696. 			    public static Expression check58__() {

    11697. 

  11697. 			       if(Main() != 0 ) {

    11698. 

  11698. 			           throw new Exception();

    11699. 

  11699. 			       } else { 

    11700. 

  11700. 			           return Expression.Constant(0);

    11701. 

  11701. 			       }

    11702. 

  11702. 			    }

    11703. 

  11703. 				public     static int Main()

    11704. 

  11704. 				    {

    11705. 

  11705. 				        Ext.StartCapture();

    11706. 

  11706. 				        bool success = false;

    11707. 

  11707. 				        try

    11708. 

  11708. 				        {

    11709. 

  11709. 				            success = check58();

    11710. 

  11710. 				        }

    11711. 

  11711. 				        finally

    11712. 

  11712. 				        {

    11713. 

  11713. 				            Ext.StopCapture();

    11714. 

  11714. 				        }

    11715. 

  11715. 				        return success ? 0 : 1;

    11716. 

  11716. 				    }

    11717. 

  11717. 				

    11718. 

  11718. 				    static bool check58() {

    11719. 

  11719. 				        foreach (uint[] val in new uint[][] { null, new uint[0], new uint[] { 0, 1, uint.MaxValue }, new uint[100] }) {

    11720. 

  11720. 				            if (!check58(val)) {

    11721. 

  11721. 				                return false;

    11722. 

  11722. 				            }

    11723. 

  11723. 				        }

    11724. 

  11724. 				        return true;

    11725. 

  11725. 				    }

    11726. 

  11726. 				

    11727. 

  11727. 				    static bool check58(uint[] val) {

    11728. 

  11728. 				        Expression<Func<uint[]>> e =

    11729. 

  11729. 				            Expression.Lambda<Func<uint[]>>(

    11730. 

  11730. 				                Expression.Constant(val, typeof(uint[])),

    11731. 

  11731. 				                new System.Collections.Generic.List<ParameterExpression>());

    11732. 

  11732. 				        Func<uint[]> f = e.Compile();

    11733. 

  11733. 				        return object.Equals(f(), val);

    11734. 

  11734. 				    }

    11735. 

  11735. 				}

    11736. 

  11736. 			

    11737. 

  11737. 			

    11738. 

  11738. 			public  static class Ext {

    11739. 

  11739. 			    public static void StartCapture() {

    11740. 

  11740. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11741. 

  11741. 			//        m.Invoke(null, new object[] { "test.dll" });

    11742. 

  11742. 			    }

    11743. 

  11743. 			

    11744. 

  11744. 			    public static void StopCapture() {

    11745. 

  11745. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11746. 

  11746. 			//        m.Invoke(null, new object[0]);

    11747. 

  11747. 			    }

    11748. 

  11748. 			

    11749. 

  11749. 			    public static bool IsIntegralOrEnum(Type type) {

    11750. 

  11750. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11751. 

  11751. 			            case TypeCode.Byte:

    11752. 

  11752. 			            case TypeCode.SByte:

    11753. 

  11753. 			            case TypeCode.Int16:

    11754. 

  11754. 			            case TypeCode.Int32:

    11755. 

  11755. 			            case TypeCode.Int64:

    11756. 

  11756. 			            case TypeCode.UInt16:

    11757. 

  11757. 			            case TypeCode.UInt32:

    11758. 

  11758. 			            case TypeCode.UInt64:

    11759. 

  11759. 			                return true;

    11760. 

  11760. 			            default:

    11761. 

  11761. 			                return false;

    11762. 

  11762. 			        }

    11763. 

  11763. 			    }

    11764. 

  11764. 			

    11765. 

  11765. 			    public static bool IsFloating(Type type) {

    11766. 

  11766. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11767. 

  11767. 			            case TypeCode.Single:

    11768. 

  11768. 			            case TypeCode.Double:

    11769. 

  11769. 			                return true;

    11770. 

  11770. 			            default:

    11771. 

  11771. 			                return false;

    11772. 

  11772. 			        }

    11773. 

  11773. 			    }

    11774. 

  11774. 			

    11775. 

  11775. 			    public static Type GetNonNullableType(Type type) {

    11776. 

  11776. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11777. 

  11777. 			                type.GetGenericArguments()[0] :

    11778. 

  11778. 			                type;

    11779. 

  11779. 			    }

    11780. 

  11780. 			}

    11781. 

  11781. 			

    11782. 

  11782. 		

    11783. 

  11783. 	}

    11784. 

  11784. 			

    11785. 

  11785. 			//-------- Scenario 1775

    11786. 

  11786. 			namespace Scenario1775{

    11787. 

  11787. 				

    11788. 

  11788. 				public class Test

    11789. 

  11789. 				{

    11790. 

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

    11791. 

  11791. 			    public static Expression check59__() {

    11792. 

  11792. 			       if(Main() != 0 ) {

    11793. 

  11793. 			           throw new Exception();

    11794. 

  11794. 			       } else { 

    11795. 

  11795. 			           return Expression.Constant(0);

    11796. 

  11796. 			       }

    11797. 

  11797. 			    }

    11798. 

  11798. 				public     static int Main()

    11799. 

  11799. 				    {

    11800. 

  11800. 				        Ext.StartCapture();

    11801. 

  11801. 				        bool success = false;

    11802. 

  11802. 				        try

    11803. 

  11803. 				        {

    11804. 

  11804. 				            success = check59();

    11805. 

  11805. 				        }

    11806. 

  11806. 				        finally

    11807. 

  11807. 				        {

    11808. 

  11808. 				            Ext.StopCapture();

    11809. 

  11809. 				        }

    11810. 

  11810. 				        return success ? 0 : 1;

    11811. 

  11811. 				    }

    11812. 

  11812. 				

    11813. 

  11813. 				    static bool check59() {

    11814. 

  11814. 				        foreach (ulong[] val in new ulong[][] { null, new ulong[0], new ulong[] { 0, 1, ulong.MaxValue }, new ulong[100] }) {

    11815. 

  11815. 				            if (!check59(val)) {

    11816. 

  11816. 				                return false;

    11817. 

  11817. 				            }

    11818. 

  11818. 				        }

    11819. 

  11819. 				        return true;

    11820. 

  11820. 				    }

    11821. 

  11821. 				

    11822. 

  11822. 				    static bool check59(ulong[] val) {

    11823. 

  11823. 				        Expression<Func<ulong[]>> e =

    11824. 

  11824. 				            Expression.Lambda<Func<ulong[]>>(

    11825. 

  11825. 				                Expression.Constant(val, typeof(ulong[])),

    11826. 

  11826. 				                new System.Collections.Generic.List<ParameterExpression>());

    11827. 

  11827. 				        Func<ulong[]> f = e.Compile();

    11828. 

  11828. 				        return object.Equals(f(), val);

    11829. 

  11829. 				    }

    11830. 

  11830. 				}

    11831. 

  11831. 			

    11832. 

  11832. 			

    11833. 

  11833. 			public  static class Ext {

    11834. 

  11834. 			    public static void StartCapture() {

    11835. 

  11835. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11836. 

  11836. 			//        m.Invoke(null, new object[] { "test.dll" });

    11837. 

  11837. 			    }

    11838. 

  11838. 			

    11839. 

  11839. 			    public static void StopCapture() {

    11840. 

  11840. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11841. 

  11841. 			//        m.Invoke(null, new object[0]);

    11842. 

  11842. 			    }

    11843. 

  11843. 			

    11844. 

  11844. 			    public static bool IsIntegralOrEnum(Type type) {

    11845. 

  11845. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11846. 

  11846. 			            case TypeCode.Byte:

    11847. 

  11847. 			            case TypeCode.SByte:

    11848. 

  11848. 			            case TypeCode.Int16:

    11849. 

  11849. 			            case TypeCode.Int32:

    11850. 

  11850. 			            case TypeCode.Int64:

    11851. 

  11851. 			            case TypeCode.UInt16:

    11852. 

  11852. 			            case TypeCode.UInt32:

    11853. 

  11853. 			            case TypeCode.UInt64:

    11854. 

  11854. 			                return true;

    11855. 

  11855. 			            default:

    11856. 

  11856. 			                return false;

    11857. 

  11857. 			        }

    11858. 

  11858. 			    }

    11859. 

  11859. 			

    11860. 

  11860. 			    public static bool IsFloating(Type type) {

    11861. 

  11861. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11862. 

  11862. 			            case TypeCode.Single:

    11863. 

  11863. 			            case TypeCode.Double:

    11864. 

  11864. 			                return true;

    11865. 

  11865. 			            default:

    11866. 

  11866. 			                return false;

    11867. 

  11867. 			        }

    11868. 

  11868. 			    }

    11869. 

  11869. 			

    11870. 

  11870. 			    public static Type GetNonNullableType(Type type) {

    11871. 

  11871. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11872. 

  11872. 			                type.GetGenericArguments()[0] :

    11873. 

  11873. 			                type;

    11874. 

  11874. 			    }

    11875. 

  11875. 			}

    11876. 

  11876. 			

    11877. 

  11877. 		

    11878. 

  11878. 	}

    11879. 

  11879. 			

    11880. 

  11880. 			//-------- Scenario 1776

    11881. 

  11881. 			namespace Scenario1776{

    11882. 

  11882. 				

    11883. 

  11883. 				public class Test

    11884. 

  11884. 				{

    11885. 

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

    11886. 

  11886. 			    public static Expression check60__() {

    11887. 

  11887. 			       if(Main() != 0 ) {

    11888. 

  11888. 			           throw new Exception();

    11889. 

  11889. 			       } else { 

    11890. 

  11890. 			           return Expression.Constant(0);

    11891. 

  11891. 			       }

    11892. 

  11892. 			    }

    11893. 

  11893. 				public     static int Main()

    11894. 

  11894. 				    {

    11895. 

  11895. 				        Ext.StartCapture();

    11896. 

  11896. 				        bool success = false;

    11897. 

  11897. 				        try

    11898. 

  11898. 				        {

    11899. 

  11899. 				            success = check60();

    11900. 

  11900. 				        }

    11901. 

  11901. 				        finally

    11902. 

  11902. 				        {

    11903. 

  11903. 				            Ext.StopCapture();

    11904. 

  11904. 				        }

    11905. 

  11905. 				        return success ? 0 : 1;

    11906. 

  11906. 				    }

    11907. 

  11907. 				

    11908. 

  11908. 				    static bool check60() {

    11909. 

  11909. 				        foreach (sbyte[] val in new sbyte[][] { null, new sbyte[0], new sbyte[] { 0, 1, -1, sbyte.MinValue, sbyte.MaxValue }, new sbyte[100] }) {

    11910. 

  11910. 				            if (!check60(val)) {

    11911. 

  11911. 				                return false;

    11912. 

  11912. 				            }

    11913. 

  11913. 				        }

    11914. 

  11914. 				        return true;

    11915. 

  11915. 				    }

    11916. 

  11916. 				

    11917. 

  11917. 				    static bool check60(sbyte[] val) {

    11918. 

  11918. 				        Expression<Func<sbyte[]>> e =

    11919. 

  11919. 				            Expression.Lambda<Func<sbyte[]>>(

    11920. 

  11920. 				                Expression.Constant(val, typeof(sbyte[])),

    11921. 

  11921. 				                new System.Collections.Generic.List<ParameterExpression>());

    11922. 

  11922. 				        Func<sbyte[]> f = e.Compile();

    11923. 

  11923. 				        return object.Equals(f(), val);

    11924. 

  11924. 				    }

    11925. 

  11925. 				}

    11926. 

  11926. 			

    11927. 

  11927. 			

    11928. 

  11928. 			public  static class Ext {

    11929. 

  11929. 			    public static void StartCapture() {

    11930. 

  11930. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11931. 

  11931. 			//        m.Invoke(null, new object[] { "test.dll" });

    11932. 

  11932. 			    }

    11933. 

  11933. 			

    11934. 

  11934. 			    public static void StopCapture() {

    11935. 

  11935. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    11936. 

  11936. 			//        m.Invoke(null, new object[0]);

    11937. 

  11937. 			    }

    11938. 

  11938. 			

    11939. 

  11939. 			    public static bool IsIntegralOrEnum(Type type) {

    11940. 

  11940. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11941. 

  11941. 			            case TypeCode.Byte:

    11942. 

  11942. 			            case TypeCode.SByte:

    11943. 

  11943. 			            case TypeCode.Int16:

    11944. 

  11944. 			            case TypeCode.Int32:

    11945. 

  11945. 			            case TypeCode.Int64:

    11946. 

  11946. 			            case TypeCode.UInt16:

    11947. 

  11947. 			            case TypeCode.UInt32:

    11948. 

  11948. 			            case TypeCode.UInt64:

    11949. 

  11949. 			                return true;

    11950. 

  11950. 			            default:

    11951. 

  11951. 			                return false;

    11952. 

  11952. 			        }

    11953. 

  11953. 			    }

    11954. 

  11954. 			

    11955. 

  11955. 			    public static bool IsFloating(Type type) {

    11956. 

  11956. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    11957. 

  11957. 			            case TypeCode.Single:

    11958. 

  11958. 			            case TypeCode.Double:

    11959. 

  11959. 			                return true;

    11960. 

  11960. 			            default:

    11961. 

  11961. 			                return false;

    11962. 

  11962. 			        }

    11963. 

  11963. 			    }

    11964. 

  11964. 			

    11965. 

  11965. 			    public static Type GetNonNullableType(Type type) {

    11966. 

  11966. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    11967. 

  11967. 			                type.GetGenericArguments()[0] :

    11968. 

  11968. 			                type;

    11969. 

  11969. 			    }

    11970. 

  11970. 			}

    11971. 

  11971. 			

    11972. 

  11972. 		

    11973. 

  11973. 	}

    11974. 

  11974. 			

    11975. 

  11975. 			//-------- Scenario 1777

    11976. 

  11976. 			namespace Scenario1777{

    11977. 

  11977. 				

    11978. 

  11978. 				public class Test

    11979. 

  11979. 				{

    11980. 

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

    11981. 

  11981. 			    public static Expression check61__() {

    11982. 

  11982. 			       if(Main() != 0 ) {

    11983. 

  11983. 			           throw new Exception();

    11984. 

  11984. 			       } else { 

    11985. 

  11985. 			           return Expression.Constant(0);

    11986. 

  11986. 			       }

    11987. 

  11987. 			    }

    11988. 

  11988. 				public     static int Main()

    11989. 

  11989. 				    {

    11990. 

  11990. 				        Ext.StartCapture();

    11991. 

  11991. 				        bool success = false;

    11992. 

  11992. 				        try

    11993. 

  11993. 				        {

    11994. 

  11994. 				            success = check61();

    11995. 

  11995. 				        }

    11996. 

  11996. 				        finally

    11997. 

  11997. 				        {

    11998. 

  11998. 				            Ext.StopCapture();

    11999. 

  11999. 				        }

    12000. 

  12000. 				        return success ? 0 : 1;

    12001. 

  12001. 				    }

    12002. 

  12002. 				

    12003. 

  12003. 				    static bool check61() {

    12004. 

  12004. 				        foreach (short[] val in new short[][] { null, new short[0], new short[] { 0, 1, -1, short.MinValue, short.MaxValue }, new short[100] }) {

    12005. 

  12005. 				            if (!check61(val)) {

    12006. 

  12006. 				                return false;

    12007. 

  12007. 				            }

    12008. 

  12008. 				        }

    12009. 

  12009. 				        return true;

    12010. 

  12010. 				    }

    12011. 

  12011. 				

    12012. 

  12012. 				    static bool check61(short[] val) {

    12013. 

  12013. 				        Expression<Func<short[]>> e =

    12014. 

  12014. 				            Expression.Lambda<Func<short[]>>(

    12015. 

  12015. 				                Expression.Constant(val, typeof(short[])),

    12016. 

  12016. 				                new System.Collections.Generic.List<ParameterExpression>());

    12017. 

  12017. 				        Func<short[]> f = e.Compile();

    12018. 

  12018. 				        return object.Equals(f(), val);

    12019. 

  12019. 				    }

    12020. 

  12020. 				}

    12021. 

  12021. 			

    12022. 

  12022. 			

    12023. 

  12023. 			public  static class Ext {

    12024. 

  12024. 			    public static void StartCapture() {

    12025. 

  12025. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12026. 

  12026. 			//        m.Invoke(null, new object[] { "test.dll" });

    12027. 

  12027. 			    }

    12028. 

  12028. 			

    12029. 

  12029. 			    public static void StopCapture() {

    12030. 

  12030. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12031. 

  12031. 			//        m.Invoke(null, new object[0]);

    12032. 

  12032. 			    }

    12033. 

  12033. 			

    12034. 

  12034. 			    public static bool IsIntegralOrEnum(Type type) {

    12035. 

  12035. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12036. 

  12036. 			            case TypeCode.Byte:

    12037. 

  12037. 			            case TypeCode.SByte:

    12038. 

  12038. 			            case TypeCode.Int16:

    12039. 

  12039. 			            case TypeCode.Int32:

    12040. 

  12040. 			            case TypeCode.Int64:

    12041. 

  12041. 			            case TypeCode.UInt16:

    12042. 

  12042. 			            case TypeCode.UInt32:

    12043. 

  12043. 			            case TypeCode.UInt64:

    12044. 

  12044. 			                return true;

    12045. 

  12045. 			            default:

    12046. 

  12046. 			                return false;

    12047. 

  12047. 			        }

    12048. 

  12048. 			    }

    12049. 

  12049. 			

    12050. 

  12050. 			    public static bool IsFloating(Type type) {

    12051. 

  12051. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12052. 

  12052. 			            case TypeCode.Single:

    12053. 

  12053. 			            case TypeCode.Double:

    12054. 

  12054. 			                return true;

    12055. 

  12055. 			            default:

    12056. 

  12056. 			                return false;

    12057. 

  12057. 			        }

    12058. 

  12058. 			    }

    12059. 

  12059. 			

    12060. 

  12060. 			    public static Type GetNonNullableType(Type type) {

    12061. 

  12061. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12062. 

  12062. 			                type.GetGenericArguments()[0] :

    12063. 

  12063. 			                type;

    12064. 

  12064. 			    }

    12065. 

  12065. 			}

    12066. 

  12066. 			

    12067. 

  12067. 		

    12068. 

  12068. 	}

    12069. 

  12069. 			

    12070. 

  12070. 			//-------- Scenario 1778

    12071. 

  12071. 			namespace Scenario1778{

    12072. 

  12072. 				

    12073. 

  12073. 				public class Test

    12074. 

  12074. 				{

    12075. 

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

    12076. 

  12076. 			    public static Expression check62__() {

    12077. 

  12077. 			       if(Main() != 0 ) {

    12078. 

  12078. 			           throw new Exception();

    12079. 

  12079. 			       } else { 

    12080. 

  12080. 			           return Expression.Constant(0);

    12081. 

  12081. 			       }

    12082. 

  12082. 			    }

    12083. 

  12083. 				public     static int Main()

    12084. 

  12084. 				    {

    12085. 

  12085. 				        Ext.StartCapture();

    12086. 

  12086. 				        bool success = false;

    12087. 

  12087. 				        try

    12088. 

  12088. 				        {

    12089. 

  12089. 				            success = check62();

    12090. 

  12090. 				        }

    12091. 

  12091. 				        finally

    12092. 

  12092. 				        {

    12093. 

  12093. 				            Ext.StopCapture();

    12094. 

  12094. 				        }

    12095. 

  12095. 				        return success ? 0 : 1;

    12096. 

  12096. 				    }

    12097. 

  12097. 				

    12098. 

  12098. 				    static bool check62() {

    12099. 

  12099. 				        foreach (int[] val in new int[][] { null, new int[0], new int[] { 0, 1, -1, int.MinValue, int.MaxValue }, new int[100] }) {

    12100. 

  12100. 				            if (!check62(val)) {

    12101. 

  12101. 				                return false;

    12102. 

  12102. 				            }

    12103. 

  12103. 				        }

    12104. 

  12104. 				        return true;

    12105. 

  12105. 				    }

    12106. 

  12106. 				

    12107. 

  12107. 				    static bool check62(int[] val) {

    12108. 

  12108. 				        Expression<Func<int[]>> e =

    12109. 

  12109. 				            Expression.Lambda<Func<int[]>>(

    12110. 

  12110. 				                Expression.Constant(val, typeof(int[])),

    12111. 

  12111. 				                new System.Collections.Generic.List<ParameterExpression>());

    12112. 

  12112. 				        Func<int[]> f = e.Compile();

    12113. 

  12113. 				        return object.Equals(f(), val);

    12114. 

  12114. 				    }

    12115. 

  12115. 				}

    12116. 

  12116. 			

    12117. 

  12117. 			

    12118. 

  12118. 			public  static class Ext {

    12119. 

  12119. 			    public static void StartCapture() {

    12120. 

  12120. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12121. 

  12121. 			//        m.Invoke(null, new object[] { "test.dll" });

    12122. 

  12122. 			    }

    12123. 

  12123. 			

    12124. 

  12124. 			    public static void StopCapture() {

    12125. 

  12125. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12126. 

  12126. 			//        m.Invoke(null, new object[0]);

    12127. 

  12127. 			    }

    12128. 

  12128. 			

    12129. 

  12129. 			    public static bool IsIntegralOrEnum(Type type) {

    12130. 

  12130. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12131. 

  12131. 			            case TypeCode.Byte:

    12132. 

  12132. 			            case TypeCode.SByte:

    12133. 

  12133. 			            case TypeCode.Int16:

    12134. 

  12134. 			            case TypeCode.Int32:

    12135. 

  12135. 			            case TypeCode.Int64:

    12136. 

  12136. 			            case TypeCode.UInt16:

    12137. 

  12137. 			            case TypeCode.UInt32:

    12138. 

  12138. 			            case TypeCode.UInt64:

    12139. 

  12139. 			                return true;

    12140. 

  12140. 			            default:

    12141. 

  12141. 			                return false;

    12142. 

  12142. 			        }

    12143. 

  12143. 			    }

    12144. 

  12144. 			

    12145. 

  12145. 			    public static bool IsFloating(Type type) {

    12146. 

  12146. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12147. 

  12147. 			            case TypeCode.Single:

    12148. 

  12148. 			            case TypeCode.Double:

    12149. 

  12149. 			                return true;

    12150. 

  12150. 			            default:

    12151. 

  12151. 			                return false;

    12152. 

  12152. 			        }

    12153. 

  12153. 			    }

    12154. 

  12154. 			

    12155. 

  12155. 			    public static Type GetNonNullableType(Type type) {

    12156. 

  12156. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12157. 

  12157. 			                type.GetGenericArguments()[0] :

    12158. 

  12158. 			                type;

    12159. 

  12159. 			    }

    12160. 

  12160. 			}

    12161. 

  12161. 			

    12162. 

  12162. 		

    12163. 

  12163. 	}

    12164. 

  12164. 			

    12165. 

  12165. 			//-------- Scenario 1779

    12166. 

  12166. 			namespace Scenario1779{

    12167. 

  12167. 				

    12168. 

  12168. 				public class Test

    12169. 

  12169. 				{

    12170. 

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

    12171. 

  12171. 			    public static Expression check63__() {

    12172. 

  12172. 			       if(Main() != 0 ) {

    12173. 

  12173. 			           throw new Exception();

    12174. 

  12174. 			       } else { 

    12175. 

  12175. 			           return Expression.Constant(0);

    12176. 

  12176. 			       }

    12177. 

  12177. 			    }

    12178. 

  12178. 				public     static int Main()

    12179. 

  12179. 				    {

    12180. 

  12180. 				        Ext.StartCapture();

    12181. 

  12181. 				        bool success = false;

    12182. 

  12182. 				        try

    12183. 

  12183. 				        {

    12184. 

  12184. 				            success = check63();

    12185. 

  12185. 				        }

    12186. 

  12186. 				        finally

    12187. 

  12187. 				        {

    12188. 

  12188. 				            Ext.StopCapture();

    12189. 

  12189. 				        }

    12190. 

  12190. 				        return success ? 0 : 1;

    12191. 

  12191. 				    }

    12192. 

  12192. 				

    12193. 

  12193. 				    static bool check63() {

    12194. 

  12194. 				        foreach (long[] val in new long[][] { null, new long[0], new long[] { 0, 1, -1, long.MinValue, long.MaxValue }, new long[100] }) {

    12195. 

  12195. 				            if (!check63(val)) {

    12196. 

  12196. 				                return false;

    12197. 

  12197. 				            }

    12198. 

  12198. 				        }

    12199. 

  12199. 				        return true;

    12200. 

  12200. 				    }

    12201. 

  12201. 				

    12202. 

  12202. 				    static bool check63(long[] val) {

    12203. 

  12203. 				        Expression<Func<long[]>> e =

    12204. 

  12204. 				            Expression.Lambda<Func<long[]>>(

    12205. 

  12205. 				                Expression.Constant(val, typeof(long[])),

    12206. 

  12206. 				                new System.Collections.Generic.List<ParameterExpression>());

    12207. 

  12207. 				        Func<long[]> f = e.Compile();

    12208. 

  12208. 				        return object.Equals(f(), val);

    12209. 

  12209. 				    }

    12210. 

  12210. 				}

    12211. 

  12211. 			

    12212. 

  12212. 			

    12213. 

  12213. 			public  static class Ext {

    12214. 

  12214. 			    public static void StartCapture() {

    12215. 

  12215. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12216. 

  12216. 			//        m.Invoke(null, new object[] { "test.dll" });

    12217. 

  12217. 			    }

    12218. 

  12218. 			

    12219. 

  12219. 			    public static void StopCapture() {

    12220. 

  12220. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12221. 

  12221. 			//        m.Invoke(null, new object[0]);

    12222. 

  12222. 			    }

    12223. 

  12223. 			

    12224. 

  12224. 			    public static bool IsIntegralOrEnum(Type type) {

    12225. 

  12225. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12226. 

  12226. 			            case TypeCode.Byte:

    12227. 

  12227. 			            case TypeCode.SByte:

    12228. 

  12228. 			            case TypeCode.Int16:

    12229. 

  12229. 			            case TypeCode.Int32:

    12230. 

  12230. 			            case TypeCode.Int64:

    12231. 

  12231. 			            case TypeCode.UInt16:

    12232. 

  12232. 			            case TypeCode.UInt32:

    12233. 

  12233. 			            case TypeCode.UInt64:

    12234. 

  12234. 			                return true;

    12235. 

  12235. 			            default:

    12236. 

  12236. 			                return false;

    12237. 

  12237. 			        }

    12238. 

  12238. 			    }

    12239. 

  12239. 			

    12240. 

  12240. 			    public static bool IsFloating(Type type) {

    12241. 

  12241. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12242. 

  12242. 			            case TypeCode.Single:

    12243. 

  12243. 			            case TypeCode.Double:

    12244. 

  12244. 			                return true;

    12245. 

  12245. 			            default:

    12246. 

  12246. 			                return false;

    12247. 

  12247. 			        }

    12248. 

  12248. 			    }

    12249. 

  12249. 			

    12250. 

  12250. 			    public static Type GetNonNullableType(Type type) {

    12251. 

  12251. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12252. 

  12252. 			                type.GetGenericArguments()[0] :

    12253. 

  12253. 			                type;

    12254. 

  12254. 			    }

    12255. 

  12255. 			}

    12256. 

  12256. 			

    12257. 

  12257. 		

    12258. 

  12258. 	}

    12259. 

  12259. 			

    12260. 

  12260. 			//-------- Scenario 1780

    12261. 

  12261. 			namespace Scenario1780{

    12262. 

  12262. 				

    12263. 

  12263. 				public class Test

    12264. 

  12264. 				{

    12265. 

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

    12266. 

  12266. 			    public static Expression check64__() {

    12267. 

  12267. 			       if(Main() != 0 ) {

    12268. 

  12268. 			           throw new Exception();

    12269. 

  12269. 			       } else { 

    12270. 

  12270. 			           return Expression.Constant(0);

    12271. 

  12271. 			       }

    12272. 

  12272. 			    }

    12273. 

  12273. 				public     static int Main()

    12274. 

  12274. 				    {

    12275. 

  12275. 				        Ext.StartCapture();

    12276. 

  12276. 				        bool success = false;

    12277. 

  12277. 				        try

    12278. 

  12278. 				        {

    12279. 

  12279. 				            success = check64();

    12280. 

  12280. 				        }

    12281. 

  12281. 				        finally

    12282. 

  12282. 				        {

    12283. 

  12283. 				            Ext.StopCapture();

    12284. 

  12284. 				        }

    12285. 

  12285. 				        return success ? 0 : 1;

    12286. 

  12286. 				    }

    12287. 

  12287. 				

    12288. 

  12288. 				    static bool check64() {

    12289. 

  12289. 				        foreach (float[] val in new float[][] { null, new float[0], new float[] { 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN }, new float[100] }) {

    12290. 

  12290. 				            if (!check64(val)) {

    12291. 

  12291. 				                return false;

    12292. 

  12292. 				            }

    12293. 

  12293. 				        }

    12294. 

  12294. 				        return true;

    12295. 

  12295. 				    }

    12296. 

  12296. 				

    12297. 

  12297. 				    static bool check64(float[] val) {

    12298. 

  12298. 				        Expression<Func<float[]>> e =

    12299. 

  12299. 				            Expression.Lambda<Func<float[]>>(

    12300. 

  12300. 				                Expression.Constant(val, typeof(float[])),

    12301. 

  12301. 				                new System.Collections.Generic.List<ParameterExpression>());

    12302. 

  12302. 				        Func<float[]> f = e.Compile();

    12303. 

  12303. 				        return object.Equals(f(), val);

    12304. 

  12304. 				    }

    12305. 

  12305. 				}

    12306. 

  12306. 			

    12307. 

  12307. 			

    12308. 

  12308. 			public  static class Ext {

    12309. 

  12309. 			    public static void StartCapture() {

    12310. 

  12310. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12311. 

  12311. 			//        m.Invoke(null, new object[] { "test.dll" });

    12312. 

  12312. 			    }

    12313. 

  12313. 			

    12314. 

  12314. 			    public static void StopCapture() {

    12315. 

  12315. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12316. 

  12316. 			//        m.Invoke(null, new object[0]);

    12317. 

  12317. 			    }

    12318. 

  12318. 			

    12319. 

  12319. 			    public static bool IsIntegralOrEnum(Type type) {

    12320. 

  12320. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12321. 

  12321. 			            case TypeCode.Byte:

    12322. 

  12322. 			            case TypeCode.SByte:

    12323. 

  12323. 			            case TypeCode.Int16:

    12324. 

  12324. 			            case TypeCode.Int32:

    12325. 

  12325. 			            case TypeCode.Int64:

    12326. 

  12326. 			            case TypeCode.UInt16:

    12327. 

  12327. 			            case TypeCode.UInt32:

    12328. 

  12328. 			            case TypeCode.UInt64:

    12329. 

  12329. 			                return true;

    12330. 

  12330. 			            default:

    12331. 

  12331. 			                return false;

    12332. 

  12332. 			        }

    12333. 

  12333. 			    }

    12334. 

  12334. 			

    12335. 

  12335. 			    public static bool IsFloating(Type type) {

    12336. 

  12336. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12337. 

  12337. 			            case TypeCode.Single:

    12338. 

  12338. 			            case TypeCode.Double:

    12339. 

  12339. 			                return true;

    12340. 

  12340. 			            default:

    12341. 

  12341. 			                return false;

    12342. 

  12342. 			        }

    12343. 

  12343. 			    }

    12344. 

  12344. 			

    12345. 

  12345. 			    public static Type GetNonNullableType(Type type) {

    12346. 

  12346. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12347. 

  12347. 			                type.GetGenericArguments()[0] :

    12348. 

  12348. 			                type;

    12349. 

  12349. 			    }

    12350. 

  12350. 			}

    12351. 

  12351. 			

    12352. 

  12352. 		

    12353. 

  12353. 	}

    12354. 

  12354. 			

    12355. 

  12355. 			//-------- Scenario 1781

    12356. 

  12356. 			namespace Scenario1781{

    12357. 

  12357. 				

    12358. 

  12358. 				public class Test

    12359. 

  12359. 				{

    12360. 

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

    12361. 

  12361. 			    public static Expression check65__() {

    12362. 

  12362. 			       if(Main() != 0 ) {

    12363. 

  12363. 			           throw new Exception();

    12364. 

  12364. 			       } else { 

    12365. 

  12365. 			           return Expression.Constant(0);

    12366. 

  12366. 			       }

    12367. 

  12367. 			    }

    12368. 

  12368. 				public     static int Main()

    12369. 

  12369. 				    {

    12370. 

  12370. 				        Ext.StartCapture();

    12371. 

  12371. 				        bool success = false;

    12372. 

  12372. 				        try

    12373. 

  12373. 				        {

    12374. 

  12374. 				            success = check65();

    12375. 

  12375. 				        }

    12376. 

  12376. 				        finally

    12377. 

  12377. 				        {

    12378. 

  12378. 				            Ext.StopCapture();

    12379. 

  12379. 				        }

    12380. 

  12380. 				        return success ? 0 : 1;

    12381. 

  12381. 				    }

    12382. 

  12382. 				

    12383. 

  12383. 				    static bool check65() {

    12384. 

  12384. 				        foreach (double[] val in new double[][] { null, new double[0], new double[] { 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN }, new double[100] }) {

    12385. 

  12385. 				            if (!check65(val)) {

    12386. 

  12386. 				                return false;

    12387. 

  12387. 				            }

    12388. 

  12388. 				        }

    12389. 

  12389. 				        return true;

    12390. 

  12390. 				    }

    12391. 

  12391. 				

    12392. 

  12392. 				    static bool check65(double[] val) {

    12393. 

  12393. 				        Expression<Func<double[]>> e =

    12394. 

  12394. 				            Expression.Lambda<Func<double[]>>(

    12395. 

  12395. 				                Expression.Constant(val, typeof(double[])),

    12396. 

  12396. 				                new System.Collections.Generic.List<ParameterExpression>());

    12397. 

  12397. 				        Func<double[]> f = e.Compile();

    12398. 

  12398. 				        return object.Equals(f(), val);

    12399. 

  12399. 				    }

    12400. 

  12400. 				}

    12401. 

  12401. 			

    12402. 

  12402. 			

    12403. 

  12403. 			public  static class Ext {

    12404. 

  12404. 			    public static void StartCapture() {

    12405. 

  12405. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12406. 

  12406. 			//        m.Invoke(null, new object[] { "test.dll" });

    12407. 

  12407. 			    }

    12408. 

  12408. 			

    12409. 

  12409. 			    public static void StopCapture() {

    12410. 

  12410. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12411. 

  12411. 			//        m.Invoke(null, new object[0]);

    12412. 

  12412. 			    }

    12413. 

  12413. 			

    12414. 

  12414. 			    public static bool IsIntegralOrEnum(Type type) {

    12415. 

  12415. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12416. 

  12416. 			            case TypeCode.Byte:

    12417. 

  12417. 			            case TypeCode.SByte:

    12418. 

  12418. 			            case TypeCode.Int16:

    12419. 

  12419. 			            case TypeCode.Int32:

    12420. 

  12420. 			            case TypeCode.Int64:

    12421. 

  12421. 			            case TypeCode.UInt16:

    12422. 

  12422. 			            case TypeCode.UInt32:

    12423. 

  12423. 			            case TypeCode.UInt64:

    12424. 

  12424. 			                return true;

    12425. 

  12425. 			            default:

    12426. 

  12426. 			                return false;

    12427. 

  12427. 			        }

    12428. 

  12428. 			    }

    12429. 

  12429. 			

    12430. 

  12430. 			    public static bool IsFloating(Type type) {

    12431. 

  12431. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12432. 

  12432. 			            case TypeCode.Single:

    12433. 

  12433. 			            case TypeCode.Double:

    12434. 

  12434. 			                return true;

    12435. 

  12435. 			            default:

    12436. 

  12436. 			                return false;

    12437. 

  12437. 			        }

    12438. 

  12438. 			    }

    12439. 

  12439. 			

    12440. 

  12440. 			    public static Type GetNonNullableType(Type type) {

    12441. 

  12441. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12442. 

  12442. 			                type.GetGenericArguments()[0] :

    12443. 

  12443. 			                type;

    12444. 

  12444. 			    }

    12445. 

  12445. 			}

    12446. 

  12446. 			

    12447. 

  12447. 		

    12448. 

  12448. 	}

    12449. 

  12449. 			

    12450. 

  12450. 			//-------- Scenario 1782

    12451. 

  12451. 			namespace Scenario1782{

    12452. 

  12452. 				

    12453. 

  12453. 				public class Test

    12454. 

  12454. 				{

    12455. 

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

    12456. 

  12456. 			    public static Expression check66__() {

    12457. 

  12457. 			       if(Main() != 0 ) {

    12458. 

  12458. 			           throw new Exception();

    12459. 

  12459. 			       } else { 

    12460. 

  12460. 			           return Expression.Constant(0);

    12461. 

  12461. 			       }

    12462. 

  12462. 			    }

    12463. 

  12463. 				public     static int Main()

    12464. 

  12464. 				    {

    12465. 

  12465. 				        Ext.StartCapture();

    12466. 

  12466. 				        bool success = false;

    12467. 

  12467. 				        try

    12468. 

  12468. 				        {

    12469. 

  12469. 				            success = check66();

    12470. 

  12470. 				        }

    12471. 

  12471. 				        finally

    12472. 

  12472. 				        {

    12473. 

  12473. 				            Ext.StopCapture();

    12474. 

  12474. 				        }

    12475. 

  12475. 				        return success ? 0 : 1;

    12476. 

  12476. 				    }

    12477. 

  12477. 				

    12478. 

  12478. 				    static bool check66() {

    12479. 

  12479. 				        foreach (decimal[] val in new decimal[][] { null, new decimal[0], new decimal[] { decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue }, new decimal[100] }) {

    12480. 

  12480. 				            if (!check66(val)) {

    12481. 

  12481. 				                return false;

    12482. 

  12482. 				            }

    12483. 

  12483. 				        }

    12484. 

  12484. 				        return true;

    12485. 

  12485. 				    }

    12486. 

  12486. 				

    12487. 

  12487. 				    static bool check66(decimal[] val) {

    12488. 

  12488. 				        Expression<Func<decimal[]>> e =

    12489. 

  12489. 				            Expression.Lambda<Func<decimal[]>>(

    12490. 

  12490. 				                Expression.Constant(val, typeof(decimal[])),

    12491. 

  12491. 				                new System.Collections.Generic.List<ParameterExpression>());

    12492. 

  12492. 				        Func<decimal[]> f = e.Compile();

    12493. 

  12493. 				        return object.Equals(f(), val);

    12494. 

  12494. 				    }

    12495. 

  12495. 				}

    12496. 

  12496. 			

    12497. 

  12497. 			

    12498. 

  12498. 			public  static class Ext {

    12499. 

  12499. 			    public static void StartCapture() {

    12500. 

  12500. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12501. 

  12501. 			//        m.Invoke(null, new object[] { "test.dll" });

    12502. 

  12502. 			    }

    12503. 

  12503. 			

    12504. 

  12504. 			    public static void StopCapture() {

    12505. 

  12505. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12506. 

  12506. 			//        m.Invoke(null, new object[0]);

    12507. 

  12507. 			    }

    12508. 

  12508. 			

    12509. 

  12509. 			    public static bool IsIntegralOrEnum(Type type) {

    12510. 

  12510. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12511. 

  12511. 			            case TypeCode.Byte:

    12512. 

  12512. 			            case TypeCode.SByte:

    12513. 

  12513. 			            case TypeCode.Int16:

    12514. 

  12514. 			            case TypeCode.Int32:

    12515. 

  12515. 			            case TypeCode.Int64:

    12516. 

  12516. 			            case TypeCode.UInt16:

    12517. 

  12517. 			            case TypeCode.UInt32:

    12518. 

  12518. 			            case TypeCode.UInt64:

    12519. 

  12519. 			                return true;

    12520. 

  12520. 			            default:

    12521. 

  12521. 			                return false;

    12522. 

  12522. 			        }

    12523. 

  12523. 			    }

    12524. 

  12524. 			

    12525. 

  12525. 			    public static bool IsFloating(Type type) {

    12526. 

  12526. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12527. 

  12527. 			            case TypeCode.Single:

    12528. 

  12528. 			            case TypeCode.Double:

    12529. 

  12529. 			                return true;

    12530. 

  12530. 			            default:

    12531. 

  12531. 			                return false;

    12532. 

  12532. 			        }

    12533. 

  12533. 			    }

    12534. 

  12534. 			

    12535. 

  12535. 			    public static Type GetNonNullableType(Type type) {

    12536. 

  12536. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12537. 

  12537. 			                type.GetGenericArguments()[0] :

    12538. 

  12538. 			                type;

    12539. 

  12539. 			    }

    12540. 

  12540. 			}

    12541. 

  12541. 			

    12542. 

  12542. 		

    12543. 

  12543. 	}

    12544. 

  12544. 			

    12545. 

  12545. 			//-------- Scenario 1783

    12546. 

  12546. 			namespace Scenario1783{

    12547. 

  12547. 				

    12548. 

  12548. 				public class Test

    12549. 

  12549. 				{

    12550. 

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

    12551. 

  12551. 			    public static Expression check67__() {

    12552. 

  12552. 			       if(Main() != 0 ) {

    12553. 

  12553. 			           throw new Exception();

    12554. 

  12554. 			       } else { 

    12555. 

  12555. 			           return Expression.Constant(0);

    12556. 

  12556. 			       }

    12557. 

  12557. 			    }

    12558. 

  12558. 				public     static int Main()

    12559. 

  12559. 				    {

    12560. 

  12560. 				        Ext.StartCapture();

    12561. 

  12561. 				        bool success = false;

    12562. 

  12562. 				        try

    12563. 

  12563. 				        {

    12564. 

  12564. 				            success = check67();

    12565. 

  12565. 				        }

    12566. 

  12566. 				        finally

    12567. 

  12567. 				        {

    12568. 

  12568. 				            Ext.StopCapture();

    12569. 

  12569. 				        }

    12570. 

  12570. 				        return success ? 0 : 1;

    12571. 

  12571. 				    }

    12572. 

  12572. 				

    12573. 

  12573. 				    static bool check67() {

    12574. 

  12574. 				        foreach (char[] val in new char[][] { null, new char[0], new char[] { '\0', '\b', 'A', '\uffff' }, new char[100] }) {

    12575. 

  12575. 				            if (!check67(val)) {

    12576. 

  12576. 				                return false;

    12577. 

  12577. 				            }

    12578. 

  12578. 				        }

    12579. 

  12579. 				        return true;

    12580. 

  12580. 				    }

    12581. 

  12581. 				

    12582. 

  12582. 				    static bool check67(char[] val) {

    12583. 

  12583. 				        Expression<Func<char[]>> e =

    12584. 

  12584. 				            Expression.Lambda<Func<char[]>>(

    12585. 

  12585. 				                Expression.Constant(val, typeof(char[])),

    12586. 

  12586. 				                new System.Collections.Generic.List<ParameterExpression>());

    12587. 

  12587. 				        Func<char[]> f = e.Compile();

    12588. 

  12588. 				        return object.Equals(f(), val);

    12589. 

  12589. 				    }

    12590. 

  12590. 				}

    12591. 

  12591. 			

    12592. 

  12592. 			

    12593. 

  12593. 			public  static class Ext {

    12594. 

  12594. 			    public static void StartCapture() {

    12595. 

  12595. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12596. 

  12596. 			//        m.Invoke(null, new object[] { "test.dll" });

    12597. 

  12597. 			    }

    12598. 

  12598. 			

    12599. 

  12599. 			    public static void StopCapture() {

    12600. 

  12600. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12601. 

  12601. 			//        m.Invoke(null, new object[0]);

    12602. 

  12602. 			    }

    12603. 

  12603. 			

    12604. 

  12604. 			    public static bool IsIntegralOrEnum(Type type) {

    12605. 

  12605. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12606. 

  12606. 			            case TypeCode.Byte:

    12607. 

  12607. 			            case TypeCode.SByte:

    12608. 

  12608. 			            case TypeCode.Int16:

    12609. 

  12609. 			            case TypeCode.Int32:

    12610. 

  12610. 			            case TypeCode.Int64:

    12611. 

  12611. 			            case TypeCode.UInt16:

    12612. 

  12612. 			            case TypeCode.UInt32:

    12613. 

  12613. 			            case TypeCode.UInt64:

    12614. 

  12614. 			                return true;

    12615. 

  12615. 			            default:

    12616. 

  12616. 			                return false;

    12617. 

  12617. 			        }

    12618. 

  12618. 			    }

    12619. 

  12619. 			

    12620. 

  12620. 			    public static bool IsFloating(Type type) {

    12621. 

  12621. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12622. 

  12622. 			            case TypeCode.Single:

    12623. 

  12623. 			            case TypeCode.Double:

    12624. 

  12624. 			                return true;

    12625. 

  12625. 			            default:

    12626. 

  12626. 			                return false;

    12627. 

  12627. 			        }

    12628. 

  12628. 			    }

    12629. 

  12629. 			

    12630. 

  12630. 			    public static Type GetNonNullableType(Type type) {

    12631. 

  12631. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12632. 

  12632. 			                type.GetGenericArguments()[0] :

    12633. 

  12633. 			                type;

    12634. 

  12634. 			    }

    12635. 

  12635. 			}

    12636. 

  12636. 			

    12637. 

  12637. 		

    12638. 

  12638. 	}

    12639. 

  12639. 			

    12640. 

  12640. 			//-------- Scenario 1784

    12641. 

  12641. 			namespace Scenario1784{

    12642. 

  12642. 				

    12643. 

  12643. 				public class Test

    12644. 

  12644. 				{

    12645. 

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

    12646. 

  12646. 			    public static Expression check68__() {

    12647. 

  12647. 			       if(Main() != 0 ) {

    12648. 

  12648. 			           throw new Exception();

    12649. 

  12649. 			       } else { 

    12650. 

  12650. 			           return Expression.Constant(0);

    12651. 

  12651. 			       }

    12652. 

  12652. 			    }

    12653. 

  12653. 				public     static int Main()

    12654. 

  12654. 				    {

    12655. 

  12655. 				        Ext.StartCapture();

    12656. 

  12656. 				        bool success = false;

    12657. 

  12657. 				        try

    12658. 

  12658. 				        {

    12659. 

  12659. 				            success = check68();

    12660. 

  12660. 				        }

    12661. 

  12661. 				        finally

    12662. 

  12662. 				        {

    12663. 

  12663. 				            Ext.StopCapture();

    12664. 

  12664. 				        }

    12665. 

  12665. 				        return success ? 0 : 1;

    12666. 

  12666. 				    }

    12667. 

  12667. 				

    12668. 

  12668. 				    static bool check68() {

    12669. 

  12669. 				        foreach (bool[] val in new bool[][] { null, new bool[0], new bool[] { true, false }, new bool[100] }) {

    12670. 

  12670. 				            if (!check68(val)) {

    12671. 

  12671. 				                return false;

    12672. 

  12672. 				            }

    12673. 

  12673. 				        }

    12674. 

  12674. 				        return true;

    12675. 

  12675. 				    }

    12676. 

  12676. 				

    12677. 

  12677. 				    static bool check68(bool[] val) {

    12678. 

  12678. 				        Expression<Func<bool[]>> e =

    12679. 

  12679. 				            Expression.Lambda<Func<bool[]>>(

    12680. 

  12680. 				                Expression.Constant(val, typeof(bool[])),

    12681. 

  12681. 				                new System.Collections.Generic.List<ParameterExpression>());

    12682. 

  12682. 				        Func<bool[]> f = e.Compile();

    12683. 

  12683. 				        return object.Equals(f(), val);

    12684. 

  12684. 				    }

    12685. 

  12685. 				}

    12686. 

  12686. 			

    12687. 

  12687. 			

    12688. 

  12688. 			public  static class Ext {

    12689. 

  12689. 			    public static void StartCapture() {

    12690. 

  12690. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12691. 

  12691. 			//        m.Invoke(null, new object[] { "test.dll" });

    12692. 

  12692. 			    }

    12693. 

  12693. 			

    12694. 

  12694. 			    public static void StopCapture() {

    12695. 

  12695. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12696. 

  12696. 			//        m.Invoke(null, new object[0]);

    12697. 

  12697. 			    }

    12698. 

  12698. 			

    12699. 

  12699. 			    public static bool IsIntegralOrEnum(Type type) {

    12700. 

  12700. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12701. 

  12701. 			            case TypeCode.Byte:

    12702. 

  12702. 			            case TypeCode.SByte:

    12703. 

  12703. 			            case TypeCode.Int16:

    12704. 

  12704. 			            case TypeCode.Int32:

    12705. 

  12705. 			            case TypeCode.Int64:

    12706. 

  12706. 			            case TypeCode.UInt16:

    12707. 

  12707. 			            case TypeCode.UInt32:

    12708. 

  12708. 			            case TypeCode.UInt64:

    12709. 

  12709. 			                return true;

    12710. 

  12710. 			            default:

    12711. 

  12711. 			                return false;

    12712. 

  12712. 			        }

    12713. 

  12713. 			    }

    12714. 

  12714. 			

    12715. 

  12715. 			    public static bool IsFloating(Type type) {

    12716. 

  12716. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12717. 

  12717. 			            case TypeCode.Single:

    12718. 

  12718. 			            case TypeCode.Double:

    12719. 

  12719. 			                return true;

    12720. 

  12720. 			            default:

    12721. 

  12721. 			                return false;

    12722. 

  12722. 			        }

    12723. 

  12723. 			    }

    12724. 

  12724. 			

    12725. 

  12725. 			    public static Type GetNonNullableType(Type type) {

    12726. 

  12726. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12727. 

  12727. 			                type.GetGenericArguments()[0] :

    12728. 

  12728. 			                type;

    12729. 

  12729. 			    }

    12730. 

  12730. 			}

    12731. 

  12731. 			

    12732. 

  12732. 		

    12733. 

  12733. 	}

    12734. 

  12734. 				

    12735. 

  12735. 				//-------- Scenario 1785

    12736. 

  12736. 				namespace Scenario1785{

    12737. 

  12737. 					

    12738. 

  12738. 					public class Test

    12739. 

  12739. 					{

    12740. 

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

    12741. 

  12741. 				    public static Expression check69__() {

    12742. 

  12742. 				       if(Main() != 0 ) {

    12743. 

  12743. 				           throw new Exception();

    12744. 

  12744. 				       } else { 

    12745. 

  12745. 				           return Expression.Constant(0);

    12746. 

  12746. 				       }

    12747. 

  12747. 				    }

    12748. 

  12748. 					public     static int Main()

    12749. 

  12749. 					    {

    12750. 

  12750. 					        Ext.StartCapture();

    12751. 

  12751. 					        bool success = false;

    12752. 

  12752. 					        try

    12753. 

  12753. 					        {

    12754. 

  12754. 					            success = check69();

    12755. 

  12755. 					        }

    12756. 

  12756. 					        finally

    12757. 

  12757. 					        {

    12758. 

  12758. 					            Ext.StopCapture();

    12759. 

  12759. 					        }

    12760. 

  12760. 					        return success ? 0 : 1;

    12761. 

  12761. 					    }

    12762. 

  12762. 					

    12763. 

  12763. 					    static bool check69() {

    12764. 

  12764. 					        foreach (S[] val in new S[][] { null, new S[0], new S[] { default(S), new S() }, new S[100] }) {

    12765. 

  12765. 					            if (!check69(val)) {

    12766. 

  12766. 					                return false;

    12767. 

  12767. 					            }

    12768. 

  12768. 					        }

    12769. 

  12769. 					        return true;

    12770. 

  12770. 					    }

    12771. 

  12771. 					

    12772. 

  12772. 					    static bool check69(S[] val) {

    12773. 

  12773. 					        Expression<Func<S[]>> e =

    12774. 

  12774. 					            Expression.Lambda<Func<S[]>>(

    12775. 

  12775. 					                Expression.Constant(val, typeof(S[])),

    12776. 

  12776. 					                new System.Collections.Generic.List<ParameterExpression>());

    12777. 

  12777. 					        Func<S[]> f = e.Compile();

    12778. 

  12778. 					        return object.Equals(f(), val);

    12779. 

  12779. 					    }

    12780. 

  12780. 					}

    12781. 

  12781. 				

    12782. 

  12782. 				

    12783. 

  12783. 				public  static class Ext {

    12784. 

  12784. 				    public static void StartCapture() {

    12785. 

  12785. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12786. 

  12786. 				//        m.Invoke(null, new object[] { "test.dll" });

    12787. 

  12787. 				    }

    12788. 

  12788. 				

    12789. 

  12789. 				    public static void StopCapture() {

    12790. 

  12790. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    12791. 

  12791. 				//        m.Invoke(null, new object[0]);

    12792. 

  12792. 				    }

    12793. 

  12793. 				

    12794. 

  12794. 				    public static bool IsIntegralOrEnum(Type type) {

    12795. 

  12795. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12796. 

  12796. 				            case TypeCode.Byte:

    12797. 

  12797. 				            case TypeCode.SByte:

    12798. 

  12798. 				            case TypeCode.Int16:

    12799. 

  12799. 				            case TypeCode.Int32:

    12800. 

  12800. 				            case TypeCode.Int64:

    12801. 

  12801. 				            case TypeCode.UInt16:

    12802. 

  12802. 				            case TypeCode.UInt32:

    12803. 

  12803. 				            case TypeCode.UInt64:

    12804. 

  12804. 				                return true;

    12805. 

  12805. 				            default:

    12806. 

  12806. 				                return false;

    12807. 

  12807. 				        }

    12808. 

  12808. 				    }

    12809. 

  12809. 				

    12810. 

  12810. 				    public static bool IsFloating(Type type) {

    12811. 

  12811. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    12812. 

  12812. 				            case TypeCode.Single:

    12813. 

  12813. 				            case TypeCode.Double:

    12814. 

  12814. 				                return true;

    12815. 

  12815. 				            default:

    12816. 

  12816. 				                return false;

    12817. 

  12817. 				        }

    12818. 

  12818. 				    }

    12819. 

  12819. 				

    12820. 

  12820. 				    public static Type GetNonNullableType(Type type) {

    12821. 

  12821. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    12822. 

  12822. 				                type.GetGenericArguments()[0] :

    12823. 

  12823. 				                type;

    12824. 

  12824. 				    }

    12825. 

  12825. 				}

    12826. 

  12826. 				

    12827. 

  12827. 			

    12828. 

  12828. 			

    12829. 

  12829. 			

    12830. 

  12830. 			public interface I {

    12831. 

  12831. 			  void M();

    12832. 

  12832. 			}

    12833. 

  12833. 			

    12834. 

  12834. 			public  class C : IEquatable<C>, I {

    12835. 

  12835. 			    void I.M() {

    12836. 

  12836. 			    }

    12837. 

  12837. 			

    12838. 

  12838. 			    public override bool Equals(object o) {

    12839. 

  12839. 			        return o is C && Equals((C) o);

    12840. 

  12840. 			    }

    12841. 

  12841. 			

    12842. 

  12842. 			    public bool Equals(C c) {

    12843. 

  12843. 			        return c != null;

    12844. 

  12844. 			    }

    12845. 

  12845. 			

    12846. 

  12846. 			    public override int GetHashCode() {

    12847. 

  12847. 			        return 0;

    12848. 

  12848. 			    }

    12849. 

  12849. 			}

    12850. 

  12850. 			

    12851. 

  12851. 			public  class D : C, IEquatable<D> {

    12852. 

  12852. 			    public int Val;

    12853. 

  12853. 			    public D() {

    12854. 

  12854. 			    }

    12855. 

  12855. 			    public D(int val) {

    12856. 

  12856. 			        Val = val;

    12857. 

  12857. 			    }

    12858. 

  12858. 			

    12859. 

  12859. 			    public override bool Equals(object o) {

    12860. 

  12860. 			        return o is D && Equals((D) o);

    12861. 

  12861. 			    }

    12862. 

  12862. 			

    12863. 

  12863. 			    public bool Equals(D d) {

    12864. 

  12864. 			        return d != null && d.Val == Val;

    12865. 

  12865. 			    }

    12866. 

  12866. 			

    12867. 

  12867. 			    public override int GetHashCode() {

    12868. 

  12868. 			        return Val;

    12869. 

  12869. 			    }

    12870. 

  12870. 			}

    12871. 

  12871. 			

    12872. 

  12872. 			public enum E {

    12873. 

  12873. 			  A=1, B=2

    12874. 

  12874. 			}

    12875. 

  12875. 			

    12876. 

  12876. 			public enum El : long {

    12877. 

  12877. 			  A, B, C

    12878. 

  12878. 			}

    12879. 

  12879. 			

    12880. 

  12880. 			public struct S : IEquatable<S> {

    12881. 

  12881. 			    public override bool Equals(object o) {

    12882. 

  12882. 			        return (o is S) && Equals((S) o);

    12883. 

  12883. 			    }

    12884. 

  12884. 			    public bool Equals(S other) {

    12885. 

  12885. 			        return true;

    12886. 

  12886. 			    }

    12887. 

  12887. 			    public override int GetHashCode() {

    12888. 

  12888. 			        return 0;

    12889. 

  12889. 			    }

    12890. 

  12890. 			}

    12891. 

  12891. 			

    12892. 

  12892. 			public struct Sp : IEquatable<Sp> {

    12893. 

  12893. 			    public Sp(int i, double d) {

    12894. 

  12894. 			        I = i;

    12895. 

  12895. 			        D = d;

    12896. 

  12896. 			    }

    12897. 

  12897. 			

    12898. 

  12898. 			    public int I;

    12899. 

  12899. 			    public double D;

    12900. 

  12900. 			

    12901. 

  12901. 			    public override bool Equals(object o) {

    12902. 

  12902. 			        return (o is Sp) && Equals((Sp) o);

    12903. 

  12903. 			    }

    12904. 

  12904. 			    public bool Equals(Sp other) {

    12905. 

  12905. 			        return other.I == I && other.D == D;

    12906. 

  12906. 			    }

    12907. 

  12907. 			    public override int GetHashCode() {

    12908. 

  12908. 			        return I.GetHashCode() ^ D.GetHashCode();

    12909. 

  12909. 			    }

    12910. 

  12910. 			}

    12911. 

  12911. 			

    12912. 

  12912. 			public struct Ss : IEquatable<Ss> {

    12913. 

  12913. 			    public Ss(S s) {

    12914. 

  12914. 			        Val = s;

    12915. 

  12915. 			    }

    12916. 

  12916. 			

    12917. 

  12917. 			    public S Val;

    12918. 

  12918. 			

    12919. 

  12919. 			    public override bool Equals(object o) {

    12920. 

  12920. 			        return (o is Ss) && Equals((Ss) o);

    12921. 

  12921. 			    }

    12922. 

  12922. 			    public bool Equals(Ss other) {

    12923. 

  12923. 			        return other.Val.Equals(Val);

    12924. 

  12924. 			    }

    12925. 

  12925. 			    public override int GetHashCode() {

    12926. 

  12926. 			        return Val.GetHashCode();

    12927. 

  12927. 			    }

    12928. 

  12928. 			}

    12929. 

  12929. 			

    12930. 

  12930. 			public struct Sc : IEquatable<Sc> {

    12931. 

  12931. 			    public Sc(string s) {

    12932. 

  12932. 			        S = s;

    12933. 

  12933. 			    }

    12934. 

  12934. 			

    12935. 

  12935. 			    public string S;

    12936. 

  12936. 			

    12937. 

  12937. 			    public override bool Equals(object o) {

    12938. 

  12938. 			        return (o is Sc) && Equals((Sc) o);

    12939. 

  12939. 			    }

    12940. 

  12940. 			    public bool Equals(Sc other) {

    12941. 

  12941. 			        return other.S == S;

    12942. 

  12942. 			    }

    12943. 

  12943. 			    public override int GetHashCode() {

    12944. 

  12944. 			        return S.GetHashCode();

    12945. 

  12945. 			    }

    12946. 

  12946. 			}

    12947. 

  12947. 			

    12948. 

  12948. 			public struct Scs : IEquatable<Scs> {

    12949. 

  12949. 			    public Scs(string s, S val) {

    12950. 

  12950. 			        S = s;

    12951. 

  12951. 			        Val = val;

    12952. 

  12952. 			    }

    12953. 

  12953. 			

    12954. 

  12954. 			    public string S;

    12955. 

  12955. 			    public S Val;

    12956. 

  12956. 			

    12957. 

  12957. 			    public override bool Equals(object o) {

    12958. 

  12958. 			        return (o is Scs) && Equals((Scs) o);

    12959. 

  12959. 			    }

    12960. 

  12960. 			    public bool Equals(Scs other) {

    12961. 

  12961. 			        return other.S == S && other.Val.Equals(Val);

    12962. 

  12962. 			    }

    12963. 

  12963. 			    public override int GetHashCode() {

    12964. 

  12964. 			        return S.GetHashCode() ^ Val.GetHashCode();

    12965. 

  12965. 			    }

    12966. 

  12966. 			}

    12967. 

  12967. 			

    12968. 

  12968. 		

    12969. 

  12969. 	}

    12970. 

  12970. 				

    12971. 

  12971. 				//-------- Scenario 1786

    12972. 

  12972. 				namespace Scenario1786{

    12973. 

  12973. 					

    12974. 

  12974. 					public class Test

    12975. 

  12975. 					{

    12976. 

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

    12977. 

  12977. 				    public static Expression check70__() {

    12978. 

  12978. 				       if(Main() != 0 ) {

    12979. 

  12979. 				           throw new Exception();

    12980. 

  12980. 				       } else { 

    12981. 

  12981. 				           return Expression.Constant(0);

    12982. 

  12982. 				       }

    12983. 

  12983. 				    }

    12984. 

  12984. 					public     static int Main()

    12985. 

  12985. 					    {

    12986. 

  12986. 					        Ext.StartCapture();

    12987. 

  12987. 					        bool success = false;

    12988. 

  12988. 					        try

    12989. 

  12989. 					        {

    12990. 

  12990. 					            success = check70();

    12991. 

  12991. 					        }

    12992. 

  12992. 					        finally

    12993. 

  12993. 					        {

    12994. 

  12994. 					            Ext.StopCapture();

    12995. 

  12995. 					        }

    12996. 

  12996. 					        return success ? 0 : 1;

    12997. 

  12997. 					    }

    12998. 

  12998. 					

    12999. 

  12999. 					    static bool check70() {

    13000. 

  13000. 					        foreach (Sp[] val in new Sp[][] { null, new Sp[0], new Sp[] { default(Sp), new Sp(), new Sp(5,5.0) }, new Sp[100] }) {

    13001. 

  13001. 					            if (!check70(val)) {

    13002. 

  13002. 					                return false;

    13003. 

  13003. 					            }

    13004. 

  13004. 					        }

    13005. 

  13005. 					        return true;

    13006. 

  13006. 					    }

    13007. 

  13007. 					

    13008. 

  13008. 					    static bool check70(Sp[] val) {

    13009. 

  13009. 					        Expression<Func<Sp[]>> e =

    13010. 

  13010. 					            Expression.Lambda<Func<Sp[]>>(

    13011. 

  13011. 					                Expression.Constant(val, typeof(Sp[])),

    13012. 

  13012. 					                new System.Collections.Generic.List<ParameterExpression>());

    13013. 

  13013. 					        Func<Sp[]> f = e.Compile();

    13014. 

  13014. 					        return object.Equals(f(), val);

    13015. 

  13015. 					    }

    13016. 

  13016. 					}

    13017. 

  13017. 				

    13018. 

  13018. 				

    13019. 

  13019. 				public  static class Ext {

    13020. 

  13020. 				    public static void StartCapture() {

    13021. 

  13021. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13022. 

  13022. 				//        m.Invoke(null, new object[] { "test.dll" });

    13023. 

  13023. 				    }

    13024. 

  13024. 				

    13025. 

  13025. 				    public static void StopCapture() {

    13026. 

  13026. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13027. 

  13027. 				//        m.Invoke(null, new object[0]);

    13028. 

  13028. 				    }

    13029. 

  13029. 				

    13030. 

  13030. 				    public static bool IsIntegralOrEnum(Type type) {

    13031. 

  13031. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13032. 

  13032. 				            case TypeCode.Byte:

    13033. 

  13033. 				            case TypeCode.SByte:

    13034. 

  13034. 				            case TypeCode.Int16:

    13035. 

  13035. 				            case TypeCode.Int32:

    13036. 

  13036. 				            case TypeCode.Int64:

    13037. 

  13037. 				            case TypeCode.UInt16:

    13038. 

  13038. 				            case TypeCode.UInt32:

    13039. 

  13039. 				            case TypeCode.UInt64:

    13040. 

  13040. 				                return true;

    13041. 

  13041. 				            default:

    13042. 

  13042. 				                return false;

    13043. 

  13043. 				        }

    13044. 

  13044. 				    }

    13045. 

  13045. 				

    13046. 

  13046. 				    public static bool IsFloating(Type type) {

    13047. 

  13047. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13048. 

  13048. 				            case TypeCode.Single:

    13049. 

  13049. 				            case TypeCode.Double:

    13050. 

  13050. 				                return true;

    13051. 

  13051. 				            default:

    13052. 

  13052. 				                return false;

    13053. 

  13053. 				        }

    13054. 

  13054. 				    }

    13055. 

  13055. 				

    13056. 

  13056. 				    public static Type GetNonNullableType(Type type) {

    13057. 

  13057. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    13058. 

  13058. 				                type.GetGenericArguments()[0] :

    13059. 

  13059. 				                type;

    13060. 

  13060. 				    }

    13061. 

  13061. 				}

    13062. 

  13062. 				

    13063. 

  13063. 			

    13064. 

  13064. 			

    13065. 

  13065. 			

    13066. 

  13066. 			public interface I {

    13067. 

  13067. 			  void M();

    13068. 

  13068. 			}

    13069. 

  13069. 			

    13070. 

  13070. 			public  class C : IEquatable<C>, I {

    13071. 

  13071. 			    void I.M() {

    13072. 

  13072. 			    }

    13073. 

  13073. 			

    13074. 

  13074. 			    public override bool Equals(object o) {

    13075. 

  13075. 			        return o is C && Equals((C) o);

    13076. 

  13076. 			    }

    13077. 

  13077. 			

    13078. 

  13078. 			    public bool Equals(C c) {

    13079. 

  13079. 			        return c != null;

    13080. 

  13080. 			    }

    13081. 

  13081. 			

    13082. 

  13082. 			    public override int GetHashCode() {

    13083. 

  13083. 			        return 0;

    13084. 

  13084. 			    }

    13085. 

  13085. 			}

    13086. 

  13086. 			

    13087. 

  13087. 			public  class D : C, IEquatable<D> {

    13088. 

  13088. 			    public int Val;

    13089. 

  13089. 			    public D() {

    13090. 

  13090. 			    }

    13091. 

  13091. 			    public D(int val) {

    13092. 

  13092. 			        Val = val;

    13093. 

  13093. 			    }

    13094. 

  13094. 			

    13095. 

  13095. 			    public override bool Equals(object o) {

    13096. 

  13096. 			        return o is D && Equals((D) o);

    13097. 

  13097. 			    }

    13098. 

  13098. 			

    13099. 

  13099. 			    public bool Equals(D d) {

    13100. 

  13100. 			        return d != null && d.Val == Val;

    13101. 

  13101. 			    }

    13102. 

  13102. 			

    13103. 

  13103. 			    public override int GetHashCode() {

    13104. 

  13104. 			        return Val;

    13105. 

  13105. 			    }

    13106. 

  13106. 			}

    13107. 

  13107. 			

    13108. 

  13108. 			public enum E {

    13109. 

  13109. 			  A=1, B=2

    13110. 

  13110. 			}

    13111. 

  13111. 			

    13112. 

  13112. 			public enum El : long {

    13113. 

  13113. 			  A, B, C

    13114. 

  13114. 			}

    13115. 

  13115. 			

    13116. 

  13116. 			public struct S : IEquatable<S> {

    13117. 

  13117. 			    public override bool Equals(object o) {

    13118. 

  13118. 			        return (o is S) && Equals((S) o);

    13119. 

  13119. 			    }

    13120. 

  13120. 			    public bool Equals(S other) {

    13121. 

  13121. 			        return true;

    13122. 

  13122. 			    }

    13123. 

  13123. 			    public override int GetHashCode() {

    13124. 

  13124. 			        return 0;

    13125. 

  13125. 			    }

    13126. 

  13126. 			}

    13127. 

  13127. 			

    13128. 

  13128. 			public struct Sp : IEquatable<Sp> {

    13129. 

  13129. 			    public Sp(int i, double d) {

    13130. 

  13130. 			        I = i;

    13131. 

  13131. 			        D = d;

    13132. 

  13132. 			    }

    13133. 

  13133. 			

    13134. 

  13134. 			    public int I;

    13135. 

  13135. 			    public double D;

    13136. 

  13136. 			

    13137. 

  13137. 			    public override bool Equals(object o) {

    13138. 

  13138. 			        return (o is Sp) && Equals((Sp) o);

    13139. 

  13139. 			    }

    13140. 

  13140. 			    public bool Equals(Sp other) {

    13141. 

  13141. 			        return other.I == I && other.D == D;

    13142. 

  13142. 			    }

    13143. 

  13143. 			    public override int GetHashCode() {

    13144. 

  13144. 			        return I.GetHashCode() ^ D.GetHashCode();

    13145. 

  13145. 			    }

    13146. 

  13146. 			}

    13147. 

  13147. 			

    13148. 

  13148. 			public struct Ss : IEquatable<Ss> {

    13149. 

  13149. 			    public Ss(S s) {

    13150. 

  13150. 			        Val = s;

    13151. 

  13151. 			    }

    13152. 

  13152. 			

    13153. 

  13153. 			    public S Val;

    13154. 

  13154. 			

    13155. 

  13155. 			    public override bool Equals(object o) {

    13156. 

  13156. 			        return (o is Ss) && Equals((Ss) o);

    13157. 

  13157. 			    }

    13158. 

  13158. 			    public bool Equals(Ss other) {

    13159. 

  13159. 			        return other.Val.Equals(Val);

    13160. 

  13160. 			    }

    13161. 

  13161. 			    public override int GetHashCode() {

    13162. 

  13162. 			        return Val.GetHashCode();

    13163. 

  13163. 			    }

    13164. 

  13164. 			}

    13165. 

  13165. 			

    13166. 

  13166. 			public struct Sc : IEquatable<Sc> {

    13167. 

  13167. 			    public Sc(string s) {

    13168. 

  13168. 			        S = s;

    13169. 

  13169. 			    }

    13170. 

  13170. 			

    13171. 

  13171. 			    public string S;

    13172. 

  13172. 			

    13173. 

  13173. 			    public override bool Equals(object o) {

    13174. 

  13174. 			        return (o is Sc) && Equals((Sc) o);

    13175. 

  13175. 			    }

    13176. 

  13176. 			    public bool Equals(Sc other) {

    13177. 

  13177. 			        return other.S == S;

    13178. 

  13178. 			    }

    13179. 

  13179. 			    public override int GetHashCode() {

    13180. 

  13180. 			        return S.GetHashCode();

    13181. 

  13181. 			    }

    13182. 

  13182. 			}

    13183. 

  13183. 			

    13184. 

  13184. 			public struct Scs : IEquatable<Scs> {

    13185. 

  13185. 			    public Scs(string s, S val) {

    13186. 

  13186. 			        S = s;

    13187. 

  13187. 			        Val = val;

    13188. 

  13188. 			    }

    13189. 

  13189. 			

    13190. 

  13190. 			    public string S;

    13191. 

  13191. 			    public S Val;

    13192. 

  13192. 			

    13193. 

  13193. 			    public override bool Equals(object o) {

    13194. 

  13194. 			        return (o is Scs) && Equals((Scs) o);

    13195. 

  13195. 			    }

    13196. 

  13196. 			    public bool Equals(Scs other) {

    13197. 

  13197. 			        return other.S == S && other.Val.Equals(Val);

    13198. 

  13198. 			    }

    13199. 

  13199. 			    public override int GetHashCode() {

    13200. 

  13200. 			        return S.GetHashCode() ^ Val.GetHashCode();

    13201. 

  13201. 			    }

    13202. 

  13202. 			}

    13203. 

  13203. 			

    13204. 

  13204. 		

    13205. 

  13205. 	}

    13206. 

  13206. 				

    13207. 

  13207. 				//-------- Scenario 1787

    13208. 

  13208. 				namespace Scenario1787{

    13209. 

  13209. 					

    13210. 

  13210. 					public class Test

    13211. 

  13211. 					{

    13212. 

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

    13213. 

  13213. 				    public static Expression check71__() {

    13214. 

  13214. 				       if(Main() != 0 ) {

    13215. 

  13215. 				           throw new Exception();

    13216. 

  13216. 				       } else { 

    13217. 

  13217. 				           return Expression.Constant(0);

    13218. 

  13218. 				       }

    13219. 

  13219. 				    }

    13220. 

  13220. 					public     static int Main()

    13221. 

  13221. 					    {

    13222. 

  13222. 					        Ext.StartCapture();

    13223. 

  13223. 					        bool success = false;

    13224. 

  13224. 					        try

    13225. 

  13225. 					        {

    13226. 

  13226. 					            success = check71();

    13227. 

  13227. 					        }

    13228. 

  13228. 					        finally

    13229. 

  13229. 					        {

    13230. 

  13230. 					            Ext.StopCapture();

    13231. 

  13231. 					        }

    13232. 

  13232. 					        return success ? 0 : 1;

    13233. 

  13233. 					    }

    13234. 

  13234. 					

    13235. 

  13235. 					    static bool check71() {

    13236. 

  13236. 					        foreach (Ss[] val in new Ss[][] { null, new Ss[0], new Ss[] { default(Ss), new Ss(), new Ss(new S()) }, new Ss[100] }) {

    13237. 

  13237. 					            if (!check71(val)) {

    13238. 

  13238. 					                return false;

    13239. 

  13239. 					            }

    13240. 

  13240. 					        }

    13241. 

  13241. 					        return true;

    13242. 

  13242. 					    }

    13243. 

  13243. 					

    13244. 

  13244. 					    static bool check71(Ss[] val) {

    13245. 

  13245. 					        Expression<Func<Ss[]>> e =

    13246. 

  13246. 					            Expression.Lambda<Func<Ss[]>>(

    13247. 

  13247. 					                Expression.Constant(val, typeof(Ss[])),

    13248. 

  13248. 					                new System.Collections.Generic.List<ParameterExpression>());

    13249. 

  13249. 					        Func<Ss[]> f = e.Compile();

    13250. 

  13250. 					        return object.Equals(f(), val);

    13251. 

  13251. 					    }

    13252. 

  13252. 					}

    13253. 

  13253. 				

    13254. 

  13254. 				

    13255. 

  13255. 				public  static class Ext {

    13256. 

  13256. 				    public static void StartCapture() {

    13257. 

  13257. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13258. 

  13258. 				//        m.Invoke(null, new object[] { "test.dll" });

    13259. 

  13259. 				    }

    13260. 

  13260. 				

    13261. 

  13261. 				    public static void StopCapture() {

    13262. 

  13262. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13263. 

  13263. 				//        m.Invoke(null, new object[0]);

    13264. 

  13264. 				    }

    13265. 

  13265. 				

    13266. 

  13266. 				    public static bool IsIntegralOrEnum(Type type) {

    13267. 

  13267. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13268. 

  13268. 				            case TypeCode.Byte:

    13269. 

  13269. 				            case TypeCode.SByte:

    13270. 

  13270. 				            case TypeCode.Int16:

    13271. 

  13271. 				            case TypeCode.Int32:

    13272. 

  13272. 				            case TypeCode.Int64:

    13273. 

  13273. 				            case TypeCode.UInt16:

    13274. 

  13274. 				            case TypeCode.UInt32:

    13275. 

  13275. 				            case TypeCode.UInt64:

    13276. 

  13276. 				                return true;

    13277. 

  13277. 				            default:

    13278. 

  13278. 				                return false;

    13279. 

  13279. 				        }

    13280. 

  13280. 				    }

    13281. 

  13281. 				

    13282. 

  13282. 				    public static bool IsFloating(Type type) {

    13283. 

  13283. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13284. 

  13284. 				            case TypeCode.Single:

    13285. 

  13285. 				            case TypeCode.Double:

    13286. 

  13286. 				                return true;

    13287. 

  13287. 				            default:

    13288. 

  13288. 				                return false;

    13289. 

  13289. 				        }

    13290. 

  13290. 				    }

    13291. 

  13291. 				

    13292. 

  13292. 				    public static Type GetNonNullableType(Type type) {

    13293. 

  13293. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    13294. 

  13294. 				                type.GetGenericArguments()[0] :

    13295. 

  13295. 				                type;

    13296. 

  13296. 				    }

    13297. 

  13297. 				}

    13298. 

  13298. 				

    13299. 

  13299. 			

    13300. 

  13300. 			

    13301. 

  13301. 			

    13302. 

  13302. 			public interface I {

    13303. 

  13303. 			  void M();

    13304. 

  13304. 			}

    13305. 

  13305. 			

    13306. 

  13306. 			public  class C : IEquatable<C>, I {

    13307. 

  13307. 			    void I.M() {

    13308. 

  13308. 			    }

    13309. 

  13309. 			

    13310. 

  13310. 			    public override bool Equals(object o) {

    13311. 

  13311. 			        return o is C && Equals((C) o);

    13312. 

  13312. 			    }

    13313. 

  13313. 			

    13314. 

  13314. 			    public bool Equals(C c) {

    13315. 

  13315. 			        return c != null;

    13316. 

  13316. 			    }

    13317. 

  13317. 			

    13318. 

  13318. 			    public override int GetHashCode() {

    13319. 

  13319. 			        return 0;

    13320. 

  13320. 			    }

    13321. 

  13321. 			}

    13322. 

  13322. 			

    13323. 

  13323. 			public  class D : C, IEquatable<D> {

    13324. 

  13324. 			    public int Val;

    13325. 

  13325. 			    public D() {

    13326. 

  13326. 			    }

    13327. 

  13327. 			    public D(int val) {

    13328. 

  13328. 			        Val = val;

    13329. 

  13329. 			    }

    13330. 

  13330. 			

    13331. 

  13331. 			    public override bool Equals(object o) {

    13332. 

  13332. 			        return o is D && Equals((D) o);

    13333. 

  13333. 			    }

    13334. 

  13334. 			

    13335. 

  13335. 			    public bool Equals(D d) {

    13336. 

  13336. 			        return d != null && d.Val == Val;

    13337. 

  13337. 			    }

    13338. 

  13338. 			

    13339. 

  13339. 			    public override int GetHashCode() {

    13340. 

  13340. 			        return Val;

    13341. 

  13341. 			    }

    13342. 

  13342. 			}

    13343. 

  13343. 			

    13344. 

  13344. 			public enum E {

    13345. 

  13345. 			  A=1, B=2

    13346. 

  13346. 			}

    13347. 

  13347. 			

    13348. 

  13348. 			public enum El : long {

    13349. 

  13349. 			  A, B, C

    13350. 

  13350. 			}

    13351. 

  13351. 			

    13352. 

  13352. 			public struct S : IEquatable<S> {

    13353. 

  13353. 			    public override bool Equals(object o) {

    13354. 

  13354. 			        return (o is S) && Equals((S) o);

    13355. 

  13355. 			    }

    13356. 

  13356. 			    public bool Equals(S other) {

    13357. 

  13357. 			        return true;

    13358. 

  13358. 			    }

    13359. 

  13359. 			    public override int GetHashCode() {

    13360. 

  13360. 			        return 0;

    13361. 

  13361. 			    }

    13362. 

  13362. 			}

    13363. 

  13363. 			

    13364. 

  13364. 			public struct Sp : IEquatable<Sp> {

    13365. 

  13365. 			    public Sp(int i, double d) {

    13366. 

  13366. 			        I = i;

    13367. 

  13367. 			        D = d;

    13368. 

  13368. 			    }

    13369. 

  13369. 			

    13370. 

  13370. 			    public int I;

    13371. 

  13371. 			    public double D;

    13372. 

  13372. 			

    13373. 

  13373. 			    public override bool Equals(object o) {

    13374. 

  13374. 			        return (o is Sp) && Equals((Sp) o);

    13375. 

  13375. 			    }

    13376. 

  13376. 			    public bool Equals(Sp other) {

    13377. 

  13377. 			        return other.I == I && other.D == D;

    13378. 

  13378. 			    }

    13379. 

  13379. 			    public override int GetHashCode() {

    13380. 

  13380. 			        return I.GetHashCode() ^ D.GetHashCode();

    13381. 

  13381. 			    }

    13382. 

  13382. 			}

    13383. 

  13383. 			

    13384. 

  13384. 			public struct Ss : IEquatable<Ss> {

    13385. 

  13385. 			    public Ss(S s) {

    13386. 

  13386. 			        Val = s;

    13387. 

  13387. 			    }

    13388. 

  13388. 			

    13389. 

  13389. 			    public S Val;

    13390. 

  13390. 			

    13391. 

  13391. 			    public override bool Equals(object o) {

    13392. 

  13392. 			        return (o is Ss) && Equals((Ss) o);

    13393. 

  13393. 			    }

    13394. 

  13394. 			    public bool Equals(Ss other) {

    13395. 

  13395. 			        return other.Val.Equals(Val);

    13396. 

  13396. 			    }

    13397. 

  13397. 			    public override int GetHashCode() {

    13398. 

  13398. 			        return Val.GetHashCode();

    13399. 

  13399. 			    }

    13400. 

  13400. 			}

    13401. 

  13401. 			

    13402. 

  13402. 			public struct Sc : IEquatable<Sc> {

    13403. 

  13403. 			    public Sc(string s) {

    13404. 

  13404. 			        S = s;

    13405. 

  13405. 			    }

    13406. 

  13406. 			

    13407. 

  13407. 			    public string S;

    13408. 

  13408. 			

    13409. 

  13409. 			    public override bool Equals(object o) {

    13410. 

  13410. 			        return (o is Sc) && Equals((Sc) o);

    13411. 

  13411. 			    }

    13412. 

  13412. 			    public bool Equals(Sc other) {

    13413. 

  13413. 			        return other.S == S;

    13414. 

  13414. 			    }

    13415. 

  13415. 			    public override int GetHashCode() {

    13416. 

  13416. 			        return S.GetHashCode();

    13417. 

  13417. 			    }

    13418. 

  13418. 			}

    13419. 

  13419. 			

    13420. 

  13420. 			public struct Scs : IEquatable<Scs> {

    13421. 

  13421. 			    public Scs(string s, S val) {

    13422. 

  13422. 			        S = s;

    13423. 

  13423. 			        Val = val;

    13424. 

  13424. 			    }

    13425. 

  13425. 			

    13426. 

  13426. 			    public string S;

    13427. 

  13427. 			    public S Val;

    13428. 

  13428. 			

    13429. 

  13429. 			    public override bool Equals(object o) {

    13430. 

  13430. 			        return (o is Scs) && Equals((Scs) o);

    13431. 

  13431. 			    }

    13432. 

  13432. 			    public bool Equals(Scs other) {

    13433. 

  13433. 			        return other.S == S && other.Val.Equals(Val);

    13434. 

  13434. 			    }

    13435. 

  13435. 			    public override int GetHashCode() {

    13436. 

  13436. 			        return S.GetHashCode() ^ Val.GetHashCode();

    13437. 

  13437. 			    }

    13438. 

  13438. 			}

    13439. 

  13439. 			

    13440. 

  13440. 		

    13441. 

  13441. 	}

    13442. 

  13442. 				

    13443. 

  13443. 				//-------- Scenario 1788

    13444. 

  13444. 				namespace Scenario1788{

    13445. 

  13445. 					

    13446. 

  13446. 					public class Test

    13447. 

  13447. 					{

    13448. 

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

    13449. 

  13449. 				    public static Expression check72__() {

    13450. 

  13450. 				       if(Main() != 0 ) {

    13451. 

  13451. 				           throw new Exception();

    13452. 

  13452. 				       } else { 

    13453. 

  13453. 				           return Expression.Constant(0);

    13454. 

  13454. 				       }

    13455. 

  13455. 				    }

    13456. 

  13456. 					public     static int Main()

    13457. 

  13457. 					    {

    13458. 

  13458. 					        Ext.StartCapture();

    13459. 

  13459. 					        bool success = false;

    13460. 

  13460. 					        try

    13461. 

  13461. 					        {

    13462. 

  13462. 					            success = check72();

    13463. 

  13463. 					        }

    13464. 

  13464. 					        finally

    13465. 

  13465. 					        {

    13466. 

  13466. 					            Ext.StopCapture();

    13467. 

  13467. 					        }

    13468. 

  13468. 					        return success ? 0 : 1;

    13469. 

  13469. 					    }

    13470. 

  13470. 					

    13471. 

  13471. 					    static bool check72() {

    13472. 

  13472. 					        foreach (Sc[] val in new Sc[][] { null, new Sc[0], new Sc[] { default(Sc), new Sc(), new Sc(null) }, new Sc[100] }) {

    13473. 

  13473. 					            if (!check72(val)) {

    13474. 

  13474. 					                return false;

    13475. 

  13475. 					            }

    13476. 

  13476. 					        }

    13477. 

  13477. 					        return true;

    13478. 

  13478. 					    }

    13479. 

  13479. 					

    13480. 

  13480. 					    static bool check72(Sc[] val) {

    13481. 

  13481. 					        Expression<Func<Sc[]>> e =

    13482. 

  13482. 					            Expression.Lambda<Func<Sc[]>>(

    13483. 

  13483. 					                Expression.Constant(val, typeof(Sc[])),

    13484. 

  13484. 					                new System.Collections.Generic.List<ParameterExpression>());

    13485. 

  13485. 					        Func<Sc[]> f = e.Compile();

    13486. 

  13486. 					        return object.Equals(f(), val);

    13487. 

  13487. 					    }

    13488. 

  13488. 					}

    13489. 

  13489. 				

    13490. 

  13490. 				

    13491. 

  13491. 				public  static class Ext {

    13492. 

  13492. 				    public static void StartCapture() {

    13493. 

  13493. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13494. 

  13494. 				//        m.Invoke(null, new object[] { "test.dll" });

    13495. 

  13495. 				    }

    13496. 

  13496. 				

    13497. 

  13497. 				    public static void StopCapture() {

    13498. 

  13498. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13499. 

  13499. 				//        m.Invoke(null, new object[0]);

    13500. 

  13500. 				    }

    13501. 

  13501. 				

    13502. 

  13502. 				    public static bool IsIntegralOrEnum(Type type) {

    13503. 

  13503. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13504. 

  13504. 				            case TypeCode.Byte:

    13505. 

  13505. 				            case TypeCode.SByte:

    13506. 

  13506. 				            case TypeCode.Int16:

    13507. 

  13507. 				            case TypeCode.Int32:

    13508. 

  13508. 				            case TypeCode.Int64:

    13509. 

  13509. 				            case TypeCode.UInt16:

    13510. 

  13510. 				            case TypeCode.UInt32:

    13511. 

  13511. 				            case TypeCode.UInt64:

    13512. 

  13512. 				                return true;

    13513. 

  13513. 				            default:

    13514. 

  13514. 				                return false;

    13515. 

  13515. 				        }

    13516. 

  13516. 				    }

    13517. 

  13517. 				

    13518. 

  13518. 				    public static bool IsFloating(Type type) {

    13519. 

  13519. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13520. 

  13520. 				            case TypeCode.Single:

    13521. 

  13521. 				            case TypeCode.Double:

    13522. 

  13522. 				                return true;

    13523. 

  13523. 				            default:

    13524. 

  13524. 				                return false;

    13525. 

  13525. 				        }

    13526. 

  13526. 				    }

    13527. 

  13527. 				

    13528. 

  13528. 				    public static Type GetNonNullableType(Type type) {

    13529. 

  13529. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    13530. 

  13530. 				                type.GetGenericArguments()[0] :

    13531. 

  13531. 				                type;

    13532. 

  13532. 				    }

    13533. 

  13533. 				}

    13534. 

  13534. 				

    13535. 

  13535. 			

    13536. 

  13536. 			

    13537. 

  13537. 			

    13538. 

  13538. 			public interface I {

    13539. 

  13539. 			  void M();

    13540. 

  13540. 			}

    13541. 

  13541. 			

    13542. 

  13542. 			public  class C : IEquatable<C>, I {

    13543. 

  13543. 			    void I.M() {

    13544. 

  13544. 			    }

    13545. 

  13545. 			

    13546. 

  13546. 			    public override bool Equals(object o) {

    13547. 

  13547. 			        return o is C && Equals((C) o);

    13548. 

  13548. 			    }

    13549. 

  13549. 			

    13550. 

  13550. 			    public bool Equals(C c) {

    13551. 

  13551. 			        return c != null;

    13552. 

  13552. 			    }

    13553. 

  13553. 			

    13554. 

  13554. 			    public override int GetHashCode() {

    13555. 

  13555. 			        return 0;

    13556. 

  13556. 			    }

    13557. 

  13557. 			}

    13558. 

  13558. 			

    13559. 

  13559. 			public  class D : C, IEquatable<D> {

    13560. 

  13560. 			    public int Val;

    13561. 

  13561. 			    public D() {

    13562. 

  13562. 			    }

    13563. 

  13563. 			    public D(int val) {

    13564. 

  13564. 			        Val = val;

    13565. 

  13565. 			    }

    13566. 

  13566. 			

    13567. 

  13567. 			    public override bool Equals(object o) {

    13568. 

  13568. 			        return o is D && Equals((D) o);

    13569. 

  13569. 			    }

    13570. 

  13570. 			

    13571. 

  13571. 			    public bool Equals(D d) {

    13572. 

  13572. 			        return d != null && d.Val == Val;

    13573. 

  13573. 			    }

    13574. 

  13574. 			

    13575. 

  13575. 			    public override int GetHashCode() {

    13576. 

  13576. 			        return Val;

    13577. 

  13577. 			    }

    13578. 

  13578. 			}

    13579. 

  13579. 			

    13580. 

  13580. 			public enum E {

    13581. 

  13581. 			  A=1, B=2

    13582. 

  13582. 			}

    13583. 

  13583. 			

    13584. 

  13584. 			public enum El : long {

    13585. 

  13585. 			  A, B, C

    13586. 

  13586. 			}

    13587. 

  13587. 			

    13588. 

  13588. 			public struct S : IEquatable<S> {

    13589. 

  13589. 			    public override bool Equals(object o) {

    13590. 

  13590. 			        return (o is S) && Equals((S) o);

    13591. 

  13591. 			    }

    13592. 

  13592. 			    public bool Equals(S other) {

    13593. 

  13593. 			        return true;

    13594. 

  13594. 			    }

    13595. 

  13595. 			    public override int GetHashCode() {

    13596. 

  13596. 			        return 0;

    13597. 

  13597. 			    }

    13598. 

  13598. 			}

    13599. 

  13599. 			

    13600. 

  13600. 			public struct Sp : IEquatable<Sp> {

    13601. 

  13601. 			    public Sp(int i, double d) {

    13602. 

  13602. 			        I = i;

    13603. 

  13603. 			        D = d;

    13604. 

  13604. 			    }

    13605. 

  13605. 			

    13606. 

  13606. 			    public int I;

    13607. 

  13607. 			    public double D;

    13608. 

  13608. 			

    13609. 

  13609. 			    public override bool Equals(object o) {

    13610. 

  13610. 			        return (o is Sp) && Equals((Sp) o);

    13611. 

  13611. 			    }

    13612. 

  13612. 			    public bool Equals(Sp other) {

    13613. 

  13613. 			        return other.I == I && other.D == D;

    13614. 

  13614. 			    }

    13615. 

  13615. 			    public override int GetHashCode() {

    13616. 

  13616. 			        return I.GetHashCode() ^ D.GetHashCode();

    13617. 

  13617. 			    }

    13618. 

  13618. 			}

    13619. 

  13619. 			

    13620. 

  13620. 			public struct Ss : IEquatable<Ss> {

    13621. 

  13621. 			    public Ss(S s) {

    13622. 

  13622. 			        Val = s;

    13623. 

  13623. 			    }

    13624. 

  13624. 			

    13625. 

  13625. 			    public S Val;

    13626. 

  13626. 			

    13627. 

  13627. 			    public override bool Equals(object o) {

    13628. 

  13628. 			        return (o is Ss) && Equals((Ss) o);

    13629. 

  13629. 			    }

    13630. 

  13630. 			    public bool Equals(Ss other) {

    13631. 

  13631. 			        return other.Val.Equals(Val);

    13632. 

  13632. 			    }

    13633. 

  13633. 			    public override int GetHashCode() {

    13634. 

  13634. 			        return Val.GetHashCode();

    13635. 

  13635. 			    }

    13636. 

  13636. 			}

    13637. 

  13637. 			

    13638. 

  13638. 			public struct Sc : IEquatable<Sc> {

    13639. 

  13639. 			    public Sc(string s) {

    13640. 

  13640. 			        S = s;

    13641. 

  13641. 			    }

    13642. 

  13642. 			

    13643. 

  13643. 			    public string S;

    13644. 

  13644. 			

    13645. 

  13645. 			    public override bool Equals(object o) {

    13646. 

  13646. 			        return (o is Sc) && Equals((Sc) o);

    13647. 

  13647. 			    }

    13648. 

  13648. 			    public bool Equals(Sc other) {

    13649. 

  13649. 			        return other.S == S;

    13650. 

  13650. 			    }

    13651. 

  13651. 			    public override int GetHashCode() {

    13652. 

  13652. 			        return S.GetHashCode();

    13653. 

  13653. 			    }

    13654. 

  13654. 			}

    13655. 

  13655. 			

    13656. 

  13656. 			public struct Scs : IEquatable<Scs> {

    13657. 

  13657. 			    public Scs(string s, S val) {

    13658. 

  13658. 			        S = s;

    13659. 

  13659. 			        Val = val;

    13660. 

  13660. 			    }

    13661. 

  13661. 			

    13662. 

  13662. 			    public string S;

    13663. 

  13663. 			    public S Val;

    13664. 

  13664. 			

    13665. 

  13665. 			    public override bool Equals(object o) {

    13666. 

  13666. 			        return (o is Scs) && Equals((Scs) o);

    13667. 

  13667. 			    }

    13668. 

  13668. 			    public bool Equals(Scs other) {

    13669. 

  13669. 			        return other.S == S && other.Val.Equals(Val);

    13670. 

  13670. 			    }

    13671. 

  13671. 			    public override int GetHashCode() {

    13672. 

  13672. 			        return S.GetHashCode() ^ Val.GetHashCode();

    13673. 

  13673. 			    }

    13674. 

  13674. 			}

    13675. 

  13675. 			

    13676. 

  13676. 		

    13677. 

  13677. 	}

    13678. 

  13678. 				

    13679. 

  13679. 				//-------- Scenario 1789

    13680. 

  13680. 				namespace Scenario1789{

    13681. 

  13681. 					

    13682. 

  13682. 					public class Test

    13683. 

  13683. 					{

    13684. 

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

    13685. 

  13685. 				    public static Expression check73__() {

    13686. 

  13686. 				       if(Main() != 0 ) {

    13687. 

  13687. 				           throw new Exception();

    13688. 

  13688. 				       } else { 

    13689. 

  13689. 				           return Expression.Constant(0);

    13690. 

  13690. 				       }

    13691. 

  13691. 				    }

    13692. 

  13692. 					public     static int Main()

    13693. 

  13693. 					    {

    13694. 

  13694. 					        Ext.StartCapture();

    13695. 

  13695. 					        bool success = false;

    13696. 

  13696. 					        try

    13697. 

  13697. 					        {

    13698. 

  13698. 					            success = check73();

    13699. 

  13699. 					        }

    13700. 

  13700. 					        finally

    13701. 

  13701. 					        {

    13702. 

  13702. 					            Ext.StopCapture();

    13703. 

  13703. 					        }

    13704. 

  13704. 					        return success ? 0 : 1;

    13705. 

  13705. 					    }

    13706. 

  13706. 					

    13707. 

  13707. 					    static bool check73() {

    13708. 

  13708. 					        foreach (Scs[] val in new Scs[][] { null, new Scs[0], new Scs[] { default(Scs), new Scs(), new Scs(null,new S()) }, new Scs[100] }) {

    13709. 

  13709. 					            if (!check73(val)) {

    13710. 

  13710. 					                return false;

    13711. 

  13711. 					            }

    13712. 

  13712. 					        }

    13713. 

  13713. 					        return true;

    13714. 

  13714. 					    }

    13715. 

  13715. 					

    13716. 

  13716. 					    static bool check73(Scs[] val) {

    13717. 

  13717. 					        Expression<Func<Scs[]>> e =

    13718. 

  13718. 					            Expression.Lambda<Func<Scs[]>>(

    13719. 

  13719. 					                Expression.Constant(val, typeof(Scs[])),

    13720. 

  13720. 					                new System.Collections.Generic.List<ParameterExpression>());

    13721. 

  13721. 					        Func<Scs[]> f = e.Compile();

    13722. 

  13722. 					        return object.Equals(f(), val);

    13723. 

  13723. 					    }

    13724. 

  13724. 					}

    13725. 

  13725. 				

    13726. 

  13726. 				

    13727. 

  13727. 				public  static class Ext {

    13728. 

  13728. 				    public static void StartCapture() {

    13729. 

  13729. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13730. 

  13730. 				//        m.Invoke(null, new object[] { "test.dll" });

    13731. 

  13731. 				    }

    13732. 

  13732. 				

    13733. 

  13733. 				    public static void StopCapture() {

    13734. 

  13734. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13735. 

  13735. 				//        m.Invoke(null, new object[0]);

    13736. 

  13736. 				    }

    13737. 

  13737. 				

    13738. 

  13738. 				    public static bool IsIntegralOrEnum(Type type) {

    13739. 

  13739. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13740. 

  13740. 				            case TypeCode.Byte:

    13741. 

  13741. 				            case TypeCode.SByte:

    13742. 

  13742. 				            case TypeCode.Int16:

    13743. 

  13743. 				            case TypeCode.Int32:

    13744. 

  13744. 				            case TypeCode.Int64:

    13745. 

  13745. 				            case TypeCode.UInt16:

    13746. 

  13746. 				            case TypeCode.UInt32:

    13747. 

  13747. 				            case TypeCode.UInt64:

    13748. 

  13748. 				                return true;

    13749. 

  13749. 				            default:

    13750. 

  13750. 				                return false;

    13751. 

  13751. 				        }

    13752. 

  13752. 				    }

    13753. 

  13753. 				

    13754. 

  13754. 				    public static bool IsFloating(Type type) {

    13755. 

  13755. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13756. 

  13756. 				            case TypeCode.Single:

    13757. 

  13757. 				            case TypeCode.Double:

    13758. 

  13758. 				                return true;

    13759. 

  13759. 				            default:

    13760. 

  13760. 				                return false;

    13761. 

  13761. 				        }

    13762. 

  13762. 				    }

    13763. 

  13763. 				

    13764. 

  13764. 				    public static Type GetNonNullableType(Type type) {

    13765. 

  13765. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    13766. 

  13766. 				                type.GetGenericArguments()[0] :

    13767. 

  13767. 				                type;

    13768. 

  13768. 				    }

    13769. 

  13769. 				}

    13770. 

  13770. 				

    13771. 

  13771. 			

    13772. 

  13772. 			

    13773. 

  13773. 			

    13774. 

  13774. 			public interface I {

    13775. 

  13775. 			  void M();

    13776. 

  13776. 			}

    13777. 

  13777. 			

    13778. 

  13778. 			public  class C : IEquatable<C>, I {

    13779. 

  13779. 			    void I.M() {

    13780. 

  13780. 			    }

    13781. 

  13781. 			

    13782. 

  13782. 			    public override bool Equals(object o) {

    13783. 

  13783. 			        return o is C && Equals((C) o);

    13784. 

  13784. 			    }

    13785. 

  13785. 			

    13786. 

  13786. 			    public bool Equals(C c) {

    13787. 

  13787. 			        return c != null;

    13788. 

  13788. 			    }

    13789. 

  13789. 			

    13790. 

  13790. 			    public override int GetHashCode() {

    13791. 

  13791. 			        return 0;

    13792. 

  13792. 			    }

    13793. 

  13793. 			}

    13794. 

  13794. 			

    13795. 

  13795. 			public  class D : C, IEquatable<D> {

    13796. 

  13796. 			    public int Val;

    13797. 

  13797. 			    public D() {

    13798. 

  13798. 			    }

    13799. 

  13799. 			    public D(int val) {

    13800. 

  13800. 			        Val = val;

    13801. 

  13801. 			    }

    13802. 

  13802. 			

    13803. 

  13803. 			    public override bool Equals(object o) {

    13804. 

  13804. 			        return o is D && Equals((D) o);

    13805. 

  13805. 			    }

    13806. 

  13806. 			

    13807. 

  13807. 			    public bool Equals(D d) {

    13808. 

  13808. 			        return d != null && d.Val == Val;

    13809. 

  13809. 			    }

    13810. 

  13810. 			

    13811. 

  13811. 			    public override int GetHashCode() {

    13812. 

  13812. 			        return Val;

    13813. 

  13813. 			    }

    13814. 

  13814. 			}

    13815. 

  13815. 			

    13816. 

  13816. 			public enum E {

    13817. 

  13817. 			  A=1, B=2

    13818. 

  13818. 			}

    13819. 

  13819. 			

    13820. 

  13820. 			public enum El : long {

    13821. 

  13821. 			  A, B, C

    13822. 

  13822. 			}

    13823. 

  13823. 			

    13824. 

  13824. 			public struct S : IEquatable<S> {

    13825. 

  13825. 			    public override bool Equals(object o) {

    13826. 

  13826. 			        return (o is S) && Equals((S) o);

    13827. 

  13827. 			    }

    13828. 

  13828. 			    public bool Equals(S other) {

    13829. 

  13829. 			        return true;

    13830. 

  13830. 			    }

    13831. 

  13831. 			    public override int GetHashCode() {

    13832. 

  13832. 			        return 0;

    13833. 

  13833. 			    }

    13834. 

  13834. 			}

    13835. 

  13835. 			

    13836. 

  13836. 			public struct Sp : IEquatable<Sp> {

    13837. 

  13837. 			    public Sp(int i, double d) {

    13838. 

  13838. 			        I = i;

    13839. 

  13839. 			        D = d;

    13840. 

  13840. 			    }

    13841. 

  13841. 			

    13842. 

  13842. 			    public int I;

    13843. 

  13843. 			    public double D;

    13844. 

  13844. 			

    13845. 

  13845. 			    public override bool Equals(object o) {

    13846. 

  13846. 			        return (o is Sp) && Equals((Sp) o);

    13847. 

  13847. 			    }

    13848. 

  13848. 			    public bool Equals(Sp other) {

    13849. 

  13849. 			        return other.I == I && other.D == D;

    13850. 

  13850. 			    }

    13851. 

  13851. 			    public override int GetHashCode() {

    13852. 

  13852. 			        return I.GetHashCode() ^ D.GetHashCode();

    13853. 

  13853. 			    }

    13854. 

  13854. 			}

    13855. 

  13855. 			

    13856. 

  13856. 			public struct Ss : IEquatable<Ss> {

    13857. 

  13857. 			    public Ss(S s) {

    13858. 

  13858. 			        Val = s;

    13859. 

  13859. 			    }

    13860. 

  13860. 			

    13861. 

  13861. 			    public S Val;

    13862. 

  13862. 			

    13863. 

  13863. 			    public override bool Equals(object o) {

    13864. 

  13864. 			        return (o is Ss) && Equals((Ss) o);

    13865. 

  13865. 			    }

    13866. 

  13866. 			    public bool Equals(Ss other) {

    13867. 

  13867. 			        return other.Val.Equals(Val);

    13868. 

  13868. 			    }

    13869. 

  13869. 			    public override int GetHashCode() {

    13870. 

  13870. 			        return Val.GetHashCode();

    13871. 

  13871. 			    }

    13872. 

  13872. 			}

    13873. 

  13873. 			

    13874. 

  13874. 			public struct Sc : IEquatable<Sc> {

    13875. 

  13875. 			    public Sc(string s) {

    13876. 

  13876. 			        S = s;

    13877. 

  13877. 			    }

    13878. 

  13878. 			

    13879. 

  13879. 			    public string S;

    13880. 

  13880. 			

    13881. 

  13881. 			    public override bool Equals(object o) {

    13882. 

  13882. 			        return (o is Sc) && Equals((Sc) o);

    13883. 

  13883. 			    }

    13884. 

  13884. 			    public bool Equals(Sc other) {

    13885. 

  13885. 			        return other.S == S;

    13886. 

  13886. 			    }

    13887. 

  13887. 			    public override int GetHashCode() {

    13888. 

  13888. 			        return S.GetHashCode();

    13889. 

  13889. 			    }

    13890. 

  13890. 			}

    13891. 

  13891. 			

    13892. 

  13892. 			public struct Scs : IEquatable<Scs> {

    13893. 

  13893. 			    public Scs(string s, S val) {

    13894. 

  13894. 			        S = s;

    13895. 

  13895. 			        Val = val;

    13896. 

  13896. 			    }

    13897. 

  13897. 			

    13898. 

  13898. 			    public string S;

    13899. 

  13899. 			    public S Val;

    13900. 

  13900. 			

    13901. 

  13901. 			    public override bool Equals(object o) {

    13902. 

  13902. 			        return (o is Scs) && Equals((Scs) o);

    13903. 

  13903. 			    }

    13904. 

  13904. 			    public bool Equals(Scs other) {

    13905. 

  13905. 			        return other.S == S && other.Val.Equals(Val);

    13906. 

  13906. 			    }

    13907. 

  13907. 			    public override int GetHashCode() {

    13908. 

  13908. 			        return S.GetHashCode() ^ Val.GetHashCode();

    13909. 

  13909. 			    }

    13910. 

  13910. 			}

    13911. 

  13911. 			

    13912. 

  13912. 		

    13913. 

  13913. 	}

    13914. 

  13914. 				

    13915. 

  13915. 				//-------- Scenario 1790

    13916. 

  13916. 				namespace Scenario1790{

    13917. 

  13917. 					

    13918. 

  13918. 					public class Test

    13919. 

  13919. 					{

    13920. 

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

    13921. 

  13921. 				    public static Expression check74_S___() {

    13922. 

  13922. 				       if(Main() != 0 ) {

    13923. 

  13923. 				           throw new Exception();

    13924. 

  13924. 				       } else { 

    13925. 

  13925. 				           return Expression.Constant(0);

    13926. 

  13926. 				       }

    13927. 

  13927. 				    }

    13928. 

  13928. 					public     static int Main()

    13929. 

  13929. 					    {

    13930. 

  13930. 					        Ext.StartCapture();

    13931. 

  13931. 					        bool success = false;

    13932. 

  13932. 					        try

    13933. 

  13933. 					        {

    13934. 

  13934. 					            success = check74<S>();

    13935. 

  13935. 					        }

    13936. 

  13936. 					        finally

    13937. 

  13937. 					        {

    13938. 

  13938. 					            Ext.StopCapture();

    13939. 

  13939. 					        }

    13940. 

  13940. 					        return success ? 0 : 1;

    13941. 

  13941. 					    }

    13942. 

  13942. 					

    13943. 

  13943. 					    static bool check74<Ts>() where Ts : struct {

    13944. 

  13944. 					        foreach (Ts[] val in new Ts[][] { null, new Ts[0], new Ts[] { default(Ts), new Ts() }, new Ts[100] }) {

    13945. 

  13945. 					            if (!check74<Ts>(val)) {

    13946. 

  13946. 					                return false;

    13947. 

  13947. 					            }

    13948. 

  13948. 					        }

    13949. 

  13949. 					        return true;

    13950. 

  13950. 					    }

    13951. 

  13951. 					

    13952. 

  13952. 					    static bool check74<Ts>(Ts[] val) where Ts : struct {

    13953. 

  13953. 					        Expression<Func<Ts[]>> e =

    13954. 

  13954. 					            Expression.Lambda<Func<Ts[]>>(

    13955. 

  13955. 					                Expression.Constant(val, typeof(Ts[])),

    13956. 

  13956. 					                new System.Collections.Generic.List<ParameterExpression>());

    13957. 

  13957. 					        Func<Ts[]> f = e.Compile();

    13958. 

  13958. 					        return object.Equals(f(), val);

    13959. 

  13959. 					    }

    13960. 

  13960. 					}

    13961. 

  13961. 				

    13962. 

  13962. 				

    13963. 

  13963. 				public  static class Ext {

    13964. 

  13964. 				    public static void StartCapture() {

    13965. 

  13965. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13966. 

  13966. 				//        m.Invoke(null, new object[] { "test.dll" });

    13967. 

  13967. 				    }

    13968. 

  13968. 				

    13969. 

  13969. 				    public static void StopCapture() {

    13970. 

  13970. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    13971. 

  13971. 				//        m.Invoke(null, new object[0]);

    13972. 

  13972. 				    }

    13973. 

  13973. 				

    13974. 

  13974. 				    public static bool IsIntegralOrEnum(Type type) {

    13975. 

  13975. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13976. 

  13976. 				            case TypeCode.Byte:

    13977. 

  13977. 				            case TypeCode.SByte:

    13978. 

  13978. 				            case TypeCode.Int16:

    13979. 

  13979. 				            case TypeCode.Int32:

    13980. 

  13980. 				            case TypeCode.Int64:

    13981. 

  13981. 				            case TypeCode.UInt16:

    13982. 

  13982. 				            case TypeCode.UInt32:

    13983. 

  13983. 				            case TypeCode.UInt64:

    13984. 

  13984. 				                return true;

    13985. 

  13985. 				            default:

    13986. 

  13986. 				                return false;

    13987. 

  13987. 				        }

    13988. 

  13988. 				    }

    13989. 

  13989. 				

    13990. 

  13990. 				    public static bool IsFloating(Type type) {

    13991. 

  13991. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    13992. 

  13992. 				            case TypeCode.Single:

    13993. 

  13993. 				            case TypeCode.Double:

    13994. 

  13994. 				                return true;

    13995. 

  13995. 				            default:

    13996. 

  13996. 				                return false;

    13997. 

  13997. 				        }

    13998. 

  13998. 				    }

    13999. 

  13999. 				

    14000. 

  14000. 				    public static Type GetNonNullableType(Type type) {

    14001. 

  14001. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    14002. 

  14002. 				                type.GetGenericArguments()[0] :

    14003. 

  14003. 				                type;

    14004. 

  14004. 				    }

    14005. 

  14005. 				}

    14006. 

  14006. 				

    14007. 

  14007. 			

    14008. 

  14008. 			

    14009. 

  14009. 			

    14010. 

  14010. 			public interface I {

    14011. 

  14011. 			  void M();

    14012. 

  14012. 			}

    14013. 

  14013. 			

    14014. 

  14014. 			public  class C : IEquatable<C>, I {

    14015. 

  14015. 			    void I.M() {

    14016. 

  14016. 			    }

    14017. 

  14017. 			

    14018. 

  14018. 			    public override bool Equals(object o) {

    14019. 

  14019. 			        return o is C && Equals((C) o);

    14020. 

  14020. 			    }

    14021. 

  14021. 			

    14022. 

  14022. 			    public bool Equals(C c) {

    14023. 

  14023. 			        return c != null;

    14024. 

  14024. 			    }

    14025. 

  14025. 			

    14026. 

  14026. 			    public override int GetHashCode() {

    14027. 

  14027. 			        return 0;

    14028. 

  14028. 			    }

    14029. 

  14029. 			}

    14030. 

  14030. 			

    14031. 

  14031. 			public  class D : C, IEquatable<D> {

    14032. 

  14032. 			    public int Val;

    14033. 

  14033. 			    public D() {

    14034. 

  14034. 			    }

    14035. 

  14035. 			    public D(int val) {

    14036. 

  14036. 			        Val = val;

    14037. 

  14037. 			    }

    14038. 

  14038. 			

    14039. 

  14039. 			    public override bool Equals(object o) {

    14040. 

  14040. 			        return o is D && Equals((D) o);

    14041. 

  14041. 			    }

    14042. 

  14042. 			

    14043. 

  14043. 			    public bool Equals(D d) {

    14044. 

  14044. 			        return d != null && d.Val == Val;

    14045. 

  14045. 			    }

    14046. 

  14046. 			

    14047. 

  14047. 			    public override int GetHashCode() {

    14048. 

  14048. 			        return Val;

    14049. 

  14049. 			    }

    14050. 

  14050. 			}

    14051. 

  14051. 			

    14052. 

  14052. 			public enum E {

    14053. 

  14053. 			  A=1, B=2

    14054. 

  14054. 			}

    14055. 

  14055. 			

    14056. 

  14056. 			public enum El : long {

    14057. 

  14057. 			  A, B, C

    14058. 

  14058. 			}

    14059. 

  14059. 			

    14060. 

  14060. 			public struct S : IEquatable<S> {

    14061. 

  14061. 			    public override bool Equals(object o) {

    14062. 

  14062. 			        return (o is S) && Equals((S) o);

    14063. 

  14063. 			    }

    14064. 

  14064. 			    public bool Equals(S other) {

    14065. 

  14065. 			        return true;

    14066. 

  14066. 			    }

    14067. 

  14067. 			    public override int GetHashCode() {

    14068. 

  14068. 			        return 0;

    14069. 

  14069. 			    }

    14070. 

  14070. 			}

    14071. 

  14071. 			

    14072. 

  14072. 			public struct Sp : IEquatable<Sp> {

    14073. 

  14073. 			    public Sp(int i, double d) {

    14074. 

  14074. 			        I = i;

    14075. 

  14075. 			        D = d;

    14076. 

  14076. 			    }

    14077. 

  14077. 			

    14078. 

  14078. 			    public int I;

    14079. 

  14079. 			    public double D;

    14080. 

  14080. 			

    14081. 

  14081. 			    public override bool Equals(object o) {

    14082. 

  14082. 			        return (o is Sp) && Equals((Sp) o);

    14083. 

  14083. 			    }

    14084. 

  14084. 			    public bool Equals(Sp other) {

    14085. 

  14085. 			        return other.I == I && other.D == D;

    14086. 

  14086. 			    }

    14087. 

  14087. 			    public override int GetHashCode() {

    14088. 

  14088. 			        return I.GetHashCode() ^ D.GetHashCode();

    14089. 

  14089. 			    }

    14090. 

  14090. 			}

    14091. 

  14091. 			

    14092. 

  14092. 			public struct Ss : IEquatable<Ss> {

    14093. 

  14093. 			    public Ss(S s) {

    14094. 

  14094. 			        Val = s;

    14095. 

  14095. 			    }

    14096. 

  14096. 			

    14097. 

  14097. 			    public S Val;

    14098. 

  14098. 			

    14099. 

  14099. 			    public override bool Equals(object o) {

    14100. 

  14100. 			        return (o is Ss) && Equals((Ss) o);

    14101. 

  14101. 			    }

    14102. 

  14102. 			    public bool Equals(Ss other) {

    14103. 

  14103. 			        return other.Val.Equals(Val);

    14104. 

  14104. 			    }

    14105. 

  14105. 			    public override int GetHashCode() {

    14106. 

  14106. 			        return Val.GetHashCode();

    14107. 

  14107. 			    }

    14108. 

  14108. 			}

    14109. 

  14109. 			

    14110. 

  14110. 			public struct Sc : IEquatable<Sc> {

    14111. 

  14111. 			    public Sc(string s) {

    14112. 

  14112. 			        S = s;

    14113. 

  14113. 			    }

    14114. 

  14114. 			

    14115. 

  14115. 			    public string S;

    14116. 

  14116. 			

    14117. 

  14117. 			    public override bool Equals(object o) {

    14118. 

  14118. 			        return (o is Sc) && Equals((Sc) o);

    14119. 

  14119. 			    }

    14120. 

  14120. 			    public bool Equals(Sc other) {

    14121. 

  14121. 			        return other.S == S;

    14122. 

  14122. 			    }

    14123. 

  14123. 			    public override int GetHashCode() {

    14124. 

  14124. 			        return S.GetHashCode();

    14125. 

  14125. 			    }

    14126. 

  14126. 			}

    14127. 

  14127. 			

    14128. 

  14128. 			public struct Scs : IEquatable<Scs> {

    14129. 

  14129. 			    public Scs(string s, S val) {

    14130. 

  14130. 			        S = s;

    14131. 

  14131. 			        Val = val;

    14132. 

  14132. 			    }

    14133. 

  14133. 			

    14134. 

  14134. 			    public string S;

    14135. 

  14135. 			    public S Val;

    14136. 

  14136. 			

    14137. 

  14137. 			    public override bool Equals(object o) {

    14138. 

  14138. 			        return (o is Scs) && Equals((Scs) o);

    14139. 

  14139. 			    }

    14140. 

  14140. 			    public bool Equals(Scs other) {

    14141. 

  14141. 			        return other.S == S && other.Val.Equals(Val);

    14142. 

  14142. 			    }

    14143. 

  14143. 			    public override int GetHashCode() {

    14144. 

  14144. 			        return S.GetHashCode() ^ Val.GetHashCode();

    14145. 

  14145. 			    }

    14146. 

  14146. 			}

    14147. 

  14147. 			

    14148. 

  14148. 		

    14149. 

  14149. 	}

    14150. 

  14150. 				

    14151. 

  14151. 				//-------- Scenario 1791

    14152. 

  14152. 				namespace Scenario1791{

    14153. 

  14153. 					

    14154. 

  14154. 					public class Test

    14155. 

  14155. 					{

    14156. 

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

    14157. 

  14157. 				    public static Expression check74_Scs___() {

    14158. 

  14158. 				       if(Main() != 0 ) {

    14159. 

  14159. 				           throw new Exception();

    14160. 

  14160. 				       } else { 

    14161. 

  14161. 				           return Expression.Constant(0);

    14162. 

  14162. 				       }

    14163. 

  14163. 				    }

    14164. 

  14164. 					public     static int Main()

    14165. 

  14165. 					    {

    14166. 

  14166. 					        Ext.StartCapture();

    14167. 

  14167. 					        bool success = false;

    14168. 

  14168. 					        try

    14169. 

  14169. 					        {

    14170. 

  14170. 					            success = check74<Scs>();

    14171. 

  14171. 					        }

    14172. 

  14172. 					        finally

    14173. 

  14173. 					        {

    14174. 

  14174. 					            Ext.StopCapture();

    14175. 

  14175. 					        }

    14176. 

  14176. 					        return success ? 0 : 1;

    14177. 

  14177. 					    }

    14178. 

  14178. 					

    14179. 

  14179. 					    static bool check74<Ts>() where Ts : struct {

    14180. 

  14180. 					        foreach (Ts[] val in new Ts[][] { null, new Ts[0], new Ts[] { default(Ts), new Ts() }, new Ts[100] }) {

    14181. 

  14181. 					            if (!check74<Ts>(val)) {

    14182. 

  14182. 					                return false;

    14183. 

  14183. 					            }

    14184. 

  14184. 					        }

    14185. 

  14185. 					        return true;

    14186. 

  14186. 					    }

    14187. 

  14187. 					

    14188. 

  14188. 					    static bool check74<Ts>(Ts[] val) where Ts : struct {

    14189. 

  14189. 					        Expression<Func<Ts[]>> e =

    14190. 

  14190. 					            Expression.Lambda<Func<Ts[]>>(

    14191. 

  14191. 					                Expression.Constant(val, typeof(Ts[])),

    14192. 

  14192. 					                new System.Collections.Generic.List<ParameterExpression>());

    14193. 

  14193. 					        Func<Ts[]> f = e.Compile();

    14194. 

  14194. 					        return object.Equals(f(), val);

    14195. 

  14195. 					    }

    14196. 

  14196. 					}

    14197. 

  14197. 				

    14198. 

  14198. 				

    14199. 

  14199. 				public  static class Ext {

    14200. 

  14200. 				    public static void StartCapture() {

    14201. 

  14201. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14202. 

  14202. 				//        m.Invoke(null, new object[] { "test.dll" });

    14203. 

  14203. 				    }

    14204. 

  14204. 				

    14205. 

  14205. 				    public static void StopCapture() {

    14206. 

  14206. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14207. 

  14207. 				//        m.Invoke(null, new object[0]);

    14208. 

  14208. 				    }

    14209. 

  14209. 				

    14210. 

  14210. 				    public static bool IsIntegralOrEnum(Type type) {

    14211. 

  14211. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14212. 

  14212. 				            case TypeCode.Byte:

    14213. 

  14213. 				            case TypeCode.SByte:

    14214. 

  14214. 				            case TypeCode.Int16:

    14215. 

  14215. 				            case TypeCode.Int32:

    14216. 

  14216. 				            case TypeCode.Int64:

    14217. 

  14217. 				            case TypeCode.UInt16:

    14218. 

  14218. 				            case TypeCode.UInt32:

    14219. 

  14219. 				            case TypeCode.UInt64:

    14220. 

  14220. 				                return true;

    14221. 

  14221. 				            default:

    14222. 

  14222. 				                return false;

    14223. 

  14223. 				        }

    14224. 

  14224. 				    }

    14225. 

  14225. 				

    14226. 

  14226. 				    public static bool IsFloating(Type type) {

    14227. 

  14227. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14228. 

  14228. 				            case TypeCode.Single:

    14229. 

  14229. 				            case TypeCode.Double:

    14230. 

  14230. 				                return true;

    14231. 

  14231. 				            default:

    14232. 

  14232. 				                return false;

    14233. 

  14233. 				        }

    14234. 

  14234. 				    }

    14235. 

  14235. 				

    14236. 

  14236. 				    public static Type GetNonNullableType(Type type) {

    14237. 

  14237. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    14238. 

  14238. 				                type.GetGenericArguments()[0] :

    14239. 

  14239. 				                type;

    14240. 

  14240. 				    }

    14241. 

  14241. 				}

    14242. 

  14242. 				

    14243. 

  14243. 			

    14244. 

  14244. 			

    14245. 

  14245. 			

    14246. 

  14246. 			public interface I {

    14247. 

  14247. 			  void M();

    14248. 

  14248. 			}

    14249. 

  14249. 			

    14250. 

  14250. 			public  class C : IEquatable<C>, I {

    14251. 

  14251. 			    void I.M() {

    14252. 

  14252. 			    }

    14253. 

  14253. 			

    14254. 

  14254. 			    public override bool Equals(object o) {

    14255. 

  14255. 			        return o is C && Equals((C) o);

    14256. 

  14256. 			    }

    14257. 

  14257. 			

    14258. 

  14258. 			    public bool Equals(C c) {

    14259. 

  14259. 			        return c != null;

    14260. 

  14260. 			    }

    14261. 

  14261. 			

    14262. 

  14262. 			    public override int GetHashCode() {

    14263. 

  14263. 			        return 0;

    14264. 

  14264. 			    }

    14265. 

  14265. 			}

    14266. 

  14266. 			

    14267. 

  14267. 			public  class D : C, IEquatable<D> {

    14268. 

  14268. 			    public int Val;

    14269. 

  14269. 			    public D() {

    14270. 

  14270. 			    }

    14271. 

  14271. 			    public D(int val) {

    14272. 

  14272. 			        Val = val;

    14273. 

  14273. 			    }

    14274. 

  14274. 			

    14275. 

  14275. 			    public override bool Equals(object o) {

    14276. 

  14276. 			        return o is D && Equals((D) o);

    14277. 

  14277. 			    }

    14278. 

  14278. 			

    14279. 

  14279. 			    public bool Equals(D d) {

    14280. 

  14280. 			        return d != null && d.Val == Val;

    14281. 

  14281. 			    }

    14282. 

  14282. 			

    14283. 

  14283. 			    public override int GetHashCode() {

    14284. 

  14284. 			        return Val;

    14285. 

  14285. 			    }

    14286. 

  14286. 			}

    14287. 

  14287. 			

    14288. 

  14288. 			public enum E {

    14289. 

  14289. 			  A=1, B=2

    14290. 

  14290. 			}

    14291. 

  14291. 			

    14292. 

  14292. 			public enum El : long {

    14293. 

  14293. 			  A, B, C

    14294. 

  14294. 			}

    14295. 

  14295. 			

    14296. 

  14296. 			public struct S : IEquatable<S> {

    14297. 

  14297. 			    public override bool Equals(object o) {

    14298. 

  14298. 			        return (o is S) && Equals((S) o);

    14299. 

  14299. 			    }

    14300. 

  14300. 			    public bool Equals(S other) {

    14301. 

  14301. 			        return true;

    14302. 

  14302. 			    }

    14303. 

  14303. 			    public override int GetHashCode() {

    14304. 

  14304. 			        return 0;

    14305. 

  14305. 			    }

    14306. 

  14306. 			}

    14307. 

  14307. 			

    14308. 

  14308. 			public struct Sp : IEquatable<Sp> {

    14309. 

  14309. 			    public Sp(int i, double d) {

    14310. 

  14310. 			        I = i;

    14311. 

  14311. 			        D = d;

    14312. 

  14312. 			    }

    14313. 

  14313. 			

    14314. 

  14314. 			    public int I;

    14315. 

  14315. 			    public double D;

    14316. 

  14316. 			

    14317. 

  14317. 			    public override bool Equals(object o) {

    14318. 

  14318. 			        return (o is Sp) && Equals((Sp) o);

    14319. 

  14319. 			    }

    14320. 

  14320. 			    public bool Equals(Sp other) {

    14321. 

  14321. 			        return other.I == I && other.D == D;

    14322. 

  14322. 			    }

    14323. 

  14323. 			    public override int GetHashCode() {

    14324. 

  14324. 			        return I.GetHashCode() ^ D.GetHashCode();

    14325. 

  14325. 			    }

    14326. 

  14326. 			}

    14327. 

  14327. 			

    14328. 

  14328. 			public struct Ss : IEquatable<Ss> {

    14329. 

  14329. 			    public Ss(S s) {

    14330. 

  14330. 			        Val = s;

    14331. 

  14331. 			    }

    14332. 

  14332. 			

    14333. 

  14333. 			    public S Val;

    14334. 

  14334. 			

    14335. 

  14335. 			    public override bool Equals(object o) {

    14336. 

  14336. 			        return (o is Ss) && Equals((Ss) o);

    14337. 

  14337. 			    }

    14338. 

  14338. 			    public bool Equals(Ss other) {

    14339. 

  14339. 			        return other.Val.Equals(Val);

    14340. 

  14340. 			    }

    14341. 

  14341. 			    public override int GetHashCode() {

    14342. 

  14342. 			        return Val.GetHashCode();

    14343. 

  14343. 			    }

    14344. 

  14344. 			}

    14345. 

  14345. 			

    14346. 

  14346. 			public struct Sc : IEquatable<Sc> {

    14347. 

  14347. 			    public Sc(string s) {

    14348. 

  14348. 			        S = s;

    14349. 

  14349. 			    }

    14350. 

  14350. 			

    14351. 

  14351. 			    public string S;

    14352. 

  14352. 			

    14353. 

  14353. 			    public override bool Equals(object o) {

    14354. 

  14354. 			        return (o is Sc) && Equals((Sc) o);

    14355. 

  14355. 			    }

    14356. 

  14356. 			    public bool Equals(Sc other) {

    14357. 

  14357. 			        return other.S == S;

    14358. 

  14358. 			    }

    14359. 

  14359. 			    public override int GetHashCode() {

    14360. 

  14360. 			        return S.GetHashCode();

    14361. 

  14361. 			    }

    14362. 

  14362. 			}

    14363. 

  14363. 			

    14364. 

  14364. 			public struct Scs : IEquatable<Scs> {

    14365. 

  14365. 			    public Scs(string s, S val) {

    14366. 

  14366. 			        S = s;

    14367. 

  14367. 			        Val = val;

    14368. 

  14368. 			    }

    14369. 

  14369. 			

    14370. 

  14370. 			    public string S;

    14371. 

  14371. 			    public S Val;

    14372. 

  14372. 			

    14373. 

  14373. 			    public override bool Equals(object o) {

    14374. 

  14374. 			        return (o is Scs) && Equals((Scs) o);

    14375. 

  14375. 			    }

    14376. 

  14376. 			    public bool Equals(Scs other) {

    14377. 

  14377. 			        return other.S == S && other.Val.Equals(Val);

    14378. 

  14378. 			    }

    14379. 

  14379. 			    public override int GetHashCode() {

    14380. 

  14380. 			        return S.GetHashCode() ^ Val.GetHashCode();

    14381. 

  14381. 			    }

    14382. 

  14382. 			}

    14383. 

  14383. 			

    14384. 

  14384. 		

    14385. 

  14385. 	}

    14386. 

  14386. 				

    14387. 

  14387. 				//-------- Scenario 1792

    14388. 

  14388. 				namespace Scenario1792{

    14389. 

  14389. 					

    14390. 

  14390. 					public class Test

    14391. 

  14391. 					{

    14392. 

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

    14393. 

  14393. 				    public static Expression check74_E___() {

    14394. 

  14394. 				       if(Main() != 0 ) {

    14395. 

  14395. 				           throw new Exception();

    14396. 

  14396. 				       } else { 

    14397. 

  14397. 				           return Expression.Constant(0);

    14398. 

  14398. 				       }

    14399. 

  14399. 				    }

    14400. 

  14400. 					public     static int Main()

    14401. 

  14401. 					    {

    14402. 

  14402. 					        Ext.StartCapture();

    14403. 

  14403. 					        bool success = false;

    14404. 

  14404. 					        try

    14405. 

  14405. 					        {

    14406. 

  14406. 					            success = check74<E>();

    14407. 

  14407. 					        }

    14408. 

  14408. 					        finally

    14409. 

  14409. 					        {

    14410. 

  14410. 					            Ext.StopCapture();

    14411. 

  14411. 					        }

    14412. 

  14412. 					        return success ? 0 : 1;

    14413. 

  14413. 					    }

    14414. 

  14414. 					

    14415. 

  14415. 					    static bool check74<Ts>() where Ts : struct {

    14416. 

  14416. 					        foreach (Ts[] val in new Ts[][] { null, new Ts[0], new Ts[] { default(Ts), new Ts() }, new Ts[100] }) {

    14417. 

  14417. 					            if (!check74<Ts>(val)) {

    14418. 

  14418. 					                return false;

    14419. 

  14419. 					            }

    14420. 

  14420. 					        }

    14421. 

  14421. 					        return true;

    14422. 

  14422. 					    }

    14423. 

  14423. 					

    14424. 

  14424. 					    static bool check74<Ts>(Ts[] val) where Ts : struct {

    14425. 

  14425. 					        Expression<Func<Ts[]>> e =

    14426. 

  14426. 					            Expression.Lambda<Func<Ts[]>>(

    14427. 

  14427. 					                Expression.Constant(val, typeof(Ts[])),

    14428. 

  14428. 					                new System.Collections.Generic.List<ParameterExpression>());

    14429. 

  14429. 					        Func<Ts[]> f = e.Compile();

    14430. 

  14430. 					        return object.Equals(f(), val);

    14431. 

  14431. 					    }

    14432. 

  14432. 					}

    14433. 

  14433. 				

    14434. 

  14434. 				

    14435. 

  14435. 				public  static class Ext {

    14436. 

  14436. 				    public static void StartCapture() {

    14437. 

  14437. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14438. 

  14438. 				//        m.Invoke(null, new object[] { "test.dll" });

    14439. 

  14439. 				    }

    14440. 

  14440. 				

    14441. 

  14441. 				    public static void StopCapture() {

    14442. 

  14442. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14443. 

  14443. 				//        m.Invoke(null, new object[0]);

    14444. 

  14444. 				    }

    14445. 

  14445. 				

    14446. 

  14446. 				    public static bool IsIntegralOrEnum(Type type) {

    14447. 

  14447. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14448. 

  14448. 				            case TypeCode.Byte:

    14449. 

  14449. 				            case TypeCode.SByte:

    14450. 

  14450. 				            case TypeCode.Int16:

    14451. 

  14451. 				            case TypeCode.Int32:

    14452. 

  14452. 				            case TypeCode.Int64:

    14453. 

  14453. 				            case TypeCode.UInt16:

    14454. 

  14454. 				            case TypeCode.UInt32:

    14455. 

  14455. 				            case TypeCode.UInt64:

    14456. 

  14456. 				                return true;

    14457. 

  14457. 				            default:

    14458. 

  14458. 				                return false;

    14459. 

  14459. 				        }

    14460. 

  14460. 				    }

    14461. 

  14461. 				

    14462. 

  14462. 				    public static bool IsFloating(Type type) {

    14463. 

  14463. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14464. 

  14464. 				            case TypeCode.Single:

    14465. 

  14465. 				            case TypeCode.Double:

    14466. 

  14466. 				                return true;

    14467. 

  14467. 				            default:

    14468. 

  14468. 				                return false;

    14469. 

  14469. 				        }

    14470. 

  14470. 				    }

    14471. 

  14471. 				

    14472. 

  14472. 				    public static Type GetNonNullableType(Type type) {

    14473. 

  14473. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    14474. 

  14474. 				                type.GetGenericArguments()[0] :

    14475. 

  14475. 				                type;

    14476. 

  14476. 				    }

    14477. 

  14477. 				}

    14478. 

  14478. 				

    14479. 

  14479. 			

    14480. 

  14480. 			

    14481. 

  14481. 			

    14482. 

  14482. 			public interface I {

    14483. 

  14483. 			  void M();

    14484. 

  14484. 			}

    14485. 

  14485. 			

    14486. 

  14486. 			public  class C : IEquatable<C>, I {

    14487. 

  14487. 			    void I.M() {

    14488. 

  14488. 			    }

    14489. 

  14489. 			

    14490. 

  14490. 			    public override bool Equals(object o) {

    14491. 

  14491. 			        return o is C && Equals((C) o);

    14492. 

  14492. 			    }

    14493. 

  14493. 			

    14494. 

  14494. 			    public bool Equals(C c) {

    14495. 

  14495. 			        return c != null;

    14496. 

  14496. 			    }

    14497. 

  14497. 			

    14498. 

  14498. 			    public override int GetHashCode() {

    14499. 

  14499. 			        return 0;

    14500. 

  14500. 			    }

    14501. 

  14501. 			}

    14502. 

  14502. 			

    14503. 

  14503. 			public  class D : C, IEquatable<D> {

    14504. 

  14504. 			    public int Val;

    14505. 

  14505. 			    public D() {

    14506. 

  14506. 			    }

    14507. 

  14507. 			    public D(int val) {

    14508. 

  14508. 			        Val = val;

    14509. 

  14509. 			    }

    14510. 

  14510. 			

    14511. 

  14511. 			    public override bool Equals(object o) {

    14512. 

  14512. 			        return o is D && Equals((D) o);

    14513. 

  14513. 			    }

    14514. 

  14514. 			

    14515. 

  14515. 			    public bool Equals(D d) {

    14516. 

  14516. 			        return d != null && d.Val == Val;

    14517. 

  14517. 			    }

    14518. 

  14518. 			

    14519. 

  14519. 			    public override int GetHashCode() {

    14520. 

  14520. 			        return Val;

    14521. 

  14521. 			    }

    14522. 

  14522. 			}

    14523. 

  14523. 			

    14524. 

  14524. 			public enum E {

    14525. 

  14525. 			  A=1, B=2

    14526. 

  14526. 			}

    14527. 

  14527. 			

    14528. 

  14528. 			public enum El : long {

    14529. 

  14529. 			  A, B, C

    14530. 

  14530. 			}

    14531. 

  14531. 			

    14532. 

  14532. 			public struct S : IEquatable<S> {

    14533. 

  14533. 			    public override bool Equals(object o) {

    14534. 

  14534. 			        return (o is S) && Equals((S) o);

    14535. 

  14535. 			    }

    14536. 

  14536. 			    public bool Equals(S other) {

    14537. 

  14537. 			        return true;

    14538. 

  14538. 			    }

    14539. 

  14539. 			    public override int GetHashCode() {

    14540. 

  14540. 			        return 0;

    14541. 

  14541. 			    }

    14542. 

  14542. 			}

    14543. 

  14543. 			

    14544. 

  14544. 			public struct Sp : IEquatable<Sp> {

    14545. 

  14545. 			    public Sp(int i, double d) {

    14546. 

  14546. 			        I = i;

    14547. 

  14547. 			        D = d;

    14548. 

  14548. 			    }

    14549. 

  14549. 			

    14550. 

  14550. 			    public int I;

    14551. 

  14551. 			    public double D;

    14552. 

  14552. 			

    14553. 

  14553. 			    public override bool Equals(object o) {

    14554. 

  14554. 			        return (o is Sp) && Equals((Sp) o);

    14555. 

  14555. 			    }

    14556. 

  14556. 			    public bool Equals(Sp other) {

    14557. 

  14557. 			        return other.I == I && other.D == D;

    14558. 

  14558. 			    }

    14559. 

  14559. 			    public override int GetHashCode() {

    14560. 

  14560. 			        return I.GetHashCode() ^ D.GetHashCode();

    14561. 

  14561. 			    }

    14562. 

  14562. 			}

    14563. 

  14563. 			

    14564. 

  14564. 			public struct Ss : IEquatable<Ss> {

    14565. 

  14565. 			    public Ss(S s) {

    14566. 

  14566. 			        Val = s;

    14567. 

  14567. 			    }

    14568. 

  14568. 			

    14569. 

  14569. 			    public S Val;

    14570. 

  14570. 			

    14571. 

  14571. 			    public override bool Equals(object o) {

    14572. 

  14572. 			        return (o is Ss) && Equals((Ss) o);

    14573. 

  14573. 			    }

    14574. 

  14574. 			    public bool Equals(Ss other) {

    14575. 

  14575. 			        return other.Val.Equals(Val);

    14576. 

  14576. 			    }

    14577. 

  14577. 			    public override int GetHashCode() {

    14578. 

  14578. 			        return Val.GetHashCode();

    14579. 

  14579. 			    }

    14580. 

  14580. 			}

    14581. 

  14581. 			

    14582. 

  14582. 			public struct Sc : IEquatable<Sc> {

    14583. 

  14583. 			    public Sc(string s) {

    14584. 

  14584. 			        S = s;

    14585. 

  14585. 			    }

    14586. 

  14586. 			

    14587. 

  14587. 			    public string S;

    14588. 

  14588. 			

    14589. 

  14589. 			    public override bool Equals(object o) {

    14590. 

  14590. 			        return (o is Sc) && Equals((Sc) o);

    14591. 

  14591. 			    }

    14592. 

  14592. 			    public bool Equals(Sc other) {

    14593. 

  14593. 			        return other.S == S;

    14594. 

  14594. 			    }

    14595. 

  14595. 			    public override int GetHashCode() {

    14596. 

  14596. 			        return S.GetHashCode();

    14597. 

  14597. 			    }

    14598. 

  14598. 			}

    14599. 

  14599. 			

    14600. 

  14600. 			public struct Scs : IEquatable<Scs> {

    14601. 

  14601. 			    public Scs(string s, S val) {

    14602. 

  14602. 			        S = s;

    14603. 

  14603. 			        Val = val;

    14604. 

  14604. 			    }

    14605. 

  14605. 			

    14606. 

  14606. 			    public string S;

    14607. 

  14607. 			    public S Val;

    14608. 

  14608. 			

    14609. 

  14609. 			    public override bool Equals(object o) {

    14610. 

  14610. 			        return (o is Scs) && Equals((Scs) o);

    14611. 

  14611. 			    }

    14612. 

  14612. 			    public bool Equals(Scs other) {

    14613. 

  14613. 			        return other.S == S && other.Val.Equals(Val);

    14614. 

  14614. 			    }

    14615. 

  14615. 			    public override int GetHashCode() {

    14616. 

  14616. 			        return S.GetHashCode() ^ Val.GetHashCode();

    14617. 

  14617. 			    }

    14618. 

  14618. 			}

    14619. 

  14619. 			

    14620. 

  14620. 		

    14621. 

  14621. 	}

    14622. 

  14622. 				

    14623. 

  14623. 				//-------- Scenario 1793

    14624. 

  14624. 				namespace Scenario1793{

    14625. 

  14625. 					

    14626. 

  14626. 					public class Test

    14627. 

  14627. 					{

    14628. 

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

    14629. 

  14629. 				    public static Expression check75__() {

    14630. 

  14630. 				       if(Main() != 0 ) {

    14631. 

  14631. 				           throw new Exception();

    14632. 

  14632. 				       } else { 

    14633. 

  14633. 				           return Expression.Constant(0);

    14634. 

  14634. 				       }

    14635. 

  14635. 				    }

    14636. 

  14636. 					public     static int Main()

    14637. 

  14637. 					    {

    14638. 

  14638. 					        Ext.StartCapture();

    14639. 

  14639. 					        bool success = false;

    14640. 

  14640. 					        try

    14641. 

  14641. 					        {

    14642. 

  14642. 					            success = check75();

    14643. 

  14643. 					        }

    14644. 

  14644. 					        finally

    14645. 

  14645. 					        {

    14646. 

  14646. 					            Ext.StopCapture();

    14647. 

  14647. 					        }

    14648. 

  14648. 					        return success ? 0 : 1;

    14649. 

  14649. 					    }

    14650. 

  14650. 					

    14651. 

  14651. 					    static bool check75() {

    14652. 

  14652. 					        foreach (E[] val in new E[][] { null, new E[0], new E[] { (E) 0, E.A, E.B, (E) int.MaxValue, (E) int.MinValue }, new E[100] }) {

    14653. 

  14653. 					            if (!check75(val)) {

    14654. 

  14654. 					                return false;

    14655. 

  14655. 					            }

    14656. 

  14656. 					        }

    14657. 

  14657. 					        return true;

    14658. 

  14658. 					    }

    14659. 

  14659. 					

    14660. 

  14660. 					    static bool check75(E[] val) {

    14661. 

  14661. 					        Expression<Func<E[]>> e =

    14662. 

  14662. 					            Expression.Lambda<Func<E[]>>(

    14663. 

  14663. 					                Expression.Constant(val, typeof(E[])),

    14664. 

  14664. 					                new System.Collections.Generic.List<ParameterExpression>());

    14665. 

  14665. 					        Func<E[]> f = e.Compile();

    14666. 

  14666. 					        return object.Equals(f(), val);

    14667. 

  14667. 					    }

    14668. 

  14668. 					}

    14669. 

  14669. 				

    14670. 

  14670. 				

    14671. 

  14671. 				public  static class Ext {

    14672. 

  14672. 				    public static void StartCapture() {

    14673. 

  14673. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14674. 

  14674. 				//        m.Invoke(null, new object[] { "test.dll" });

    14675. 

  14675. 				    }

    14676. 

  14676. 				

    14677. 

  14677. 				    public static void StopCapture() {

    14678. 

  14678. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14679. 

  14679. 				//        m.Invoke(null, new object[0]);

    14680. 

  14680. 				    }

    14681. 

  14681. 				

    14682. 

  14682. 				    public static bool IsIntegralOrEnum(Type type) {

    14683. 

  14683. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14684. 

  14684. 				            case TypeCode.Byte:

    14685. 

  14685. 				            case TypeCode.SByte:

    14686. 

  14686. 				            case TypeCode.Int16:

    14687. 

  14687. 				            case TypeCode.Int32:

    14688. 

  14688. 				            case TypeCode.Int64:

    14689. 

  14689. 				            case TypeCode.UInt16:

    14690. 

  14690. 				            case TypeCode.UInt32:

    14691. 

  14691. 				            case TypeCode.UInt64:

    14692. 

  14692. 				                return true;

    14693. 

  14693. 				            default:

    14694. 

  14694. 				                return false;

    14695. 

  14695. 				        }

    14696. 

  14696. 				    }

    14697. 

  14697. 				

    14698. 

  14698. 				    public static bool IsFloating(Type type) {

    14699. 

  14699. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14700. 

  14700. 				            case TypeCode.Single:

    14701. 

  14701. 				            case TypeCode.Double:

    14702. 

  14702. 				                return true;

    14703. 

  14703. 				            default:

    14704. 

  14704. 				                return false;

    14705. 

  14705. 				        }

    14706. 

  14706. 				    }

    14707. 

  14707. 				

    14708. 

  14708. 				    public static Type GetNonNullableType(Type type) {

    14709. 

  14709. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    14710. 

  14710. 				                type.GetGenericArguments()[0] :

    14711. 

  14711. 				                type;

    14712. 

  14712. 				    }

    14713. 

  14713. 				}

    14714. 

  14714. 				

    14715. 

  14715. 			

    14716. 

  14716. 			

    14717. 

  14717. 			

    14718. 

  14718. 			public interface I {

    14719. 

  14719. 			  void M();

    14720. 

  14720. 			}

    14721. 

  14721. 			

    14722. 

  14722. 			public  class C : IEquatable<C>, I {

    14723. 

  14723. 			    void I.M() {

    14724. 

  14724. 			    }

    14725. 

  14725. 			

    14726. 

  14726. 			    public override bool Equals(object o) {

    14727. 

  14727. 			        return o is C && Equals((C) o);

    14728. 

  14728. 			    }

    14729. 

  14729. 			

    14730. 

  14730. 			    public bool Equals(C c) {

    14731. 

  14731. 			        return c != null;

    14732. 

  14732. 			    }

    14733. 

  14733. 			

    14734. 

  14734. 			    public override int GetHashCode() {

    14735. 

  14735. 			        return 0;

    14736. 

  14736. 			    }

    14737. 

  14737. 			}

    14738. 

  14738. 			

    14739. 

  14739. 			public  class D : C, IEquatable<D> {

    14740. 

  14740. 			    public int Val;

    14741. 

  14741. 			    public D() {

    14742. 

  14742. 			    }

    14743. 

  14743. 			    public D(int val) {

    14744. 

  14744. 			        Val = val;

    14745. 

  14745. 			    }

    14746. 

  14746. 			

    14747. 

  14747. 			    public override bool Equals(object o) {

    14748. 

  14748. 			        return o is D && Equals((D) o);

    14749. 

  14749. 			    }

    14750. 

  14750. 			

    14751. 

  14751. 			    public bool Equals(D d) {

    14752. 

  14752. 			        return d != null && d.Val == Val;

    14753. 

  14753. 			    }

    14754. 

  14754. 			

    14755. 

  14755. 			    public override int GetHashCode() {

    14756. 

  14756. 			        return Val;

    14757. 

  14757. 			    }

    14758. 

  14758. 			}

    14759. 

  14759. 			

    14760. 

  14760. 			public enum E {

    14761. 

  14761. 			  A=1, B=2

    14762. 

  14762. 			}

    14763. 

  14763. 			

    14764. 

  14764. 			public enum El : long {

    14765. 

  14765. 			  A, B, C

    14766. 

  14766. 			}

    14767. 

  14767. 			

    14768. 

  14768. 			public struct S : IEquatable<S> {

    14769. 

  14769. 			    public override bool Equals(object o) {

    14770. 

  14770. 			        return (o is S) && Equals((S) o);

    14771. 

  14771. 			    }

    14772. 

  14772. 			    public bool Equals(S other) {

    14773. 

  14773. 			        return true;

    14774. 

  14774. 			    }

    14775. 

  14775. 			    public override int GetHashCode() {

    14776. 

  14776. 			        return 0;

    14777. 

  14777. 			    }

    14778. 

  14778. 			}

    14779. 

  14779. 			

    14780. 

  14780. 			public struct Sp : IEquatable<Sp> {

    14781. 

  14781. 			    public Sp(int i, double d) {

    14782. 

  14782. 			        I = i;

    14783. 

  14783. 			        D = d;

    14784. 

  14784. 			    }

    14785. 

  14785. 			

    14786. 

  14786. 			    public int I;

    14787. 

  14787. 			    public double D;

    14788. 

  14788. 			

    14789. 

  14789. 			    public override bool Equals(object o) {

    14790. 

  14790. 			        return (o is Sp) && Equals((Sp) o);

    14791. 

  14791. 			    }

    14792. 

  14792. 			    public bool Equals(Sp other) {

    14793. 

  14793. 			        return other.I == I && other.D == D;

    14794. 

  14794. 			    }

    14795. 

  14795. 			    public override int GetHashCode() {

    14796. 

  14796. 			        return I.GetHashCode() ^ D.GetHashCode();

    14797. 

  14797. 			    }

    14798. 

  14798. 			}

    14799. 

  14799. 			

    14800. 

  14800. 			public struct Ss : IEquatable<Ss> {

    14801. 

  14801. 			    public Ss(S s) {

    14802. 

  14802. 			        Val = s;

    14803. 

  14803. 			    }

    14804. 

  14804. 			

    14805. 

  14805. 			    public S Val;

    14806. 

  14806. 			

    14807. 

  14807. 			    public override bool Equals(object o) {

    14808. 

  14808. 			        return (o is Ss) && Equals((Ss) o);

    14809. 

  14809. 			    }

    14810. 

  14810. 			    public bool Equals(Ss other) {

    14811. 

  14811. 			        return other.Val.Equals(Val);

    14812. 

  14812. 			    }

    14813. 

  14813. 			    public override int GetHashCode() {

    14814. 

  14814. 			        return Val.GetHashCode();

    14815. 

  14815. 			    }

    14816. 

  14816. 			}

    14817. 

  14817. 			

    14818. 

  14818. 			public struct Sc : IEquatable<Sc> {

    14819. 

  14819. 			    public Sc(string s) {

    14820. 

  14820. 			        S = s;

    14821. 

  14821. 			    }

    14822. 

  14822. 			

    14823. 

  14823. 			    public string S;

    14824. 

  14824. 			

    14825. 

  14825. 			    public override bool Equals(object o) {

    14826. 

  14826. 			        return (o is Sc) && Equals((Sc) o);

    14827. 

  14827. 			    }

    14828. 

  14828. 			    public bool Equals(Sc other) {

    14829. 

  14829. 			        return other.S == S;

    14830. 

  14830. 			    }

    14831. 

  14831. 			    public override int GetHashCode() {

    14832. 

  14832. 			        return S.GetHashCode();

    14833. 

  14833. 			    }

    14834. 

  14834. 			}

    14835. 

  14835. 			

    14836. 

  14836. 			public struct Scs : IEquatable<Scs> {

    14837. 

  14837. 			    public Scs(string s, S val) {

    14838. 

  14838. 			        S = s;

    14839. 

  14839. 			        Val = val;

    14840. 

  14840. 			    }

    14841. 

  14841. 			

    14842. 

  14842. 			    public string S;

    14843. 

  14843. 			    public S Val;

    14844. 

  14844. 			

    14845. 

  14845. 			    public override bool Equals(object o) {

    14846. 

  14846. 			        return (o is Scs) && Equals((Scs) o);

    14847. 

  14847. 			    }

    14848. 

  14848. 			    public bool Equals(Scs other) {

    14849. 

  14849. 			        return other.S == S && other.Val.Equals(Val);

    14850. 

  14850. 			    }

    14851. 

  14851. 			    public override int GetHashCode() {

    14852. 

  14852. 			        return S.GetHashCode() ^ Val.GetHashCode();

    14853. 

  14853. 			    }

    14854. 

  14854. 			}

    14855. 

  14855. 			

    14856. 

  14856. 		

    14857. 

  14857. 	}

    14858. 

  14858. 				

    14859. 

  14859. 				//-------- Scenario 1794

    14860. 

  14860. 				namespace Scenario1794{

    14861. 

  14861. 					

    14862. 

  14862. 					public class Test

    14863. 

  14863. 					{

    14864. 

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

    14865. 

  14865. 				    public static Expression check76__() {

    14866. 

  14866. 				       if(Main() != 0 ) {

    14867. 

  14867. 				           throw new Exception();

    14868. 

  14868. 				       } else { 

    14869. 

  14869. 				           return Expression.Constant(0);

    14870. 

  14870. 				       }

    14871. 

  14871. 				    }

    14872. 

  14872. 					public     static int Main()

    14873. 

  14873. 					    {

    14874. 

  14874. 					        Ext.StartCapture();

    14875. 

  14875. 					        bool success = false;

    14876. 

  14876. 					        try

    14877. 

  14877. 					        {

    14878. 

  14878. 					            success = check76();

    14879. 

  14879. 					        }

    14880. 

  14880. 					        finally

    14881. 

  14881. 					        {

    14882. 

  14882. 					            Ext.StopCapture();

    14883. 

  14883. 					        }

    14884. 

  14884. 					        return success ? 0 : 1;

    14885. 

  14885. 					    }

    14886. 

  14886. 					

    14887. 

  14887. 					    static bool check76() {

    14888. 

  14888. 					        foreach (El[] val in new El[][] { null, new El[0], new El[] { (El) 0, El.A, El.B, (El) long.MaxValue, (El) long.MinValue }, new El[100] }) {

    14889. 

  14889. 					            if (!check76(val)) {

    14890. 

  14890. 					                return false;

    14891. 

  14891. 					            }

    14892. 

  14892. 					        }

    14893. 

  14893. 					        return true;

    14894. 

  14894. 					    }

    14895. 

  14895. 					

    14896. 

  14896. 					    static bool check76(El[] val) {

    14897. 

  14897. 					        Expression<Func<El[]>> e =

    14898. 

  14898. 					            Expression.Lambda<Func<El[]>>(

    14899. 

  14899. 					                Expression.Constant(val, typeof(El[])),

    14900. 

  14900. 					                new System.Collections.Generic.List<ParameterExpression>());

    14901. 

  14901. 					        Func<El[]> f = e.Compile();

    14902. 

  14902. 					        return object.Equals(f(), val);

    14903. 

  14903. 					    }

    14904. 

  14904. 					}

    14905. 

  14905. 				

    14906. 

  14906. 				

    14907. 

  14907. 				public  static class Ext {

    14908. 

  14908. 				    public static void StartCapture() {

    14909. 

  14909. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14910. 

  14910. 				//        m.Invoke(null, new object[] { "test.dll" });

    14911. 

  14911. 				    }

    14912. 

  14912. 				

    14913. 

  14913. 				    public static void StopCapture() {

    14914. 

  14914. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    14915. 

  14915. 				//        m.Invoke(null, new object[0]);

    14916. 

  14916. 				    }

    14917. 

  14917. 				

    14918. 

  14918. 				    public static bool IsIntegralOrEnum(Type type) {

    14919. 

  14919. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14920. 

  14920. 				            case TypeCode.Byte:

    14921. 

  14921. 				            case TypeCode.SByte:

    14922. 

  14922. 				            case TypeCode.Int16:

    14923. 

  14923. 				            case TypeCode.Int32:

    14924. 

  14924. 				            case TypeCode.Int64:

    14925. 

  14925. 				            case TypeCode.UInt16:

    14926. 

  14926. 				            case TypeCode.UInt32:

    14927. 

  14927. 				            case TypeCode.UInt64:

    14928. 

  14928. 				                return true;

    14929. 

  14929. 				            default:

    14930. 

  14930. 				                return false;

    14931. 

  14931. 				        }

    14932. 

  14932. 				    }

    14933. 

  14933. 				

    14934. 

  14934. 				    public static bool IsFloating(Type type) {

    14935. 

  14935. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    14936. 

  14936. 				            case TypeCode.Single:

    14937. 

  14937. 				            case TypeCode.Double:

    14938. 

  14938. 				                return true;

    14939. 

  14939. 				            default:

    14940. 

  14940. 				                return false;

    14941. 

  14941. 				        }

    14942. 

  14942. 				    }

    14943. 

  14943. 				

    14944. 

  14944. 				    public static Type GetNonNullableType(Type type) {

    14945. 

  14945. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    14946. 

  14946. 				                type.GetGenericArguments()[0] :

    14947. 

  14947. 				                type;

    14948. 

  14948. 				    }

    14949. 

  14949. 				}

    14950. 

  14950. 				

    14951. 

  14951. 			

    14952. 

  14952. 			

    14953. 

  14953. 			

    14954. 

  14954. 			public interface I {

    14955. 

  14955. 			  void M();

    14956. 

  14956. 			}

    14957. 

  14957. 			

    14958. 

  14958. 			public  class C : IEquatable<C>, I {

    14959. 

  14959. 			    void I.M() {

    14960. 

  14960. 			    }

    14961. 

  14961. 			

    14962. 

  14962. 			    public override bool Equals(object o) {

    14963. 

  14963. 			        return o is C && Equals((C) o);

    14964. 

  14964. 			    }

    14965. 

  14965. 			

    14966. 

  14966. 			    public bool Equals(C c) {

    14967. 

  14967. 			        return c != null;

    14968. 

  14968. 			    }

    14969. 

  14969. 			

    14970. 

  14970. 			    public override int GetHashCode() {

    14971. 

  14971. 			        return 0;

    14972. 

  14972. 			    }

    14973. 

  14973. 			}

    14974. 

  14974. 			

    14975. 

  14975. 			public  class D : C, IEquatable<D> {

    14976. 

  14976. 			    public int Val;

    14977. 

  14977. 			    public D() {

    14978. 

  14978. 			    }

    14979. 

  14979. 			    public D(int val) {

    14980. 

  14980. 			        Val = val;

    14981. 

  14981. 			    }

    14982. 

  14982. 			

    14983. 

  14983. 			    public override bool Equals(object o) {

    14984. 

  14984. 			        return o is D && Equals((D) o);

    14985. 

  14985. 			    }

    14986. 

  14986. 			

    14987. 

  14987. 			    public bool Equals(D d) {

    14988. 

  14988. 			        return d != null && d.Val == Val;

    14989. 

  14989. 			    }

    14990. 

  14990. 			

    14991. 

  14991. 			    public override int GetHashCode() {

    14992. 

  14992. 			        return Val;

    14993. 

  14993. 			    }

    14994. 

  14994. 			}

    14995. 

  14995. 			

    14996. 

  14996. 			public enum E {

    14997. 

  14997. 			  A=1, B=2

    14998. 

  14998. 			}

    14999. 

  14999. 			

    15000. 

  15000. 			public enum El : long {

    15001. 

  15001. 			  A, B, C

    15002. 

  15002. 			}

    15003. 

  15003. 			

    15004. 

  15004. 			public struct S : IEquatable<S> {

    15005. 

  15005. 			    public override bool Equals(object o) {

    15006. 

  15006. 			        return (o is S) && Equals((S) o);

    15007. 

  15007. 			    }

    15008. 

  15008. 			    public bool Equals(S other) {

    15009. 

  15009. 			        return true;

    15010. 

  15010. 			    }

    15011. 

  15011. 			    public override int GetHashCode() {

    15012. 

  15012. 			        return 0;

    15013. 

  15013. 			    }

    15014. 

  15014. 			}

    15015. 

  15015. 			

    15016. 

  15016. 			public struct Sp : IEquatable<Sp> {

    15017. 

  15017. 			    public Sp(int i, double d) {

    15018. 

  15018. 			        I = i;

    15019. 

  15019. 			        D = d;

    15020. 

  15020. 			    }

    15021. 

  15021. 			

    15022. 

  15022. 			    public int I;

    15023. 

  15023. 			    public double D;

    15024. 

  15024. 			

    15025. 

  15025. 			    public override bool Equals(object o) {

    15026. 

  15026. 			        return (o is Sp) && Equals((Sp) o);

    15027. 

  15027. 			    }

    15028. 

  15028. 			    public bool Equals(Sp other) {

    15029. 

  15029. 			        return other.I == I && other.D == D;

    15030. 

  15030. 			    }

    15031. 

  15031. 			    public override int GetHashCode() {

    15032. 

  15032. 			        return I.GetHashCode() ^ D.GetHashCode();

    15033. 

  15033. 			    }

    15034. 

  15034. 			}

    15035. 

  15035. 			

    15036. 

  15036. 			public struct Ss : IEquatable<Ss> {

    15037. 

  15037. 			    public Ss(S s) {

    15038. 

  15038. 			        Val = s;

    15039. 

  15039. 			    }

    15040. 

  15040. 			

    15041. 

  15041. 			    public S Val;

    15042. 

  15042. 			

    15043. 

  15043. 			    public override bool Equals(object o) {

    15044. 

  15044. 			        return (o is Ss) && Equals((Ss) o);

    15045. 

  15045. 			    }

    15046. 

  15046. 			    public bool Equals(Ss other) {

    15047. 

  15047. 			        return other.Val.Equals(Val);

    15048. 

  15048. 			    }

    15049. 

  15049. 			    public override int GetHashCode() {

    15050. 

  15050. 			        return Val.GetHashCode();

    15051. 

  15051. 			    }

    15052. 

  15052. 			}

    15053. 

  15053. 			

    15054. 

  15054. 			public struct Sc : IEquatable<Sc> {

    15055. 

  15055. 			    public Sc(string s) {

    15056. 

  15056. 			        S = s;

    15057. 

  15057. 			    }

    15058. 

  15058. 			

    15059. 

  15059. 			    public string S;

    15060. 

  15060. 			

    15061. 

  15061. 			    public override bool Equals(object o) {

    15062. 

  15062. 			        return (o is Sc) && Equals((Sc) o);

    15063. 

  15063. 			    }

    15064. 

  15064. 			    public bool Equals(Sc other) {

    15065. 

  15065. 			        return other.S == S;

    15066. 

  15066. 			    }

    15067. 

  15067. 			    public override int GetHashCode() {

    15068. 

  15068. 			        return S.GetHashCode();

    15069. 

  15069. 			    }

    15070. 

  15070. 			}

    15071. 

  15071. 			

    15072. 

  15072. 			public struct Scs : IEquatable<Scs> {

    15073. 

  15073. 			    public Scs(string s, S val) {

    15074. 

  15074. 			        S = s;

    15075. 

  15075. 			        Val = val;

    15076. 

  15076. 			    }

    15077. 

  15077. 			

    15078. 

  15078. 			    public string S;

    15079. 

  15079. 			    public S Val;

    15080. 

  15080. 			

    15081. 

  15081. 			    public override bool Equals(object o) {

    15082. 

  15082. 			        return (o is Scs) && Equals((Scs) o);

    15083. 

  15083. 			    }

    15084. 

  15084. 			    public bool Equals(Scs other) {

    15085. 

  15085. 			        return other.S == S && other.Val.Equals(Val);

    15086. 

  15086. 			    }

    15087. 

  15087. 			    public override int GetHashCode() {

    15088. 

  15088. 			        return S.GetHashCode() ^ Val.GetHashCode();

    15089. 

  15089. 			    }

    15090. 

  15090. 			}

    15091. 

  15091. 			

    15092. 

  15092. 		

    15093. 

  15093. 	}

    15094. 

  15094. 			

    15095. 

  15095. 			//-------- Scenario 1795

    15096. 

  15096. 			namespace Scenario1795{

    15097. 

  15097. 				

    15098. 

  15098. 				public class Test

    15099. 

  15099. 				{

    15100. 

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

    15101. 

  15101. 			    public static Expression check77__() {

    15102. 

  15102. 			       if(Main() != 0 ) {

    15103. 

  15103. 			           throw new Exception();

    15104. 

  15104. 			       } else { 

    15105. 

  15105. 			           return Expression.Constant(0);

    15106. 

  15106. 			       }

    15107. 

  15107. 			    }

    15108. 

  15108. 				public     static int Main()

    15109. 

  15109. 				    {

    15110. 

  15110. 				        Ext.StartCapture();

    15111. 

  15111. 				        bool success = false;

    15112. 

  15112. 				        try

    15113. 

  15113. 				        {

    15114. 

  15114. 				            success = check77();

    15115. 

  15115. 				        }

    15116. 

  15116. 				        finally

    15117. 

  15117. 				        {

    15118. 

  15118. 				            Ext.StopCapture();

    15119. 

  15119. 				        }

    15120. 

  15120. 				        return success ? 0 : 1;

    15121. 

  15121. 				    }

    15122. 

  15122. 				

    15123. 

  15123. 				    static bool check77() {

    15124. 

  15124. 				        foreach (string[] val in new string[][] { null, new string[0], new string[] { null, "", "a", "foo" }, new string[100] }) {

    15125. 

  15125. 				            if (!check77(val)) {

    15126. 

  15126. 				                return false;

    15127. 

  15127. 				            }

    15128. 

  15128. 				        }

    15129. 

  15129. 				        return true;

    15130. 

  15130. 				    }

    15131. 

  15131. 				

    15132. 

  15132. 				    static bool check77(string[] val) {

    15133. 

  15133. 				        Expression<Func<string[]>> e =

    15134. 

  15134. 				            Expression.Lambda<Func<string[]>>(

    15135. 

  15135. 				                Expression.Constant(val, typeof(string[])),

    15136. 

  15136. 				                new System.Collections.Generic.List<ParameterExpression>());

    15137. 

  15137. 				        Func<string[]> f = e.Compile();

    15138. 

  15138. 				        return object.Equals(f(), val);

    15139. 

  15139. 				    }

    15140. 

  15140. 				}

    15141. 

  15141. 			

    15142. 

  15142. 			

    15143. 

  15143. 			public  static class Ext {

    15144. 

  15144. 			    public static void StartCapture() {

    15145. 

  15145. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15146. 

  15146. 			//        m.Invoke(null, new object[] { "test.dll" });

    15147. 

  15147. 			    }

    15148. 

  15148. 			

    15149. 

  15149. 			    public static void StopCapture() {

    15150. 

  15150. 			//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15151. 

  15151. 			//        m.Invoke(null, new object[0]);

    15152. 

  15152. 			    }

    15153. 

  15153. 			

    15154. 

  15154. 			    public static bool IsIntegralOrEnum(Type type) {

    15155. 

  15155. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15156. 

  15156. 			            case TypeCode.Byte:

    15157. 

  15157. 			            case TypeCode.SByte:

    15158. 

  15158. 			            case TypeCode.Int16:

    15159. 

  15159. 			            case TypeCode.Int32:

    15160. 

  15160. 			            case TypeCode.Int64:

    15161. 

  15161. 			            case TypeCode.UInt16:

    15162. 

  15162. 			            case TypeCode.UInt32:

    15163. 

  15163. 			            case TypeCode.UInt64:

    15164. 

  15164. 			                return true;

    15165. 

  15165. 			            default:

    15166. 

  15166. 			                return false;

    15167. 

  15167. 			        }

    15168. 

  15168. 			    }

    15169. 

  15169. 			

    15170. 

  15170. 			    public static bool IsFloating(Type type) {

    15171. 

  15171. 			        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15172. 

  15172. 			            case TypeCode.Single:

    15173. 

  15173. 			            case TypeCode.Double:

    15174. 

  15174. 			                return true;

    15175. 

  15175. 			            default:

    15176. 

  15176. 			                return false;

    15177. 

  15177. 			        }

    15178. 

  15178. 			    }

    15179. 

  15179. 			

    15180. 

  15180. 			    public static Type GetNonNullableType(Type type) {

    15181. 

  15181. 			        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    15182. 

  15182. 			                type.GetGenericArguments()[0] :

    15183. 

  15183. 			                type;

    15184. 

  15184. 			    }

    15185. 

  15185. 			}

    15186. 

  15186. 			

    15187. 

  15187. 		

    15188. 

  15188. 	}

    15189. 

  15189. 				

    15190. 

  15190. 				//-------- Scenario 1796

    15191. 

  15191. 				namespace Scenario1796{

    15192. 

  15192. 					

    15193. 

  15193. 					public class Test

    15194. 

  15194. 					{

    15195. 

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

    15196. 

  15196. 				    public static Expression check78__() {

    15197. 

  15197. 				       if(Main() != 0 ) {

    15198. 

  15198. 				           throw new Exception();

    15199. 

  15199. 				       } else { 

    15200. 

  15200. 				           return Expression.Constant(0);

    15201. 

  15201. 				       }

    15202. 

  15202. 				    }

    15203. 

  15203. 					public     static int Main()

    15204. 

  15204. 					    {

    15205. 

  15205. 					        Ext.StartCapture();

    15206. 

  15206. 					        bool success = false;

    15207. 

  15207. 					        try

    15208. 

  15208. 					        {

    15209. 

  15209. 					            success = check78();

    15210. 

  15210. 					        }

    15211. 

  15211. 					        finally

    15212. 

  15212. 					        {

    15213. 

  15213. 					            Ext.StopCapture();

    15214. 

  15214. 					        }

    15215. 

  15215. 					        return success ? 0 : 1;

    15216. 

  15216. 					    }

    15217. 

  15217. 					

    15218. 

  15218. 					    static bool check78() {

    15219. 

  15219. 					        foreach (object[] val in new object[][] { null, new object[0], new object[] { null, new object(), new C(), new D(3) }, new object[100] }) {

    15220. 

  15220. 					            if (!check78(val)) {

    15221. 

  15221. 					                return false;

    15222. 

  15222. 					            }

    15223. 

  15223. 					        }

    15224. 

  15224. 					        return true;

    15225. 

  15225. 					    }

    15226. 

  15226. 					

    15227. 

  15227. 					    static bool check78(object[] val) {

    15228. 

  15228. 					        Expression<Func<object[]>> e =

    15229. 

  15229. 					            Expression.Lambda<Func<object[]>>(

    15230. 

  15230. 					                Expression.Constant(val, typeof(object[])),

    15231. 

  15231. 					                new System.Collections.Generic.List<ParameterExpression>());

    15232. 

  15232. 					        Func<object[]> f = e.Compile();

    15233. 

  15233. 					        return object.Equals(f(), val);

    15234. 

  15234. 					    }

    15235. 

  15235. 					}

    15236. 

  15236. 				

    15237. 

  15237. 				

    15238. 

  15238. 				public  static class Ext {

    15239. 

  15239. 				    public static void StartCapture() {

    15240. 

  15240. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15241. 

  15241. 				//        m.Invoke(null, new object[] { "test.dll" });

    15242. 

  15242. 				    }

    15243. 

  15243. 				

    15244. 

  15244. 				    public static void StopCapture() {

    15245. 

  15245. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15246. 

  15246. 				//        m.Invoke(null, new object[0]);

    15247. 

  15247. 				    }

    15248. 

  15248. 				

    15249. 

  15249. 				    public static bool IsIntegralOrEnum(Type type) {

    15250. 

  15250. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15251. 

  15251. 				            case TypeCode.Byte:

    15252. 

  15252. 				            case TypeCode.SByte:

    15253. 

  15253. 				            case TypeCode.Int16:

    15254. 

  15254. 				            case TypeCode.Int32:

    15255. 

  15255. 				            case TypeCode.Int64:

    15256. 

  15256. 				            case TypeCode.UInt16:

    15257. 

  15257. 				            case TypeCode.UInt32:

    15258. 

  15258. 				            case TypeCode.UInt64:

    15259. 

  15259. 				                return true;

    15260. 

  15260. 				            default:

    15261. 

  15261. 				                return false;

    15262. 

  15262. 				        }

    15263. 

  15263. 				    }

    15264. 

  15264. 				

    15265. 

  15265. 				    public static bool IsFloating(Type type) {

    15266. 

  15266. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15267. 

  15267. 				            case TypeCode.Single:

    15268. 

  15268. 				            case TypeCode.Double:

    15269. 

  15269. 				                return true;

    15270. 

  15270. 				            default:

    15271. 

  15271. 				                return false;

    15272. 

  15272. 				        }

    15273. 

  15273. 				    }

    15274. 

  15274. 				

    15275. 

  15275. 				    public static Type GetNonNullableType(Type type) {

    15276. 

  15276. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    15277. 

  15277. 				                type.GetGenericArguments()[0] :

    15278. 

  15278. 				                type;

    15279. 

  15279. 				    }

    15280. 

  15280. 				}

    15281. 

  15281. 				

    15282. 

  15282. 			

    15283. 

  15283. 			

    15284. 

  15284. 			

    15285. 

  15285. 			public interface I {

    15286. 

  15286. 			  void M();

    15287. 

  15287. 			}

    15288. 

  15288. 			

    15289. 

  15289. 			public  class C : IEquatable<C>, I {

    15290. 

  15290. 			    void I.M() {

    15291. 

  15291. 			    }

    15292. 

  15292. 			

    15293. 

  15293. 			    public override bool Equals(object o) {

    15294. 

  15294. 			        return o is C && Equals((C) o);

    15295. 

  15295. 			    }

    15296. 

  15296. 			

    15297. 

  15297. 			    public bool Equals(C c) {

    15298. 

  15298. 			        return c != null;

    15299. 

  15299. 			    }

    15300. 

  15300. 			

    15301. 

  15301. 			    public override int GetHashCode() {

    15302. 

  15302. 			        return 0;

    15303. 

  15303. 			    }

    15304. 

  15304. 			}

    15305. 

  15305. 			

    15306. 

  15306. 			public  class D : C, IEquatable<D> {

    15307. 

  15307. 			    public int Val;

    15308. 

  15308. 			    public D() {

    15309. 

  15309. 			    }

    15310. 

  15310. 			    public D(int val) {

    15311. 

  15311. 			        Val = val;

    15312. 

  15312. 			    }

    15313. 

  15313. 			

    15314. 

  15314. 			    public override bool Equals(object o) {

    15315. 

  15315. 			        return o is D && Equals((D) o);

    15316. 

  15316. 			    }

    15317. 

  15317. 			

    15318. 

  15318. 			    public bool Equals(D d) {

    15319. 

  15319. 			        return d != null && d.Val == Val;

    15320. 

  15320. 			    }

    15321. 

  15321. 			

    15322. 

  15322. 			    public override int GetHashCode() {

    15323. 

  15323. 			        return Val;

    15324. 

  15324. 			    }

    15325. 

  15325. 			}

    15326. 

  15326. 			

    15327. 

  15327. 			public enum E {

    15328. 

  15328. 			  A=1, B=2

    15329. 

  15329. 			}

    15330. 

  15330. 			

    15331. 

  15331. 			public enum El : long {

    15332. 

  15332. 			  A, B, C

    15333. 

  15333. 			}

    15334. 

  15334. 			

    15335. 

  15335. 			public struct S : IEquatable<S> {

    15336. 

  15336. 			    public override bool Equals(object o) {

    15337. 

  15337. 			        return (o is S) && Equals((S) o);

    15338. 

  15338. 			    }

    15339. 

  15339. 			    public bool Equals(S other) {

    15340. 

  15340. 			        return true;

    15341. 

  15341. 			    }

    15342. 

  15342. 			    public override int GetHashCode() {

    15343. 

  15343. 			        return 0;

    15344. 

  15344. 			    }

    15345. 

  15345. 			}

    15346. 

  15346. 			

    15347. 

  15347. 			public struct Sp : IEquatable<Sp> {

    15348. 

  15348. 			    public Sp(int i, double d) {

    15349. 

  15349. 			        I = i;

    15350. 

  15350. 			        D = d;

    15351. 

  15351. 			    }

    15352. 

  15352. 			

    15353. 

  15353. 			    public int I;

    15354. 

  15354. 			    public double D;

    15355. 

  15355. 			

    15356. 

  15356. 			    public override bool Equals(object o) {

    15357. 

  15357. 			        return (o is Sp) && Equals((Sp) o);

    15358. 

  15358. 			    }

    15359. 

  15359. 			    public bool Equals(Sp other) {

    15360. 

  15360. 			        return other.I == I && other.D == D;

    15361. 

  15361. 			    }

    15362. 

  15362. 			    public override int GetHashCode() {

    15363. 

  15363. 			        return I.GetHashCode() ^ D.GetHashCode();

    15364. 

  15364. 			    }

    15365. 

  15365. 			}

    15366. 

  15366. 			

    15367. 

  15367. 			public struct Ss : IEquatable<Ss> {

    15368. 

  15368. 			    public Ss(S s) {

    15369. 

  15369. 			        Val = s;

    15370. 

  15370. 			    }

    15371. 

  15371. 			

    15372. 

  15372. 			    public S Val;

    15373. 

  15373. 			

    15374. 

  15374. 			    public override bool Equals(object o) {

    15375. 

  15375. 			        return (o is Ss) && Equals((Ss) o);

    15376. 

  15376. 			    }

    15377. 

  15377. 			    public bool Equals(Ss other) {

    15378. 

  15378. 			        return other.Val.Equals(Val);

    15379. 

  15379. 			    }

    15380. 

  15380. 			    public override int GetHashCode() {

    15381. 

  15381. 			        return Val.GetHashCode();

    15382. 

  15382. 			    }

    15383. 

  15383. 			}

    15384. 

  15384. 			

    15385. 

  15385. 			public struct Sc : IEquatable<Sc> {

    15386. 

  15386. 			    public Sc(string s) {

    15387. 

  15387. 			        S = s;

    15388. 

  15388. 			    }

    15389. 

  15389. 			

    15390. 

  15390. 			    public string S;

    15391. 

  15391. 			

    15392. 

  15392. 			    public override bool Equals(object o) {

    15393. 

  15393. 			        return (o is Sc) && Equals((Sc) o);

    15394. 

  15394. 			    }

    15395. 

  15395. 			    public bool Equals(Sc other) {

    15396. 

  15396. 			        return other.S == S;

    15397. 

  15397. 			    }

    15398. 

  15398. 			    public override int GetHashCode() {

    15399. 

  15399. 			        return S.GetHashCode();

    15400. 

  15400. 			    }

    15401. 

  15401. 			}

    15402. 

  15402. 			

    15403. 

  15403. 			public struct Scs : IEquatable<Scs> {

    15404. 

  15404. 			    public Scs(string s, S val) {

    15405. 

  15405. 			        S = s;

    15406. 

  15406. 			        Val = val;

    15407. 

  15407. 			    }

    15408. 

  15408. 			

    15409. 

  15409. 			    public string S;

    15410. 

  15410. 			    public S Val;

    15411. 

  15411. 			

    15412. 

  15412. 			    public override bool Equals(object o) {

    15413. 

  15413. 			        return (o is Scs) && Equals((Scs) o);

    15414. 

  15414. 			    }

    15415. 

  15415. 			    public bool Equals(Scs other) {

    15416. 

  15416. 			        return other.S == S && other.Val.Equals(Val);

    15417. 

  15417. 			    }

    15418. 

  15418. 			    public override int GetHashCode() {

    15419. 

  15419. 			        return S.GetHashCode() ^ Val.GetHashCode();

    15420. 

  15420. 			    }

    15421. 

  15421. 			}

    15422. 

  15422. 			

    15423. 

  15423. 		

    15424. 

  15424. 	}

    15425. 

  15425. 				

    15426. 

  15426. 				//-------- Scenario 1797

    15427. 

  15427. 				namespace Scenario1797{

    15428. 

  15428. 					

    15429. 

  15429. 					public class Test

    15430. 

  15430. 					{

    15431. 

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

    15432. 

  15432. 				    public static Expression check79__() {

    15433. 

  15433. 				       if(Main() != 0 ) {

    15434. 

  15434. 				           throw new Exception();

    15435. 

  15435. 				       } else { 

    15436. 

  15436. 				           return Expression.Constant(0);

    15437. 

  15437. 				       }

    15438. 

  15438. 				    }

    15439. 

  15439. 					public     static int Main()

    15440. 

  15440. 					    {

    15441. 

  15441. 					        Ext.StartCapture();

    15442. 

  15442. 					        bool success = false;

    15443. 

  15443. 					        try

    15444. 

  15444. 					        {

    15445. 

  15445. 					            success = check79();

    15446. 

  15446. 					        }

    15447. 

  15447. 					        finally

    15448. 

  15448. 					        {

    15449. 

  15449. 					            Ext.StopCapture();

    15450. 

  15450. 					        }

    15451. 

  15451. 					        return success ? 0 : 1;

    15452. 

  15452. 					    }

    15453. 

  15453. 					

    15454. 

  15454. 					    static bool check79() {

    15455. 

  15455. 					        foreach (C[] val in new C[][] { null, new C[0], new C[] { null, new C(), new D(), new D(0), new D(5) }, new C[100] }) {

    15456. 

  15456. 					            if (!check79(val)) {

    15457. 

  15457. 					                return false;

    15458. 

  15458. 					            }

    15459. 

  15459. 					        }

    15460. 

  15460. 					        return true;

    15461. 

  15461. 					    }

    15462. 

  15462. 					

    15463. 

  15463. 					    static bool check79(C[] val) {

    15464. 

  15464. 					        Expression<Func<C[]>> e =

    15465. 

  15465. 					            Expression.Lambda<Func<C[]>>(

    15466. 

  15466. 					                Expression.Constant(val, typeof(C[])),

    15467. 

  15467. 					                new System.Collections.Generic.List<ParameterExpression>());

    15468. 

  15468. 					        Func<C[]> f = e.Compile();

    15469. 

  15469. 					        return object.Equals(f(), val);

    15470. 

  15470. 					    }

    15471. 

  15471. 					}

    15472. 

  15472. 				

    15473. 

  15473. 				

    15474. 

  15474. 				public  static class Ext {

    15475. 

  15475. 				    public static void StartCapture() {

    15476. 

  15476. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15477. 

  15477. 				//        m.Invoke(null, new object[] { "test.dll" });

    15478. 

  15478. 				    }

    15479. 

  15479. 				

    15480. 

  15480. 				    public static void StopCapture() {

    15481. 

  15481. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15482. 

  15482. 				//        m.Invoke(null, new object[0]);

    15483. 

  15483. 				    }

    15484. 

  15484. 				

    15485. 

  15485. 				    public static bool IsIntegralOrEnum(Type type) {

    15486. 

  15486. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15487. 

  15487. 				            case TypeCode.Byte:

    15488. 

  15488. 				            case TypeCode.SByte:

    15489. 

  15489. 				            case TypeCode.Int16:

    15490. 

  15490. 				            case TypeCode.Int32:

    15491. 

  15491. 				            case TypeCode.Int64:

    15492. 

  15492. 				            case TypeCode.UInt16:

    15493. 

  15493. 				            case TypeCode.UInt32:

    15494. 

  15494. 				            case TypeCode.UInt64:

    15495. 

  15495. 				                return true;

    15496. 

  15496. 				            default:

    15497. 

  15497. 				                return false;

    15498. 

  15498. 				        }

    15499. 

  15499. 				    }

    15500. 

  15500. 				

    15501. 

  15501. 				    public static bool IsFloating(Type type) {

    15502. 

  15502. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15503. 

  15503. 				            case TypeCode.Single:

    15504. 

  15504. 				            case TypeCode.Double:

    15505. 

  15505. 				                return true;

    15506. 

  15506. 				            default:

    15507. 

  15507. 				                return false;

    15508. 

  15508. 				        }

    15509. 

  15509. 				    }

    15510. 

  15510. 				

    15511. 

  15511. 				    public static Type GetNonNullableType(Type type) {

    15512. 

  15512. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    15513. 

  15513. 				                type.GetGenericArguments()[0] :

    15514. 

  15514. 				                type;

    15515. 

  15515. 				    }

    15516. 

  15516. 				}

    15517. 

  15517. 				

    15518. 

  15518. 			

    15519. 

  15519. 			

    15520. 

  15520. 			

    15521. 

  15521. 			public interface I {

    15522. 

  15522. 			  void M();

    15523. 

  15523. 			}

    15524. 

  15524. 			

    15525. 

  15525. 			public  class C : IEquatable<C>, I {

    15526. 

  15526. 			    void I.M() {

    15527. 

  15527. 			    }

    15528. 

  15528. 			

    15529. 

  15529. 			    public override bool Equals(object o) {

    15530. 

  15530. 			        return o is C && Equals((C) o);

    15531. 

  15531. 			    }

    15532. 

  15532. 			

    15533. 

  15533. 			    public bool Equals(C c) {

    15534. 

  15534. 			        return c != null;

    15535. 

  15535. 			    }

    15536. 

  15536. 			

    15537. 

  15537. 			    public override int GetHashCode() {

    15538. 

  15538. 			        return 0;

    15539. 

  15539. 			    }

    15540. 

  15540. 			}

    15541. 

  15541. 			

    15542. 

  15542. 			public  class D : C, IEquatable<D> {

    15543. 

  15543. 			    public int Val;

    15544. 

  15544. 			    public D() {

    15545. 

  15545. 			    }

    15546. 

  15546. 			    public D(int val) {

    15547. 

  15547. 			        Val = val;

    15548. 

  15548. 			    }

    15549. 

  15549. 			

    15550. 

  15550. 			    public override bool Equals(object o) {

    15551. 

  15551. 			        return o is D && Equals((D) o);

    15552. 

  15552. 			    }

    15553. 

  15553. 			

    15554. 

  15554. 			    public bool Equals(D d) {

    15555. 

  15555. 			        return d != null && d.Val == Val;

    15556. 

  15556. 			    }

    15557. 

  15557. 			

    15558. 

  15558. 			    public override int GetHashCode() {

    15559. 

  15559. 			        return Val;

    15560. 

  15560. 			    }

    15561. 

  15561. 			}

    15562. 

  15562. 			

    15563. 

  15563. 			public enum E {

    15564. 

  15564. 			  A=1, B=2

    15565. 

  15565. 			}

    15566. 

  15566. 			

    15567. 

  15567. 			public enum El : long {

    15568. 

  15568. 			  A, B, C

    15569. 

  15569. 			}

    15570. 

  15570. 			

    15571. 

  15571. 			public struct S : IEquatable<S> {

    15572. 

  15572. 			    public override bool Equals(object o) {

    15573. 

  15573. 			        return (o is S) && Equals((S) o);

    15574. 

  15574. 			    }

    15575. 

  15575. 			    public bool Equals(S other) {

    15576. 

  15576. 			        return true;

    15577. 

  15577. 			    }

    15578. 

  15578. 			    public override int GetHashCode() {

    15579. 

  15579. 			        return 0;

    15580. 

  15580. 			    }

    15581. 

  15581. 			}

    15582. 

  15582. 			

    15583. 

  15583. 			public struct Sp : IEquatable<Sp> {

    15584. 

  15584. 			    public Sp(int i, double d) {

    15585. 

  15585. 			        I = i;

    15586. 

  15586. 			        D = d;

    15587. 

  15587. 			    }

    15588. 

  15588. 			

    15589. 

  15589. 			    public int I;

    15590. 

  15590. 			    public double D;

    15591. 

  15591. 			

    15592. 

  15592. 			    public override bool Equals(object o) {

    15593. 

  15593. 			        return (o is Sp) && Equals((Sp) o);

    15594. 

  15594. 			    }

    15595. 

  15595. 			    public bool Equals(Sp other) {

    15596. 

  15596. 			        return other.I == I && other.D == D;

    15597. 

  15597. 			    }

    15598. 

  15598. 			    public override int GetHashCode() {

    15599. 

  15599. 			        return I.GetHashCode() ^ D.GetHashCode();

    15600. 

  15600. 			    }

    15601. 

  15601. 			}

    15602. 

  15602. 			

    15603. 

  15603. 			public struct Ss : IEquatable<Ss> {

    15604. 

  15604. 			    public Ss(S s) {

    15605. 

  15605. 			        Val = s;

    15606. 

  15606. 			    }

    15607. 

  15607. 			

    15608. 

  15608. 			    public S Val;

    15609. 

  15609. 			

    15610. 

  15610. 			    public override bool Equals(object o) {

    15611. 

  15611. 			        return (o is Ss) && Equals((Ss) o);

    15612. 

  15612. 			    }

    15613. 

  15613. 			    public bool Equals(Ss other) {

    15614. 

  15614. 			        return other.Val.Equals(Val);

    15615. 

  15615. 			    }

    15616. 

  15616. 			    public override int GetHashCode() {

    15617. 

  15617. 			        return Val.GetHashCode();

    15618. 

  15618. 			    }

    15619. 

  15619. 			}

    15620. 

  15620. 			

    15621. 

  15621. 			public struct Sc : IEquatable<Sc> {

    15622. 

  15622. 			    public Sc(string s) {

    15623. 

  15623. 			        S = s;

    15624. 

  15624. 			    }

    15625. 

  15625. 			

    15626. 

  15626. 			    public string S;

    15627. 

  15627. 			

    15628. 

  15628. 			    public override bool Equals(object o) {

    15629. 

  15629. 			        return (o is Sc) && Equals((Sc) o);

    15630. 

  15630. 			    }

    15631. 

  15631. 			    public bool Equals(Sc other) {

    15632. 

  15632. 			        return other.S == S;

    15633. 

  15633. 			    }

    15634. 

  15634. 			    public override int GetHashCode() {

    15635. 

  15635. 			        return S.GetHashCode();

    15636. 

  15636. 			    }

    15637. 

  15637. 			}

    15638. 

  15638. 			

    15639. 

  15639. 			public struct Scs : IEquatable<Scs> {

    15640. 

  15640. 			    public Scs(string s, S val) {

    15641. 

  15641. 			        S = s;

    15642. 

  15642. 			        Val = val;

    15643. 

  15643. 			    }

    15644. 

  15644. 			

    15645. 

  15645. 			    public string S;

    15646. 

  15646. 			    public S Val;

    15647. 

  15647. 			

    15648. 

  15648. 			    public override bool Equals(object o) {

    15649. 

  15649. 			        return (o is Scs) && Equals((Scs) o);

    15650. 

  15650. 			    }

    15651. 

  15651. 			    public bool Equals(Scs other) {

    15652. 

  15652. 			        return other.S == S && other.Val.Equals(Val);

    15653. 

  15653. 			    }

    15654. 

  15654. 			    public override int GetHashCode() {

    15655. 

  15655. 			        return S.GetHashCode() ^ Val.GetHashCode();

    15656. 

  15656. 			    }

    15657. 

  15657. 			}

    15658. 

  15658. 			

    15659. 

  15659. 		

    15660. 

  15660. 	}

    15661. 

  15661. 				

    15662. 

  15662. 				//-------- Scenario 1798

    15663. 

  15663. 				namespace Scenario1798{

    15664. 

  15664. 					

    15665. 

  15665. 					public class Test

    15666. 

  15666. 					{

    15667. 

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

    15668. 

  15668. 				    public static Expression check80__() {

    15669. 

  15669. 				       if(Main() != 0 ) {

    15670. 

  15670. 				           throw new Exception();

    15671. 

  15671. 				       } else { 

    15672. 

  15672. 				           return Expression.Constant(0);

    15673. 

  15673. 				       }

    15674. 

  15674. 				    }

    15675. 

  15675. 					public     static int Main()

    15676. 

  15676. 					    {

    15677. 

  15677. 					        Ext.StartCapture();

    15678. 

  15678. 					        bool success = false;

    15679. 

  15679. 					        try

    15680. 

  15680. 					        {

    15681. 

  15681. 					            success = check80();

    15682. 

  15682. 					        }

    15683. 

  15683. 					        finally

    15684. 

  15684. 					        {

    15685. 

  15685. 					            Ext.StopCapture();

    15686. 

  15686. 					        }

    15687. 

  15687. 					        return success ? 0 : 1;

    15688. 

  15688. 					    }

    15689. 

  15689. 					

    15690. 

  15690. 					    static bool check80() {

    15691. 

  15691. 					        foreach (D[] val in new D[][] { null, new D[0], new D[] { null, new D(), new D(0), new D(5) }, new D[100] }) {

    15692. 

  15692. 					            if (!check80(val)) {

    15693. 

  15693. 					                return false;

    15694. 

  15694. 					            }

    15695. 

  15695. 					        }

    15696. 

  15696. 					        return true;

    15697. 

  15697. 					    }

    15698. 

  15698. 					

    15699. 

  15699. 					    static bool check80(D[] val) {

    15700. 

  15700. 					        Expression<Func<D[]>> e =

    15701. 

  15701. 					            Expression.Lambda<Func<D[]>>(

    15702. 

  15702. 					                Expression.Constant(val, typeof(D[])),

    15703. 

  15703. 					                new System.Collections.Generic.List<ParameterExpression>());

    15704. 

  15704. 					        Func<D[]> f = e.Compile();

    15705. 

  15705. 					        return object.Equals(f(), val);

    15706. 

  15706. 					    }

    15707. 

  15707. 					}

    15708. 

  15708. 				

    15709. 

  15709. 				

    15710. 

  15710. 				public  static class Ext {

    15711. 

  15711. 				    public static void StartCapture() {

    15712. 

  15712. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15713. 

  15713. 				//        m.Invoke(null, new object[] { "test.dll" });

    15714. 

  15714. 				    }

    15715. 

  15715. 				

    15716. 

  15716. 				    public static void StopCapture() {

    15717. 

  15717. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15718. 

  15718. 				//        m.Invoke(null, new object[0]);

    15719. 

  15719. 				    }

    15720. 

  15720. 				

    15721. 

  15721. 				    public static bool IsIntegralOrEnum(Type type) {

    15722. 

  15722. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15723. 

  15723. 				            case TypeCode.Byte:

    15724. 

  15724. 				            case TypeCode.SByte:

    15725. 

  15725. 				            case TypeCode.Int16:

    15726. 

  15726. 				            case TypeCode.Int32:

    15727. 

  15727. 				            case TypeCode.Int64:

    15728. 

  15728. 				            case TypeCode.UInt16:

    15729. 

  15729. 				            case TypeCode.UInt32:

    15730. 

  15730. 				            case TypeCode.UInt64:

    15731. 

  15731. 				                return true;

    15732. 

  15732. 				            default:

    15733. 

  15733. 				                return false;

    15734. 

  15734. 				        }

    15735. 

  15735. 				    }

    15736. 

  15736. 				

    15737. 

  15737. 				    public static bool IsFloating(Type type) {

    15738. 

  15738. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15739. 

  15739. 				            case TypeCode.Single:

    15740. 

  15740. 				            case TypeCode.Double:

    15741. 

  15741. 				                return true;

    15742. 

  15742. 				            default:

    15743. 

  15743. 				                return false;

    15744. 

  15744. 				        }

    15745. 

  15745. 				    }

    15746. 

  15746. 				

    15747. 

  15747. 				    public static Type GetNonNullableType(Type type) {

    15748. 

  15748. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    15749. 

  15749. 				                type.GetGenericArguments()[0] :

    15750. 

  15750. 				                type;

    15751. 

  15751. 				    }

    15752. 

  15752. 				}

    15753. 

  15753. 				

    15754. 

  15754. 			

    15755. 

  15755. 			

    15756. 

  15756. 			

    15757. 

  15757. 			public interface I {

    15758. 

  15758. 			  void M();

    15759. 

  15759. 			}

    15760. 

  15760. 			

    15761. 

  15761. 			public  class C : IEquatable<C>, I {

    15762. 

  15762. 			    void I.M() {

    15763. 

  15763. 			    }

    15764. 

  15764. 			

    15765. 

  15765. 			    public override bool Equals(object o) {

    15766. 

  15766. 			        return o is C && Equals((C) o);

    15767. 

  15767. 			    }

    15768. 

  15768. 			

    15769. 

  15769. 			    public bool Equals(C c) {

    15770. 

  15770. 			        return c != null;

    15771. 

  15771. 			    }

    15772. 

  15772. 			

    15773. 

  15773. 			    public override int GetHashCode() {

    15774. 

  15774. 			        return 0;

    15775. 

  15775. 			    }

    15776. 

  15776. 			}

    15777. 

  15777. 			

    15778. 

  15778. 			public  class D : C, IEquatable<D> {

    15779. 

  15779. 			    public int Val;

    15780. 

  15780. 			    public D() {

    15781. 

  15781. 			    }

    15782. 

  15782. 			    public D(int val) {

    15783. 

  15783. 			        Val = val;

    15784. 

  15784. 			    }

    15785. 

  15785. 			

    15786. 

  15786. 			    public override bool Equals(object o) {

    15787. 

  15787. 			        return o is D && Equals((D) o);

    15788. 

  15788. 			    }

    15789. 

  15789. 			

    15790. 

  15790. 			    public bool Equals(D d) {

    15791. 

  15791. 			        return d != null && d.Val == Val;

    15792. 

  15792. 			    }

    15793. 

  15793. 			

    15794. 

  15794. 			    public override int GetHashCode() {

    15795. 

  15795. 			        return Val;

    15796. 

  15796. 			    }

    15797. 

  15797. 			}

    15798. 

  15798. 			

    15799. 

  15799. 			public enum E {

    15800. 

  15800. 			  A=1, B=2

    15801. 

  15801. 			}

    15802. 

  15802. 			

    15803. 

  15803. 			public enum El : long {

    15804. 

  15804. 			  A, B, C

    15805. 

  15805. 			}

    15806. 

  15806. 			

    15807. 

  15807. 			public struct S : IEquatable<S> {

    15808. 

  15808. 			    public override bool Equals(object o) {

    15809. 

  15809. 			        return (o is S) && Equals((S) o);

    15810. 

  15810. 			    }

    15811. 

  15811. 			    public bool Equals(S other) {

    15812. 

  15812. 			        return true;

    15813. 

  15813. 			    }

    15814. 

  15814. 			    public override int GetHashCode() {

    15815. 

  15815. 			        return 0;

    15816. 

  15816. 			    }

    15817. 

  15817. 			}

    15818. 

  15818. 			

    15819. 

  15819. 			public struct Sp : IEquatable<Sp> {

    15820. 

  15820. 			    public Sp(int i, double d) {

    15821. 

  15821. 			        I = i;

    15822. 

  15822. 			        D = d;

    15823. 

  15823. 			    }

    15824. 

  15824. 			

    15825. 

  15825. 			    public int I;

    15826. 

  15826. 			    public double D;

    15827. 

  15827. 			

    15828. 

  15828. 			    public override bool Equals(object o) {

    15829. 

  15829. 			        return (o is Sp) && Equals((Sp) o);

    15830. 

  15830. 			    }

    15831. 

  15831. 			    public bool Equals(Sp other) {

    15832. 

  15832. 			        return other.I == I && other.D == D;

    15833. 

  15833. 			    }

    15834. 

  15834. 			    public override int GetHashCode() {

    15835. 

  15835. 			        return I.GetHashCode() ^ D.GetHashCode();

    15836. 

  15836. 			    }

    15837. 

  15837. 			}

    15838. 

  15838. 			

    15839. 

  15839. 			public struct Ss : IEquatable<Ss> {

    15840. 

  15840. 			    public Ss(S s) {

    15841. 

  15841. 			        Val = s;

    15842. 

  15842. 			    }

    15843. 

  15843. 			

    15844. 

  15844. 			    public S Val;

    15845. 

  15845. 			

    15846. 

  15846. 			    public override bool Equals(object o) {

    15847. 

  15847. 			        return (o is Ss) && Equals((Ss) o);

    15848. 

  15848. 			    }

    15849. 

  15849. 			    public bool Equals(Ss other) {

    15850. 

  15850. 			        return other.Val.Equals(Val);

    15851. 

  15851. 			    }

    15852. 

  15852. 			    public override int GetHashCode() {

    15853. 

  15853. 			        return Val.GetHashCode();

    15854. 

  15854. 			    }

    15855. 

  15855. 			}

    15856. 

  15856. 			

    15857. 

  15857. 			public struct Sc : IEquatable<Sc> {

    15858. 

  15858. 			    public Sc(string s) {

    15859. 

  15859. 			        S = s;

    15860. 

  15860. 			    }

    15861. 

  15861. 			

    15862. 

  15862. 			    public string S;

    15863. 

  15863. 			

    15864. 

  15864. 			    public override bool Equals(object o) {

    15865. 

  15865. 			        return (o is Sc) && Equals((Sc) o);

    15866. 

  15866. 			    }

    15867. 

  15867. 			    public bool Equals(Sc other) {

    15868. 

  15868. 			        return other.S == S;

    15869. 

  15869. 			    }

    15870. 

  15870. 			    public override int GetHashCode() {

    15871. 

  15871. 			        return S.GetHashCode();

    15872. 

  15872. 			    }

    15873. 

  15873. 			}

    15874. 

  15874. 			

    15875. 

  15875. 			public struct Scs : IEquatable<Scs> {

    15876. 

  15876. 			    public Scs(string s, S val) {

    15877. 

  15877. 			        S = s;

    15878. 

  15878. 			        Val = val;

    15879. 

  15879. 			    }

    15880. 

  15880. 			

    15881. 

  15881. 			    public string S;

    15882. 

  15882. 			    public S Val;

    15883. 

  15883. 			

    15884. 

  15884. 			    public override bool Equals(object o) {

    15885. 

  15885. 			        return (o is Scs) && Equals((Scs) o);

    15886. 

  15886. 			    }

    15887. 

  15887. 			    public bool Equals(Scs other) {

    15888. 

  15888. 			        return other.S == S && other.Val.Equals(Val);

    15889. 

  15889. 			    }

    15890. 

  15890. 			    public override int GetHashCode() {

    15891. 

  15891. 			        return S.GetHashCode() ^ Val.GetHashCode();

    15892. 

  15892. 			    }

    15893. 

  15893. 			}

    15894. 

  15894. 			

    15895. 

  15895. 		

    15896. 

  15896. 	}

    15897. 

  15897. 				

    15898. 

  15898. 				//-------- Scenario 1799

    15899. 

  15899. 				namespace Scenario1799{

    15900. 

  15900. 					

    15901. 

  15901. 					public class Test

    15902. 

  15902. 					{

    15903. 

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

    15904. 

  15904. 				    public static Expression check81_object___() {

    15905. 

  15905. 				       if(Main() != 0 ) {

    15906. 

  15906. 				           throw new Exception();

    15907. 

  15907. 				       } else { 

    15908. 

  15908. 				           return Expression.Constant(0);

    15909. 

  15909. 				       }

    15910. 

  15910. 				    }

    15911. 

  15911. 					public     static int Main()

    15912. 

  15912. 					    {

    15913. 

  15913. 					        Ext.StartCapture();

    15914. 

  15914. 					        bool success = false;

    15915. 

  15915. 					        try

    15916. 

  15916. 					        {

    15917. 

  15917. 					            success = check81<object>();

    15918. 

  15918. 					        }

    15919. 

  15919. 					        finally

    15920. 

  15920. 					        {

    15921. 

  15921. 					            Ext.StopCapture();

    15922. 

  15922. 					        }

    15923. 

  15923. 					        return success ? 0 : 1;

    15924. 

  15924. 					    }

    15925. 

  15925. 					

    15926. 

  15926. 					    static bool check81<T>() {

    15927. 

  15927. 					        foreach (T[] val in new T[][] { null, new T[0], new T[] { default(T) }, new T[100] }) {

    15928. 

  15928. 					            if (!check81<T>(val)) {

    15929. 

  15929. 					                return false;

    15930. 

  15930. 					            }

    15931. 

  15931. 					        }

    15932. 

  15932. 					        return true;

    15933. 

  15933. 					    }

    15934. 

  15934. 					

    15935. 

  15935. 					    static bool check81<T>(T[] val) {

    15936. 

  15936. 					        Expression<Func<T[]>> e =

    15937. 

  15937. 					            Expression.Lambda<Func<T[]>>(

    15938. 

  15938. 					                Expression.Constant(val, typeof(T[])),

    15939. 

  15939. 					                new System.Collections.Generic.List<ParameterExpression>());

    15940. 

  15940. 					        Func<T[]> f = e.Compile();

    15941. 

  15941. 					        return object.Equals(f(), val);

    15942. 

  15942. 					    }

    15943. 

  15943. 					}

    15944. 

  15944. 				

    15945. 

  15945. 				

    15946. 

  15946. 				public  static class Ext {

    15947. 

  15947. 				    public static void StartCapture() {

    15948. 

  15948. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15949. 

  15949. 				//        m.Invoke(null, new object[] { "test.dll" });

    15950. 

  15950. 				    }

    15951. 

  15951. 				

    15952. 

  15952. 				    public static void StopCapture() {

    15953. 

  15953. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    15954. 

  15954. 				//        m.Invoke(null, new object[0]);

    15955. 

  15955. 				    }

    15956. 

  15956. 				

    15957. 

  15957. 				    public static bool IsIntegralOrEnum(Type type) {

    15958. 

  15958. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15959. 

  15959. 				            case TypeCode.Byte:

    15960. 

  15960. 				            case TypeCode.SByte:

    15961. 

  15961. 				            case TypeCode.Int16:

    15962. 

  15962. 				            case TypeCode.Int32:

    15963. 

  15963. 				            case TypeCode.Int64:

    15964. 

  15964. 				            case TypeCode.UInt16:

    15965. 

  15965. 				            case TypeCode.UInt32:

    15966. 

  15966. 				            case TypeCode.UInt64:

    15967. 

  15967. 				                return true;

    15968. 

  15968. 				            default:

    15969. 

  15969. 				                return false;

    15970. 

  15970. 				        }

    15971. 

  15971. 				    }

    15972. 

  15972. 				

    15973. 

  15973. 				    public static bool IsFloating(Type type) {

    15974. 

  15974. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    15975. 

  15975. 				            case TypeCode.Single:

    15976. 

  15976. 				            case TypeCode.Double:

    15977. 

  15977. 				                return true;

    15978. 

  15978. 				            default:

    15979. 

  15979. 				                return false;

    15980. 

  15980. 				        }

    15981. 

  15981. 				    }

    15982. 

  15982. 				

    15983. 

  15983. 				    public static Type GetNonNullableType(Type type) {

    15984. 

  15984. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    15985. 

  15985. 				                type.GetGenericArguments()[0] :

    15986. 

  15986. 				                type;

    15987. 

  15987. 				    }

    15988. 

  15988. 				}

    15989. 

  15989. 				

    15990. 

  15990. 			

    15991. 

  15991. 			

    15992. 

  15992. 			

    15993. 

  15993. 			public interface I {

    15994. 

  15994. 			  void M();

    15995. 

  15995. 			}

    15996. 

  15996. 			

    15997. 

  15997. 			public  class C : IEquatable<C>, I {

    15998. 

  15998. 			    void I.M() {

    15999. 

  15999. 			    }

    16000. 

  16000. 			

    16001. 

  16001. 			    public override bool Equals(object o) {

    16002. 

  16002. 			        return o is C && Equals((C) o);

    16003. 

  16003. 			    }

    16004. 

  16004. 			

    16005. 

  16005. 			    public bool Equals(C c) {

    16006. 

  16006. 			        return c != null;

    16007. 

  16007. 			    }

    16008. 

  16008. 			

    16009. 

  16009. 			    public override int GetHashCode() {

    16010. 

  16010. 			        return 0;

    16011. 

  16011. 			    }

    16012. 

  16012. 			}

    16013. 

  16013. 			

    16014. 

  16014. 			public  class D : C, IEquatable<D> {

    16015. 

  16015. 			    public int Val;

    16016. 

  16016. 			    public D() {

    16017. 

  16017. 			    }

    16018. 

  16018. 			    public D(int val) {

    16019. 

  16019. 			        Val = val;

    16020. 

  16020. 			    }

    16021. 

  16021. 			

    16022. 

  16022. 			    public override bool Equals(object o) {

    16023. 

  16023. 			        return o is D && Equals((D) o);

    16024. 

  16024. 			    }

    16025. 

  16025. 			

    16026. 

  16026. 			    public bool Equals(D d) {

    16027. 

  16027. 			        return d != null && d.Val == Val;

    16028. 

  16028. 			    }

    16029. 

  16029. 			

    16030. 

  16030. 			    public override int GetHashCode() {

    16031. 

  16031. 			        return Val;

    16032. 

  16032. 			    }

    16033. 

  16033. 			}

    16034. 

  16034. 			

    16035. 

  16035. 			public enum E {

    16036. 

  16036. 			  A=1, B=2

    16037. 

  16037. 			}

    16038. 

  16038. 			

    16039. 

  16039. 			public enum El : long {

    16040. 

  16040. 			  A, B, C

    16041. 

  16041. 			}

    16042. 

  16042. 			

    16043. 

  16043. 			public struct S : IEquatable<S> {

    16044. 

  16044. 			    public override bool Equals(object o) {

    16045. 

  16045. 			        return (o is S) && Equals((S) o);

    16046. 

  16046. 			    }

    16047. 

  16047. 			    public bool Equals(S other) {

    16048. 

  16048. 			        return true;

    16049. 

  16049. 			    }

    16050. 

  16050. 			    public override int GetHashCode() {

    16051. 

  16051. 			        return 0;

    16052. 

  16052. 			    }

    16053. 

  16053. 			}

    16054. 

  16054. 			

    16055. 

  16055. 			public struct Sp : IEquatable<Sp> {

    16056. 

  16056. 			    public Sp(int i, double d) {

    16057. 

  16057. 			        I = i;

    16058. 

  16058. 			        D = d;

    16059. 

  16059. 			    }

    16060. 

  16060. 			

    16061. 

  16061. 			    public int I;

    16062. 

  16062. 			    public double D;

    16063. 

  16063. 			

    16064. 

  16064. 			    public override bool Equals(object o) {

    16065. 

  16065. 			        return (o is Sp) && Equals((Sp) o);

    16066. 

  16066. 			    }

    16067. 

  16067. 			    public bool Equals(Sp other) {

    16068. 

  16068. 			        return other.I == I && other.D == D;

    16069. 

  16069. 			    }

    16070. 

  16070. 			    public override int GetHashCode() {

    16071. 

  16071. 			        return I.GetHashCode() ^ D.GetHashCode();

    16072. 

  16072. 			    }

    16073. 

  16073. 			}

    16074. 

  16074. 			

    16075. 

  16075. 			public struct Ss : IEquatable<Ss> {

    16076. 

  16076. 			    public Ss(S s) {

    16077. 

  16077. 			        Val = s;

    16078. 

  16078. 			    }

    16079. 

  16079. 			

    16080. 

  16080. 			    public S Val;

    16081. 

  16081. 			

    16082. 

  16082. 			    public override bool Equals(object o) {

    16083. 

  16083. 			        return (o is Ss) && Equals((Ss) o);

    16084. 

  16084. 			    }

    16085. 

  16085. 			    public bool Equals(Ss other) {

    16086. 

  16086. 			        return other.Val.Equals(Val);

    16087. 

  16087. 			    }

    16088. 

  16088. 			    public override int GetHashCode() {

    16089. 

  16089. 			        return Val.GetHashCode();

    16090. 

  16090. 			    }

    16091. 

  16091. 			}

    16092. 

  16092. 			

    16093. 

  16093. 			public struct Sc : IEquatable<Sc> {

    16094. 

  16094. 			    public Sc(string s) {

    16095. 

  16095. 			        S = s;

    16096. 

  16096. 			    }

    16097. 

  16097. 			

    16098. 

  16098. 			    public string S;

    16099. 

  16099. 			

    16100. 

  16100. 			    public override bool Equals(object o) {

    16101. 

  16101. 			        return (o is Sc) && Equals((Sc) o);

    16102. 

  16102. 			    }

    16103. 

  16103. 			    public bool Equals(Sc other) {

    16104. 

  16104. 			        return other.S == S;

    16105. 

  16105. 			    }

    16106. 

  16106. 			    public override int GetHashCode() {

    16107. 

  16107. 			        return S.GetHashCode();

    16108. 

  16108. 			    }

    16109. 

  16109. 			}

    16110. 

  16110. 			

    16111. 

  16111. 			public struct Scs : IEquatable<Scs> {

    16112. 

  16112. 			    public Scs(string s, S val) {

    16113. 

  16113. 			        S = s;

    16114. 

  16114. 			        Val = val;

    16115. 

  16115. 			    }

    16116. 

  16116. 			

    16117. 

  16117. 			    public string S;

    16118. 

  16118. 			    public S Val;

    16119. 

  16119. 			

    16120. 

  16120. 			    public override bool Equals(object o) {

    16121. 

  16121. 			        return (o is Scs) && Equals((Scs) o);

    16122. 

  16122. 			    }

    16123. 

  16123. 			    public bool Equals(Scs other) {

    16124. 

  16124. 			        return other.S == S && other.Val.Equals(Val);

    16125. 

  16125. 			    }

    16126. 

  16126. 			    public override int GetHashCode() {

    16127. 

  16127. 			        return S.GetHashCode() ^ Val.GetHashCode();

    16128. 

  16128. 			    }

    16129. 

  16129. 			}

    16130. 

  16130. 			

    16131. 

  16131. 		

    16132. 

  16132. 	}

    16133. 

  16133. 				

    16134. 

  16134. 				//-------- Scenario 1800

    16135. 

  16135. 				namespace Scenario1800{

    16136. 

  16136. 					

    16137. 

  16137. 					public class Test

    16138. 

  16138. 					{

    16139. 

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

    16140. 

  16140. 				    public static Expression check81_C___() {

    16141. 

  16141. 				       if(Main() != 0 ) {

    16142. 

  16142. 				           throw new Exception();

    16143. 

  16143. 				       } else { 

    16144. 

  16144. 				           return Expression.Constant(0);

    16145. 

  16145. 				       }

    16146. 

  16146. 				    }

    16147. 

  16147. 					public     static int Main()

    16148. 

  16148. 					    {

    16149. 

  16149. 					        Ext.StartCapture();

    16150. 

  16150. 					        bool success = false;

    16151. 

  16151. 					        try

    16152. 

  16152. 					        {

    16153. 

  16153. 					            success = check81<C>();

    16154. 

  16154. 					        }

    16155. 

  16155. 					        finally

    16156. 

  16156. 					        {

    16157. 

  16157. 					            Ext.StopCapture();

    16158. 

  16158. 					        }

    16159. 

  16159. 					        return success ? 0 : 1;

    16160. 

  16160. 					    }

    16161. 

  16161. 					

    16162. 

  16162. 					    static bool check81<T>() {

    16163. 

  16163. 					        foreach (T[] val in new T[][] { null, new T[0], new T[] { default(T) }, new T[100] }) {

    16164. 

  16164. 					            if (!check81<T>(val)) {

    16165. 

  16165. 					                return false;

    16166. 

  16166. 					            }

    16167. 

  16167. 					        }

    16168. 

  16168. 					        return true;

    16169. 

  16169. 					    }

    16170. 

  16170. 					

    16171. 

  16171. 					    static bool check81<T>(T[] val) {

    16172. 

  16172. 					        Expression<Func<T[]>> e =

    16173. 

  16173. 					            Expression.Lambda<Func<T[]>>(

    16174. 

  16174. 					                Expression.Constant(val, typeof(T[])),

    16175. 

  16175. 					                new System.Collections.Generic.List<ParameterExpression>());

    16176. 

  16176. 					        Func<T[]> f = e.Compile();

    16177. 

  16177. 					        return object.Equals(f(), val);

    16178. 

  16178. 					    }

    16179. 

  16179. 					}

    16180. 

  16180. 				

    16181. 

  16181. 				

    16182. 

  16182. 				public  static class Ext {

    16183. 

  16183. 				    public static void StartCapture() {

    16184. 

  16184. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16185. 

  16185. 				//        m.Invoke(null, new object[] { "test.dll" });

    16186. 

  16186. 				    }

    16187. 

  16187. 				

    16188. 

  16188. 				    public static void StopCapture() {

    16189. 

  16189. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16190. 

  16190. 				//        m.Invoke(null, new object[0]);

    16191. 

  16191. 				    }

    16192. 

  16192. 				

    16193. 

  16193. 				    public static bool IsIntegralOrEnum(Type type) {

    16194. 

  16194. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16195. 

  16195. 				            case TypeCode.Byte:

    16196. 

  16196. 				            case TypeCode.SByte:

    16197. 

  16197. 				            case TypeCode.Int16:

    16198. 

  16198. 				            case TypeCode.Int32:

    16199. 

  16199. 				            case TypeCode.Int64:

    16200. 

  16200. 				            case TypeCode.UInt16:

    16201. 

  16201. 				            case TypeCode.UInt32:

    16202. 

  16202. 				            case TypeCode.UInt64:

    16203. 

  16203. 				                return true;

    16204. 

  16204. 				            default:

    16205. 

  16205. 				                return false;

    16206. 

  16206. 				        }

    16207. 

  16207. 				    }

    16208. 

  16208. 				

    16209. 

  16209. 				    public static bool IsFloating(Type type) {

    16210. 

  16210. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16211. 

  16211. 				            case TypeCode.Single:

    16212. 

  16212. 				            case TypeCode.Double:

    16213. 

  16213. 				                return true;

    16214. 

  16214. 				            default:

    16215. 

  16215. 				                return false;

    16216. 

  16216. 				        }

    16217. 

  16217. 				    }

    16218. 

  16218. 				

    16219. 

  16219. 				    public static Type GetNonNullableType(Type type) {

    16220. 

  16220. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    16221. 

  16221. 				                type.GetGenericArguments()[0] :

    16222. 

  16222. 				                type;

    16223. 

  16223. 				    }

    16224. 

  16224. 				}

    16225. 

  16225. 				

    16226. 

  16226. 			

    16227. 

  16227. 			

    16228. 

  16228. 			

    16229. 

  16229. 			public interface I {

    16230. 

  16230. 			  void M();

    16231. 

  16231. 			}

    16232. 

  16232. 			

    16233. 

  16233. 			public  class C : IEquatable<C>, I {

    16234. 

  16234. 			    void I.M() {

    16235. 

  16235. 			    }

    16236. 

  16236. 			

    16237. 

  16237. 			    public override bool Equals(object o) {

    16238. 

  16238. 			        return o is C && Equals((C) o);

    16239. 

  16239. 			    }

    16240. 

  16240. 			

    16241. 

  16241. 			    public bool Equals(C c) {

    16242. 

  16242. 			        return c != null;

    16243. 

  16243. 			    }

    16244. 

  16244. 			

    16245. 

  16245. 			    public override int GetHashCode() {

    16246. 

  16246. 			        return 0;

    16247. 

  16247. 			    }

    16248. 

  16248. 			}

    16249. 

  16249. 			

    16250. 

  16250. 			public  class D : C, IEquatable<D> {

    16251. 

  16251. 			    public int Val;

    16252. 

  16252. 			    public D() {

    16253. 

  16253. 			    }

    16254. 

  16254. 			    public D(int val) {

    16255. 

  16255. 			        Val = val;

    16256. 

  16256. 			    }

    16257. 

  16257. 			

    16258. 

  16258. 			    public override bool Equals(object o) {

    16259. 

  16259. 			        return o is D && Equals((D) o);

    16260. 

  16260. 			    }

    16261. 

  16261. 			

    16262. 

  16262. 			    public bool Equals(D d) {

    16263. 

  16263. 			        return d != null && d.Val == Val;

    16264. 

  16264. 			    }

    16265. 

  16265. 			

    16266. 

  16266. 			    public override int GetHashCode() {

    16267. 

  16267. 			        return Val;

    16268. 

  16268. 			    }

    16269. 

  16269. 			}

    16270. 

  16270. 			

    16271. 

  16271. 			public enum E {

    16272. 

  16272. 			  A=1, B=2

    16273. 

  16273. 			}

    16274. 

  16274. 			

    16275. 

  16275. 			public enum El : long {

    16276. 

  16276. 			  A, B, C

    16277. 

  16277. 			}

    16278. 

  16278. 			

    16279. 

  16279. 			public struct S : IEquatable<S> {

    16280. 

  16280. 			    public override bool Equals(object o) {

    16281. 

  16281. 			        return (o is S) && Equals((S) o);

    16282. 

  16282. 			    }

    16283. 

  16283. 			    public bool Equals(S other) {

    16284. 

  16284. 			        return true;

    16285. 

  16285. 			    }

    16286. 

  16286. 			    public override int GetHashCode() {

    16287. 

  16287. 			        return 0;

    16288. 

  16288. 			    }

    16289. 

  16289. 			}

    16290. 

  16290. 			

    16291. 

  16291. 			public struct Sp : IEquatable<Sp> {

    16292. 

  16292. 			    public Sp(int i, double d) {

    16293. 

  16293. 			        I = i;

    16294. 

  16294. 			        D = d;

    16295. 

  16295. 			    }

    16296. 

  16296. 			

    16297. 

  16297. 			    public int I;

    16298. 

  16298. 			    public double D;

    16299. 

  16299. 			

    16300. 

  16300. 			    public override bool Equals(object o) {

    16301. 

  16301. 			        return (o is Sp) && Equals((Sp) o);

    16302. 

  16302. 			    }

    16303. 

  16303. 			    public bool Equals(Sp other) {

    16304. 

  16304. 			        return other.I == I && other.D == D;

    16305. 

  16305. 			    }

    16306. 

  16306. 			    public override int GetHashCode() {

    16307. 

  16307. 			        return I.GetHashCode() ^ D.GetHashCode();

    16308. 

  16308. 			    }

    16309. 

  16309. 			}

    16310. 

  16310. 			

    16311. 

  16311. 			public struct Ss : IEquatable<Ss> {

    16312. 

  16312. 			    public Ss(S s) {

    16313. 

  16313. 			        Val = s;

    16314. 

  16314. 			    }

    16315. 

  16315. 			

    16316. 

  16316. 			    public S Val;

    16317. 

  16317. 			

    16318. 

  16318. 			    public override bool Equals(object o) {

    16319. 

  16319. 			        return (o is Ss) && Equals((Ss) o);

    16320. 

  16320. 			    }

    16321. 

  16321. 			    public bool Equals(Ss other) {

    16322. 

  16322. 			        return other.Val.Equals(Val);

    16323. 

  16323. 			    }

    16324. 

  16324. 			    public override int GetHashCode() {

    16325. 

  16325. 			        return Val.GetHashCode();

    16326. 

  16326. 			    }

    16327. 

  16327. 			}

    16328. 

  16328. 			

    16329. 

  16329. 			public struct Sc : IEquatable<Sc> {

    16330. 

  16330. 			    public Sc(string s) {

    16331. 

  16331. 			        S = s;

    16332. 

  16332. 			    }

    16333. 

  16333. 			

    16334. 

  16334. 			    public string S;

    16335. 

  16335. 			

    16336. 

  16336. 			    public override bool Equals(object o) {

    16337. 

  16337. 			        return (o is Sc) && Equals((Sc) o);

    16338. 

  16338. 			    }

    16339. 

  16339. 			    public bool Equals(Sc other) {

    16340. 

  16340. 			        return other.S == S;

    16341. 

  16341. 			    }

    16342. 

  16342. 			    public override int GetHashCode() {

    16343. 

  16343. 			        return S.GetHashCode();

    16344. 

  16344. 			    }

    16345. 

  16345. 			}

    16346. 

  16346. 			

    16347. 

  16347. 			public struct Scs : IEquatable<Scs> {

    16348. 

  16348. 			    public Scs(string s, S val) {

    16349. 

  16349. 			        S = s;

    16350. 

  16350. 			        Val = val;

    16351. 

  16351. 			    }

    16352. 

  16352. 			

    16353. 

  16353. 			    public string S;

    16354. 

  16354. 			    public S Val;

    16355. 

  16355. 			

    16356. 

  16356. 			    public override bool Equals(object o) {

    16357. 

  16357. 			        return (o is Scs) && Equals((Scs) o);

    16358. 

  16358. 			    }

    16359. 

  16359. 			    public bool Equals(Scs other) {

    16360. 

  16360. 			        return other.S == S && other.Val.Equals(Val);

    16361. 

  16361. 			    }

    16362. 

  16362. 			    public override int GetHashCode() {

    16363. 

  16363. 			        return S.GetHashCode() ^ Val.GetHashCode();

    16364. 

  16364. 			    }

    16365. 

  16365. 			}

    16366. 

  16366. 			

    16367. 

  16367. 		

    16368. 

  16368. 	}

    16369. 

  16369. 				

    16370. 

  16370. 				//-------- Scenario 1801

    16371. 

  16371. 				namespace Scenario1801{

    16372. 

  16372. 					

    16373. 

  16373. 					public class Test

    16374. 

  16374. 					{

    16375. 

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

    16376. 

  16376. 				    public static Expression check81_S___() {

    16377. 

  16377. 				       if(Main() != 0 ) {

    16378. 

  16378. 				           throw new Exception();

    16379. 

  16379. 				       } else { 

    16380. 

  16380. 				           return Expression.Constant(0);

    16381. 

  16381. 				       }

    16382. 

  16382. 				    }

    16383. 

  16383. 					public     static int Main()

    16384. 

  16384. 					    {

    16385. 

  16385. 					        Ext.StartCapture();

    16386. 

  16386. 					        bool success = false;

    16387. 

  16387. 					        try

    16388. 

  16388. 					        {

    16389. 

  16389. 					            success = check81<S>();

    16390. 

  16390. 					        }

    16391. 

  16391. 					        finally

    16392. 

  16392. 					        {

    16393. 

  16393. 					            Ext.StopCapture();

    16394. 

  16394. 					        }

    16395. 

  16395. 					        return success ? 0 : 1;

    16396. 

  16396. 					    }

    16397. 

  16397. 					

    16398. 

  16398. 					    static bool check81<T>() {

    16399. 

  16399. 					        foreach (T[] val in new T[][] { null, new T[0], new T[] { default(T) }, new T[100] }) {

    16400. 

  16400. 					            if (!check81<T>(val)) {

    16401. 

  16401. 					                return false;

    16402. 

  16402. 					            }

    16403. 

  16403. 					        }

    16404. 

  16404. 					        return true;

    16405. 

  16405. 					    }

    16406. 

  16406. 					

    16407. 

  16407. 					    static bool check81<T>(T[] val) {

    16408. 

  16408. 					        Expression<Func<T[]>> e =

    16409. 

  16409. 					            Expression.Lambda<Func<T[]>>(

    16410. 

  16410. 					                Expression.Constant(val, typeof(T[])),

    16411. 

  16411. 					                new System.Collections.Generic.List<ParameterExpression>());

    16412. 

  16412. 					        Func<T[]> f = e.Compile();

    16413. 

  16413. 					        return object.Equals(f(), val);

    16414. 

  16414. 					    }

    16415. 

  16415. 					}

    16416. 

  16416. 				

    16417. 

  16417. 				

    16418. 

  16418. 				public  static class Ext {

    16419. 

  16419. 				    public static void StartCapture() {

    16420. 

  16420. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16421. 

  16421. 				//        m.Invoke(null, new object[] { "test.dll" });

    16422. 

  16422. 				    }

    16423. 

  16423. 				

    16424. 

  16424. 				    public static void StopCapture() {

    16425. 

  16425. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16426. 

  16426. 				//        m.Invoke(null, new object[0]);

    16427. 

  16427. 				    }

    16428. 

  16428. 				

    16429. 

  16429. 				    public static bool IsIntegralOrEnum(Type type) {

    16430. 

  16430. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16431. 

  16431. 				            case TypeCode.Byte:

    16432. 

  16432. 				            case TypeCode.SByte:

    16433. 

  16433. 				            case TypeCode.Int16:

    16434. 

  16434. 				            case TypeCode.Int32:

    16435. 

  16435. 				            case TypeCode.Int64:

    16436. 

  16436. 				            case TypeCode.UInt16:

    16437. 

  16437. 				            case TypeCode.UInt32:

    16438. 

  16438. 				            case TypeCode.UInt64:

    16439. 

  16439. 				                return true;

    16440. 

  16440. 				            default:

    16441. 

  16441. 				                return false;

    16442. 

  16442. 				        }

    16443. 

  16443. 				    }

    16444. 

  16444. 				

    16445. 

  16445. 				    public static bool IsFloating(Type type) {

    16446. 

  16446. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16447. 

  16447. 				            case TypeCode.Single:

    16448. 

  16448. 				            case TypeCode.Double:

    16449. 

  16449. 				                return true;

    16450. 

  16450. 				            default:

    16451. 

  16451. 				                return false;

    16452. 

  16452. 				        }

    16453. 

  16453. 				    }

    16454. 

  16454. 				

    16455. 

  16455. 				    public static Type GetNonNullableType(Type type) {

    16456. 

  16456. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    16457. 

  16457. 				                type.GetGenericArguments()[0] :

    16458. 

  16458. 				                type;

    16459. 

  16459. 				    }

    16460. 

  16460. 				}

    16461. 

  16461. 				

    16462. 

  16462. 			

    16463. 

  16463. 			

    16464. 

  16464. 			

    16465. 

  16465. 			public interface I {

    16466. 

  16466. 			  void M();

    16467. 

  16467. 			}

    16468. 

  16468. 			

    16469. 

  16469. 			public  class C : IEquatable<C>, I {

    16470. 

  16470. 			    void I.M() {

    16471. 

  16471. 			    }

    16472. 

  16472. 			

    16473. 

  16473. 			    public override bool Equals(object o) {

    16474. 

  16474. 			        return o is C && Equals((C) o);

    16475. 

  16475. 			    }

    16476. 

  16476. 			

    16477. 

  16477. 			    public bool Equals(C c) {

    16478. 

  16478. 			        return c != null;

    16479. 

  16479. 			    }

    16480. 

  16480. 			

    16481. 

  16481. 			    public override int GetHashCode() {

    16482. 

  16482. 			        return 0;

    16483. 

  16483. 			    }

    16484. 

  16484. 			}

    16485. 

  16485. 			

    16486. 

  16486. 			public  class D : C, IEquatable<D> {

    16487. 

  16487. 			    public int Val;

    16488. 

  16488. 			    public D() {

    16489. 

  16489. 			    }

    16490. 

  16490. 			    public D(int val) {

    16491. 

  16491. 			        Val = val;

    16492. 

  16492. 			    }

    16493. 

  16493. 			

    16494. 

  16494. 			    public override bool Equals(object o) {

    16495. 

  16495. 			        return o is D && Equals((D) o);

    16496. 

  16496. 			    }

    16497. 

  16497. 			

    16498. 

  16498. 			    public bool Equals(D d) {

    16499. 

  16499. 			        return d != null && d.Val == Val;

    16500. 

  16500. 			    }

    16501. 

  16501. 			

    16502. 

  16502. 			    public override int GetHashCode() {

    16503. 

  16503. 			        return Val;

    16504. 

  16504. 			    }

    16505. 

  16505. 			}

    16506. 

  16506. 			

    16507. 

  16507. 			public enum E {

    16508. 

  16508. 			  A=1, B=2

    16509. 

  16509. 			}

    16510. 

  16510. 			

    16511. 

  16511. 			public enum El : long {

    16512. 

  16512. 			  A, B, C

    16513. 

  16513. 			}

    16514. 

  16514. 			

    16515. 

  16515. 			public struct S : IEquatable<S> {

    16516. 

  16516. 			    public override bool Equals(object o) {

    16517. 

  16517. 			        return (o is S) && Equals((S) o);

    16518. 

  16518. 			    }

    16519. 

  16519. 			    public bool Equals(S other) {

    16520. 

  16520. 			        return true;

    16521. 

  16521. 			    }

    16522. 

  16522. 			    public override int GetHashCode() {

    16523. 

  16523. 			        return 0;

    16524. 

  16524. 			    }

    16525. 

  16525. 			}

    16526. 

  16526. 			

    16527. 

  16527. 			public struct Sp : IEquatable<Sp> {

    16528. 

  16528. 			    public Sp(int i, double d) {

    16529. 

  16529. 			        I = i;

    16530. 

  16530. 			        D = d;

    16531. 

  16531. 			    }

    16532. 

  16532. 			

    16533. 

  16533. 			    public int I;

    16534. 

  16534. 			    public double D;

    16535. 

  16535. 			

    16536. 

  16536. 			    public override bool Equals(object o) {

    16537. 

  16537. 			        return (o is Sp) && Equals((Sp) o);

    16538. 

  16538. 			    }

    16539. 

  16539. 			    public bool Equals(Sp other) {

    16540. 

  16540. 			        return other.I == I && other.D == D;

    16541. 

  16541. 			    }

    16542. 

  16542. 			    public override int GetHashCode() {

    16543. 

  16543. 			        return I.GetHashCode() ^ D.GetHashCode();

    16544. 

  16544. 			    }

    16545. 

  16545. 			}

    16546. 

  16546. 			

    16547. 

  16547. 			public struct Ss : IEquatable<Ss> {

    16548. 

  16548. 			    public Ss(S s) {

    16549. 

  16549. 			        Val = s;

    16550. 

  16550. 			    }

    16551. 

  16551. 			

    16552. 

  16552. 			    public S Val;

    16553. 

  16553. 			

    16554. 

  16554. 			    public override bool Equals(object o) {

    16555. 

  16555. 			        return (o is Ss) && Equals((Ss) o);

    16556. 

  16556. 			    }

    16557. 

  16557. 			    public bool Equals(Ss other) {

    16558. 

  16558. 			        return other.Val.Equals(Val);

    16559. 

  16559. 			    }

    16560. 

  16560. 			    public override int GetHashCode() {

    16561. 

  16561. 			        return Val.GetHashCode();

    16562. 

  16562. 			    }

    16563. 

  16563. 			}

    16564. 

  16564. 			

    16565. 

  16565. 			public struct Sc : IEquatable<Sc> {

    16566. 

  16566. 			    public Sc(string s) {

    16567. 

  16567. 			        S = s;

    16568. 

  16568. 			    }

    16569. 

  16569. 			

    16570. 

  16570. 			    public string S;

    16571. 

  16571. 			

    16572. 

  16572. 			    public override bool Equals(object o) {

    16573. 

  16573. 			        return (o is Sc) && Equals((Sc) o);

    16574. 

  16574. 			    }

    16575. 

  16575. 			    public bool Equals(Sc other) {

    16576. 

  16576. 			        return other.S == S;

    16577. 

  16577. 			    }

    16578. 

  16578. 			    public override int GetHashCode() {

    16579. 

  16579. 			        return S.GetHashCode();

    16580. 

  16580. 			    }

    16581. 

  16581. 			}

    16582. 

  16582. 			

    16583. 

  16583. 			public struct Scs : IEquatable<Scs> {

    16584. 

  16584. 			    public Scs(string s, S val) {

    16585. 

  16585. 			        S = s;

    16586. 

  16586. 			        Val = val;

    16587. 

  16587. 			    }

    16588. 

  16588. 			

    16589. 

  16589. 			    public string S;

    16590. 

  16590. 			    public S Val;

    16591. 

  16591. 			

    16592. 

  16592. 			    public override bool Equals(object o) {

    16593. 

  16593. 			        return (o is Scs) && Equals((Scs) o);

    16594. 

  16594. 			    }

    16595. 

  16595. 			    public bool Equals(Scs other) {

    16596. 

  16596. 			        return other.S == S && other.Val.Equals(Val);

    16597. 

  16597. 			    }

    16598. 

  16598. 			    public override int GetHashCode() {

    16599. 

  16599. 			        return S.GetHashCode() ^ Val.GetHashCode();

    16600. 

  16600. 			    }

    16601. 

  16601. 			}

    16602. 

  16602. 			

    16603. 

  16603. 		

    16604. 

  16604. 	}

    16605. 

  16605. 				

    16606. 

  16606. 				//-------- Scenario 1802

    16607. 

  16607. 				namespace Scenario1802{

    16608. 

  16608. 					

    16609. 

  16609. 					public class Test

    16610. 

  16610. 					{

    16611. 

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

    16612. 

  16612. 				    public static Expression check81_Scs___() {

    16613. 

  16613. 				       if(Main() != 0 ) {

    16614. 

  16614. 				           throw new Exception();

    16615. 

  16615. 				       } else { 

    16616. 

  16616. 				           return Expression.Constant(0);

    16617. 

  16617. 				       }

    16618. 

  16618. 				    }

    16619. 

  16619. 					public     static int Main()

    16620. 

  16620. 					    {

    16621. 

  16621. 					        Ext.StartCapture();

    16622. 

  16622. 					        bool success = false;

    16623. 

  16623. 					        try

    16624. 

  16624. 					        {

    16625. 

  16625. 					            success = check81<Scs>();

    16626. 

  16626. 					        }

    16627. 

  16627. 					        finally

    16628. 

  16628. 					        {

    16629. 

  16629. 					            Ext.StopCapture();

    16630. 

  16630. 					        }

    16631. 

  16631. 					        return success ? 0 : 1;

    16632. 

  16632. 					    }

    16633. 

  16633. 					

    16634. 

  16634. 					    static bool check81<T>() {

    16635. 

  16635. 					        foreach (T[] val in new T[][] { null, new T[0], new T[] { default(T) }, new T[100] }) {

    16636. 

  16636. 					            if (!check81<T>(val)) {

    16637. 

  16637. 					                return false;

    16638. 

  16638. 					            }

    16639. 

  16639. 					        }

    16640. 

  16640. 					        return true;

    16641. 

  16641. 					    }

    16642. 

  16642. 					

    16643. 

  16643. 					    static bool check81<T>(T[] val) {

    16644. 

  16644. 					        Expression<Func<T[]>> e =

    16645. 

  16645. 					            Expression.Lambda<Func<T[]>>(

    16646. 

  16646. 					                Expression.Constant(val, typeof(T[])),

    16647. 

  16647. 					                new System.Collections.Generic.List<ParameterExpression>());

    16648. 

  16648. 					        Func<T[]> f = e.Compile();

    16649. 

  16649. 					        return object.Equals(f(), val);

    16650. 

  16650. 					    }

    16651. 

  16651. 					}

    16652. 

  16652. 				

    16653. 

  16653. 				

    16654. 

  16654. 				public  static class Ext {

    16655. 

  16655. 				    public static void StartCapture() {

    16656. 

  16656. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16657. 

  16657. 				//        m.Invoke(null, new object[] { "test.dll" });

    16658. 

  16658. 				    }

    16659. 

  16659. 				

    16660. 

  16660. 				    public static void StopCapture() {

    16661. 

  16661. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16662. 

  16662. 				//        m.Invoke(null, new object[0]);

    16663. 

  16663. 				    }

    16664. 

  16664. 				

    16665. 

  16665. 				    public static bool IsIntegralOrEnum(Type type) {

    16666. 

  16666. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16667. 

  16667. 				            case TypeCode.Byte:

    16668. 

  16668. 				            case TypeCode.SByte:

    16669. 

  16669. 				            case TypeCode.Int16:

    16670. 

  16670. 				            case TypeCode.Int32:

    16671. 

  16671. 				            case TypeCode.Int64:

    16672. 

  16672. 				            case TypeCode.UInt16:

    16673. 

  16673. 				            case TypeCode.UInt32:

    16674. 

  16674. 				            case TypeCode.UInt64:

    16675. 

  16675. 				                return true;

    16676. 

  16676. 				            default:

    16677. 

  16677. 				                return false;

    16678. 

  16678. 				        }

    16679. 

  16679. 				    }

    16680. 

  16680. 				

    16681. 

  16681. 				    public static bool IsFloating(Type type) {

    16682. 

  16682. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16683. 

  16683. 				            case TypeCode.Single:

    16684. 

  16684. 				            case TypeCode.Double:

    16685. 

  16685. 				                return true;

    16686. 

  16686. 				            default:

    16687. 

  16687. 				                return false;

    16688. 

  16688. 				        }

    16689. 

  16689. 				    }

    16690. 

  16690. 				

    16691. 

  16691. 				    public static Type GetNonNullableType(Type type) {

    16692. 

  16692. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    16693. 

  16693. 				                type.GetGenericArguments()[0] :

    16694. 

  16694. 				                type;

    16695. 

  16695. 				    }

    16696. 

  16696. 				}

    16697. 

  16697. 				

    16698. 

  16698. 			

    16699. 

  16699. 			

    16700. 

  16700. 			

    16701. 

  16701. 			public interface I {

    16702. 

  16702. 			  void M();

    16703. 

  16703. 			}

    16704. 

  16704. 			

    16705. 

  16705. 			public  class C : IEquatable<C>, I {

    16706. 

  16706. 			    void I.M() {

    16707. 

  16707. 			    }

    16708. 

  16708. 			

    16709. 

  16709. 			    public override bool Equals(object o) {

    16710. 

  16710. 			        return o is C && Equals((C) o);

    16711. 

  16711. 			    }

    16712. 

  16712. 			

    16713. 

  16713. 			    public bool Equals(C c) {

    16714. 

  16714. 			        return c != null;

    16715. 

  16715. 			    }

    16716. 

  16716. 			

    16717. 

  16717. 			    public override int GetHashCode() {

    16718. 

  16718. 			        return 0;

    16719. 

  16719. 			    }

    16720. 

  16720. 			}

    16721. 

  16721. 			

    16722. 

  16722. 			public  class D : C, IEquatable<D> {

    16723. 

  16723. 			    public int Val;

    16724. 

  16724. 			    public D() {

    16725. 

  16725. 			    }

    16726. 

  16726. 			    public D(int val) {

    16727. 

  16727. 			        Val = val;

    16728. 

  16728. 			    }

    16729. 

  16729. 			

    16730. 

  16730. 			    public override bool Equals(object o) {

    16731. 

  16731. 			        return o is D && Equals((D) o);

    16732. 

  16732. 			    }

    16733. 

  16733. 			

    16734. 

  16734. 			    public bool Equals(D d) {

    16735. 

  16735. 			        return d != null && d.Val == Val;

    16736. 

  16736. 			    }

    16737. 

  16737. 			

    16738. 

  16738. 			    public override int GetHashCode() {

    16739. 

  16739. 			        return Val;

    16740. 

  16740. 			    }

    16741. 

  16741. 			}

    16742. 

  16742. 			

    16743. 

  16743. 			public enum E {

    16744. 

  16744. 			  A=1, B=2

    16745. 

  16745. 			}

    16746. 

  16746. 			

    16747. 

  16747. 			public enum El : long {

    16748. 

  16748. 			  A, B, C

    16749. 

  16749. 			}

    16750. 

  16750. 			

    16751. 

  16751. 			public struct S : IEquatable<S> {

    16752. 

  16752. 			    public override bool Equals(object o) {

    16753. 

  16753. 			        return (o is S) && Equals((S) o);

    16754. 

  16754. 			    }

    16755. 

  16755. 			    public bool Equals(S other) {

    16756. 

  16756. 			        return true;

    16757. 

  16757. 			    }

    16758. 

  16758. 			    public override int GetHashCode() {

    16759. 

  16759. 			        return 0;

    16760. 

  16760. 			    }

    16761. 

  16761. 			}

    16762. 

  16762. 			

    16763. 

  16763. 			public struct Sp : IEquatable<Sp> {

    16764. 

  16764. 			    public Sp(int i, double d) {

    16765. 

  16765. 			        I = i;

    16766. 

  16766. 			        D = d;

    16767. 

  16767. 			    }

    16768. 

  16768. 			

    16769. 

  16769. 			    public int I;

    16770. 

  16770. 			    public double D;

    16771. 

  16771. 			

    16772. 

  16772. 			    public override bool Equals(object o) {

    16773. 

  16773. 			        return (o is Sp) && Equals((Sp) o);

    16774. 

  16774. 			    }

    16775. 

  16775. 			    public bool Equals(Sp other) {

    16776. 

  16776. 			        return other.I == I && other.D == D;

    16777. 

  16777. 			    }

    16778. 

  16778. 			    public override int GetHashCode() {

    16779. 

  16779. 			        return I.GetHashCode() ^ D.GetHashCode();

    16780. 

  16780. 			    }

    16781. 

  16781. 			}

    16782. 

  16782. 			

    16783. 

  16783. 			public struct Ss : IEquatable<Ss> {

    16784. 

  16784. 			    public Ss(S s) {

    16785. 

  16785. 			        Val = s;

    16786. 

  16786. 			    }

    16787. 

  16787. 			

    16788. 

  16788. 			    public S Val;

    16789. 

  16789. 			

    16790. 

  16790. 			    public override bool Equals(object o) {

    16791. 

  16791. 			        return (o is Ss) && Equals((Ss) o);

    16792. 

  16792. 			    }

    16793. 

  16793. 			    public bool Equals(Ss other) {

    16794. 

  16794. 			        return other.Val.Equals(Val);

    16795. 

  16795. 			    }

    16796. 

  16796. 			    public override int GetHashCode() {

    16797. 

  16797. 			        return Val.GetHashCode();

    16798. 

  16798. 			    }

    16799. 

  16799. 			}

    16800. 

  16800. 			

    16801. 

  16801. 			public struct Sc : IEquatable<Sc> {

    16802. 

  16802. 			    public Sc(string s) {

    16803. 

  16803. 			        S = s;

    16804. 

  16804. 			    }

    16805. 

  16805. 			

    16806. 

  16806. 			    public string S;

    16807. 

  16807. 			

    16808. 

  16808. 			    public override bool Equals(object o) {

    16809. 

  16809. 			        return (o is Sc) && Equals((Sc) o);

    16810. 

  16810. 			    }

    16811. 

  16811. 			    public bool Equals(Sc other) {

    16812. 

  16812. 			        return other.S == S;

    16813. 

  16813. 			    }

    16814. 

  16814. 			    public override int GetHashCode() {

    16815. 

  16815. 			        return S.GetHashCode();

    16816. 

  16816. 			    }

    16817. 

  16817. 			}

    16818. 

  16818. 			

    16819. 

  16819. 			public struct Scs : IEquatable<Scs> {

    16820. 

  16820. 			    public Scs(string s, S val) {

    16821. 

  16821. 			        S = s;

    16822. 

  16822. 			        Val = val;

    16823. 

  16823. 			    }

    16824. 

  16824. 			

    16825. 

  16825. 			    public string S;

    16826. 

  16826. 			    public S Val;

    16827. 

  16827. 			

    16828. 

  16828. 			    public override bool Equals(object o) {

    16829. 

  16829. 			        return (o is Scs) && Equals((Scs) o);

    16830. 

  16830. 			    }

    16831. 

  16831. 			    public bool Equals(Scs other) {

    16832. 

  16832. 			        return other.S == S && other.Val.Equals(Val);

    16833. 

  16833. 			    }

    16834. 

  16834. 			    public override int GetHashCode() {

    16835. 

  16835. 			        return S.GetHashCode() ^ Val.GetHashCode();

    16836. 

  16836. 			    }

    16837. 

  16837. 			}

    16838. 

  16838. 			

    16839. 

  16839. 		

    16840. 

  16840. 	}

    16841. 

  16841. 				

    16842. 

  16842. 				//-------- Scenario 1803

    16843. 

  16843. 				namespace Scenario1803{

    16844. 

  16844. 					

    16845. 

  16845. 					public class Test

    16846. 

  16846. 					{

    16847. 

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

    16848. 

  16848. 				    public static Expression check81_E___() {

    16849. 

  16849. 				       if(Main() != 0 ) {

    16850. 

  16850. 				           throw new Exception();

    16851. 

  16851. 				       } else { 

    16852. 

  16852. 				           return Expression.Constant(0);

    16853. 

  16853. 				       }

    16854. 

  16854. 				    }

    16855. 

  16855. 					public     static int Main()

    16856. 

  16856. 					    {

    16857. 

  16857. 					        Ext.StartCapture();

    16858. 

  16858. 					        bool success = false;

    16859. 

  16859. 					        try

    16860. 

  16860. 					        {

    16861. 

  16861. 					            success = check81<E>();

    16862. 

  16862. 					        }

    16863. 

  16863. 					        finally

    16864. 

  16864. 					        {

    16865. 

  16865. 					            Ext.StopCapture();

    16866. 

  16866. 					        }

    16867. 

  16867. 					        return success ? 0 : 1;

    16868. 

  16868. 					    }

    16869. 

  16869. 					

    16870. 

  16870. 					    static bool check81<T>() {

    16871. 

  16871. 					        foreach (T[] val in new T[][] { null, new T[0], new T[] { default(T) }, new T[100] }) {

    16872. 

  16872. 					            if (!check81<T>(val)) {

    16873. 

  16873. 					                return false;

    16874. 

  16874. 					            }

    16875. 

  16875. 					        }

    16876. 

  16876. 					        return true;

    16877. 

  16877. 					    }

    16878. 

  16878. 					

    16879. 

  16879. 					    static bool check81<T>(T[] val) {

    16880. 

  16880. 					        Expression<Func<T[]>> e =

    16881. 

  16881. 					            Expression.Lambda<Func<T[]>>(

    16882. 

  16882. 					                Expression.Constant(val, typeof(T[])),

    16883. 

  16883. 					                new System.Collections.Generic.List<ParameterExpression>());

    16884. 

  16884. 					        Func<T[]> f = e.Compile();

    16885. 

  16885. 					        return object.Equals(f(), val);

    16886. 

  16886. 					    }

    16887. 

  16887. 					}

    16888. 

  16888. 				

    16889. 

  16889. 				

    16890. 

  16890. 				public  static class Ext {

    16891. 

  16891. 				    public static void StartCapture() {

    16892. 

  16892. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16893. 

  16893. 				//        m.Invoke(null, new object[] { "test.dll" });

    16894. 

  16894. 				    }

    16895. 

  16895. 				

    16896. 

  16896. 				    public static void StopCapture() {

    16897. 

  16897. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    16898. 

  16898. 				//        m.Invoke(null, new object[0]);

    16899. 

  16899. 				    }

    16900. 

  16900. 				

    16901. 

  16901. 				    public static bool IsIntegralOrEnum(Type type) {

    16902. 

  16902. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16903. 

  16903. 				            case TypeCode.Byte:

    16904. 

  16904. 				            case TypeCode.SByte:

    16905. 

  16905. 				            case TypeCode.Int16:

    16906. 

  16906. 				            case TypeCode.Int32:

    16907. 

  16907. 				            case TypeCode.Int64:

    16908. 

  16908. 				            case TypeCode.UInt16:

    16909. 

  16909. 				            case TypeCode.UInt32:

    16910. 

  16910. 				            case TypeCode.UInt64:

    16911. 

  16911. 				                return true;

    16912. 

  16912. 				            default:

    16913. 

  16913. 				                return false;

    16914. 

  16914. 				        }

    16915. 

  16915. 				    }

    16916. 

  16916. 				

    16917. 

  16917. 				    public static bool IsFloating(Type type) {

    16918. 

  16918. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    16919. 

  16919. 				            case TypeCode.Single:

    16920. 

  16920. 				            case TypeCode.Double:

    16921. 

  16921. 				                return true;

    16922. 

  16922. 				            default:

    16923. 

  16923. 				                return false;

    16924. 

  16924. 				        }

    16925. 

  16925. 				    }

    16926. 

  16926. 				

    16927. 

  16927. 				    public static Type GetNonNullableType(Type type) {

    16928. 

  16928. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    16929. 

  16929. 				                type.GetGenericArguments()[0] :

    16930. 

  16930. 				                type;

    16931. 

  16931. 				    }

    16932. 

  16932. 				}

    16933. 

  16933. 				

    16934. 

  16934. 			

    16935. 

  16935. 			

    16936. 

  16936. 			

    16937. 

  16937. 			public interface I {

    16938. 

  16938. 			  void M();

    16939. 

  16939. 			}

    16940. 

  16940. 			

    16941. 

  16941. 			public  class C : IEquatable<C>, I {

    16942. 

  16942. 			    void I.M() {

    16943. 

  16943. 			    }

    16944. 

  16944. 			

    16945. 

  16945. 			    public override bool Equals(object o) {

    16946. 

  16946. 			        return o is C && Equals((C) o);

    16947. 

  16947. 			    }

    16948. 

  16948. 			

    16949. 

  16949. 			    public bool Equals(C c) {

    16950. 

  16950. 			        return c != null;

    16951. 

  16951. 			    }

    16952. 

  16952. 			

    16953. 

  16953. 			    public override int GetHashCode() {

    16954. 

  16954. 			        return 0;

    16955. 

  16955. 			    }

    16956. 

  16956. 			}

    16957. 

  16957. 			

    16958. 

  16958. 			public  class D : C, IEquatable<D> {

    16959. 

  16959. 			    public int Val;

    16960. 

  16960. 			    public D() {

    16961. 

  16961. 			    }

    16962. 

  16962. 			    public D(int val) {

    16963. 

  16963. 			        Val = val;

    16964. 

  16964. 			    }

    16965. 

  16965. 			

    16966. 

  16966. 			    public override bool Equals(object o) {

    16967. 

  16967. 			        return o is D && Equals((D) o);

    16968. 

  16968. 			    }

    16969. 

  16969. 			

    16970. 

  16970. 			    public bool Equals(D d) {

    16971. 

  16971. 			        return d != null && d.Val == Val;

    16972. 

  16972. 			    }

    16973. 

  16973. 			

    16974. 

  16974. 			    public override int GetHashCode() {

    16975. 

  16975. 			        return Val;

    16976. 

  16976. 			    }

    16977. 

  16977. 			}

    16978. 

  16978. 			

    16979. 

  16979. 			public enum E {

    16980. 

  16980. 			  A=1, B=2

    16981. 

  16981. 			}

    16982. 

  16982. 			

    16983. 

  16983. 			public enum El : long {

    16984. 

  16984. 			  A, B, C

    16985. 

  16985. 			}

    16986. 

  16986. 			

    16987. 

  16987. 			public struct S : IEquatable<S> {

    16988. 

  16988. 			    public override bool Equals(object o) {

    16989. 

  16989. 			        return (o is S) && Equals((S) o);

    16990. 

  16990. 			    }

    16991. 

  16991. 			    public bool Equals(S other) {

    16992. 

  16992. 			        return true;

    16993. 

  16993. 			    }

    16994. 

  16994. 			    public override int GetHashCode() {

    16995. 

  16995. 			        return 0;

    16996. 

  16996. 			    }

    16997. 

  16997. 			}

    16998. 

  16998. 			

    16999. 

  16999. 			public struct Sp : IEquatable<Sp> {

    17000. 

  17000. 			    public Sp(int i, double d) {

    17001. 

  17001. 			        I = i;

    17002. 

  17002. 			        D = d;

    17003. 

  17003. 			    }

    17004. 

  17004. 			

    17005. 

  17005. 			    public int I;

    17006. 

  17006. 			    public double D;

    17007. 

  17007. 			

    17008. 

  17008. 			    public override bool Equals(object o) {

    17009. 

  17009. 			        return (o is Sp) && Equals((Sp) o);

    17010. 

  17010. 			    }

    17011. 

  17011. 			    public bool Equals(Sp other) {

    17012. 

  17012. 			        return other.I == I && other.D == D;

    17013. 

  17013. 			    }

    17014. 

  17014. 			    public override int GetHashCode() {

    17015. 

  17015. 			        return I.GetHashCode() ^ D.GetHashCode();

    17016. 

  17016. 			    }

    17017. 

  17017. 			}

    17018. 

  17018. 			

    17019. 

  17019. 			public struct Ss : IEquatable<Ss> {

    17020. 

  17020. 			    public Ss(S s) {

    17021. 

  17021. 			        Val = s;

    17022. 

  17022. 			    }

    17023. 

  17023. 			

    17024. 

  17024. 			    public S Val;

    17025. 

  17025. 			

    17026. 

  17026. 			    public override bool Equals(object o) {

    17027. 

  17027. 			        return (o is Ss) && Equals((Ss) o);

    17028. 

  17028. 			    }

    17029. 

  17029. 			    public bool Equals(Ss other) {

    17030. 

  17030. 			        return other.Val.Equals(Val);

    17031. 

  17031. 			    }

    17032. 

  17032. 			    public override int GetHashCode() {

    17033. 

  17033. 			        return Val.GetHashCode();

    17034. 

  17034. 			    }

    17035. 

  17035. 			}

    17036. 

  17036. 			

    17037. 

  17037. 			public struct Sc : IEquatable<Sc> {

    17038. 

  17038. 			    public Sc(string s) {

    17039. 

  17039. 			        S = s;

    17040. 

  17040. 			    }

    17041. 

  17041. 			

    17042. 

  17042. 			    public string S;

    17043. 

  17043. 			

    17044. 

  17044. 			    public override bool Equals(object o) {

    17045. 

  17045. 			        return (o is Sc) && Equals((Sc) o);

    17046. 

  17046. 			    }

    17047. 

  17047. 			    public bool Equals(Sc other) {

    17048. 

  17048. 			        return other.S == S;

    17049. 

  17049. 			    }

    17050. 

  17050. 			    public override int GetHashCode() {

    17051. 

  17051. 			        return S.GetHashCode();

    17052. 

  17052. 			    }

    17053. 

  17053. 			}

    17054. 

  17054. 			

    17055. 

  17055. 			public struct Scs : IEquatable<Scs> {

    17056. 

  17056. 			    public Scs(string s, S val) {

    17057. 

  17057. 			        S = s;

    17058. 

  17058. 			        Val = val;

    17059. 

  17059. 			    }

    17060. 

  17060. 			

    17061. 

  17061. 			    public string S;

    17062. 

  17062. 			    public S Val;

    17063. 

  17063. 			

    17064. 

  17064. 			    public override bool Equals(object o) {

    17065. 

  17065. 			        return (o is Scs) && Equals((Scs) o);

    17066. 

  17066. 			    }

    17067. 

  17067. 			    public bool Equals(Scs other) {

    17068.