PageRenderTime 118ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 1ms

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

#
C# | 10651 lines | 9016 code | 1420 blank | 215 comment | 846 complexity | 58772e2b18712478e6f2280faba6af92 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 3124

    14. 

  14. 			namespace Scenario3124{

    15. 

  15. 				

    16. 

  16. 				public class Test

    17. 

  17. 				{

    18. 

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

    19. 

  19. 			    public static Expression byte_ArrayIndex__() {

    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 = check_byte_ArrayIndex();

    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 check_byte_ArrayIndex()

    42. 

  42. 				    {

    43. 

  43. 				        return checkEx_byte_ArrayIndex(null, -1) &

    44. 

  44. 				            checkEx_byte_ArrayIndex(null, 0) &

    45. 

  45. 				            checkEx_byte_ArrayIndex(null, 1) &

    46. 

  46. 				

    47. 

  47. 				            check_byte_ArrayIndex(genArrbyte_ArrayIndex(0)) &

    48. 

  48. 				            check_byte_ArrayIndex(genArrbyte_ArrayIndex(1)) &

    49. 

  49. 				            check_byte_ArrayIndex(genArrbyte_ArrayIndex(5));

    50. 

  50. 				    }

    51. 

  51. 				

    52. 

  52. 				    static byte[] genArrbyte_ArrayIndex(int size)

    53. 

  53. 				    {

    54. 

  54. 				        byte[] vals = new byte[] { 0, 1, byte.MaxValue };

    55. 

  55. 				        byte[] result = new byte[size];

    56. 

  56. 				        for (int i = 0; i < size; i++)

    57. 

  57. 				        {

    58. 

  58. 				            result[i] = vals[i % vals.Length];

    59. 

  59. 				        }

    60. 

  60. 				        return result;

    61. 

  61. 				    }

    62. 

  62. 				

    63. 

  63. 				    static bool check_byte_ArrayIndex(byte[] val)

    64. 

  64. 				    {

    65. 

  65. 				        bool success = checkEx_byte_ArrayIndex(val, -1);

    66. 

  66. 				        for (int i = 0; i < val.Length; i++)

    67. 

  67. 				        {

    68. 

  68. 				            success &= check_byte_ArrayIndex(val, 0);

    69. 

  69. 				        }

    70. 

  70. 				        success &= checkEx_byte_ArrayIndex(val, val.Length);

    71. 

  71. 				        return success;

    72. 

  72. 				    }

    73. 

  73. 				

    74. 

  74. 				    static bool checkEx_byte_ArrayIndex(byte[] val, int index)

    75. 

  75. 				    {

    76. 

  76. 				        try

    77. 

  77. 				        {

    78. 

  78. 				            check_byte_ArrayIndex(val, index);

    79. 

  79. 				            Console.WriteLine("byte_ArrayIndex[" + index + "] failed");

    80. 

  80. 				            return false;

    81. 

  81. 				        }

    82. 

  82. 				        catch

    83. 

  83. 				        {

    84. 

  84. 				            return true;

    85. 

  85. 				        }

    86. 

  86. 				    }

    87. 

  87. 				

    88. 

  88. 				    static bool check_byte_ArrayIndex(byte[] val, int index)

    89. 

  89. 				    {

    90. 

  90. 				        Expression<Func<byte>> e =

    91. 

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

    92. 

  92. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(byte[])),

    93. 

  93. 				                    Expression.Constant(index, typeof(int))),

    94. 

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

    95. 

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

    96. 

  96. 				        return object.Equals(f(), val[index]);

    97. 

  97. 				    }

    98. 

  98. 				}

    99. 

  99. 			

    100. 

  100. 			

    101. 

  101. 			public  static class Ext {

    102. 

  102. 			    public static void StartCapture() {

    103. 

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

    104. 

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

    105. 

  105. 			    }

    106. 

  106. 			

    107. 

  107. 			    public static void StopCapture() {

    108. 

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

    109. 

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

    110. 

  110. 			    }

    111. 

  111. 			

    112. 

  112. 			    public static bool IsIntegralOrEnum(Type type) {

    113. 

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

    114. 

  114. 			            case TypeCode.Byte:

    115. 

  115. 			            case TypeCode.SByte:

    116. 

  116. 			            case TypeCode.Int16:

    117. 

  117. 			            case TypeCode.Int32:

    118. 

  118. 			            case TypeCode.Int64:

    119. 

  119. 			            case TypeCode.UInt16:

    120. 

  120. 			            case TypeCode.UInt32:

    121. 

  121. 			            case TypeCode.UInt64:

    122. 

  122. 			                return true;

    123. 

  123. 			            default:

    124. 

  124. 			                return false;

    125. 

  125. 			        }

    126. 

  126. 			    }

    127. 

  127. 			

    128. 

  128. 			    public static bool IsFloating(Type type) {

    129. 

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

    130. 

  130. 			            case TypeCode.Single:

    131. 

  131. 			            case TypeCode.Double:

    132. 

  132. 			                return true;

    133. 

  133. 			            default:

    134. 

  134. 			                return false;

    135. 

  135. 			        }

    136. 

  136. 			    }

    137. 

  137. 			

    138. 

  138. 			    public static Type GetNonNullableType(Type type) {

    139. 

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

    140. 

  140. 			                type.GetGenericArguments()[0] :

    141. 

  141. 			                type;

    142. 

  142. 			    }

    143. 

  143. 			}

    144. 

  144. 			

    145. 

  145. 		

    146. 

  146. 	}

    147. 

  147. 			

    148. 

  148. 			//-------- Scenario 3125

    149. 

  149. 			namespace Scenario3125{

    150. 

  150. 				

    151. 

  151. 				public class Test

    152. 

  152. 				{

    153. 

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

    154. 

  154. 			    public static Expression ushort_ArrayIndex__() {

    155. 

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

    156. 

  156. 			           throw new Exception();

    157. 

  157. 			       } else { 

    158. 

  158. 			           return Expression.Constant(0);

    159. 

  159. 			       }

    160. 

  160. 			    }

    161. 

  161. 				public     static int Main()

    162. 

  162. 				    {

    163. 

  163. 				        Ext.StartCapture();

    164. 

  164. 				        bool success = false;

    165. 

  165. 				        try

    166. 

  166. 				        {

    167. 

  167. 				            success = check_ushort_ArrayIndex();

    168. 

  168. 				        }

    169. 

  169. 				        finally

    170. 

  170. 				        {

    171. 

  171. 				            Ext.StopCapture();

    172. 

  172. 				        }

    173. 

  173. 				        return success ? 0 : 1;

    174. 

  174. 				    }

    175. 

  175. 				

    176. 

  176. 				    static bool check_ushort_ArrayIndex()

    177. 

  177. 				    {

    178. 

  178. 				        return checkEx_ushort_ArrayIndex(null, -1) &

    179. 

  179. 				            checkEx_ushort_ArrayIndex(null, 0) &

    180. 

  180. 				            checkEx_ushort_ArrayIndex(null, 1) &

    181. 

  181. 				

    182. 

  182. 				            check_ushort_ArrayIndex(genArrushort_ArrayIndex(0)) &

    183. 

  183. 				            check_ushort_ArrayIndex(genArrushort_ArrayIndex(1)) &

    184. 

  184. 				            check_ushort_ArrayIndex(genArrushort_ArrayIndex(5));

    185. 

  185. 				    }

    186. 

  186. 				

    187. 

  187. 				    static ushort[] genArrushort_ArrayIndex(int size)

    188. 

  188. 				    {

    189. 

  189. 				        ushort[] vals = new ushort[] { 0, 1, ushort.MaxValue };

    190. 

  190. 				        ushort[] result = new ushort[size];

    191. 

  191. 				        for (int i = 0; i < size; i++)

    192. 

  192. 				        {

    193. 

  193. 				            result[i] = vals[i % vals.Length];

    194. 

  194. 				        }

    195. 

  195. 				        return result;

    196. 

  196. 				    }

    197. 

  197. 				

    198. 

  198. 				    static bool check_ushort_ArrayIndex(ushort[] val)

    199. 

  199. 				    {

    200. 

  200. 				        bool success = checkEx_ushort_ArrayIndex(val, -1);

    201. 

  201. 				        for (int i = 0; i < val.Length; i++)

    202. 

  202. 				        {

    203. 

  203. 				            success &= check_ushort_ArrayIndex(val, 0);

    204. 

  204. 				        }

    205. 

  205. 				        success &= checkEx_ushort_ArrayIndex(val, val.Length);

    206. 

  206. 				        return success;

    207. 

  207. 				    }

    208. 

  208. 				

    209. 

  209. 				    static bool checkEx_ushort_ArrayIndex(ushort[] val, int index)

    210. 

  210. 				    {

    211. 

  211. 				        try

    212. 

  212. 				        {

    213. 

  213. 				            check_ushort_ArrayIndex(val, index);

    214. 

  214. 				            Console.WriteLine("ushort_ArrayIndex[" + index + "] failed");

    215. 

  215. 				            return false;

    216. 

  216. 				        }

    217. 

  217. 				        catch

    218. 

  218. 				        {

    219. 

  219. 				            return true;

    220. 

  220. 				        }

    221. 

  221. 				    }

    222. 

  222. 				

    223. 

  223. 				    static bool check_ushort_ArrayIndex(ushort[] val, int index)

    224. 

  224. 				    {

    225. 

  225. 				        Expression<Func<ushort>> e =

    226. 

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

    227. 

  227. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(ushort[])),

    228. 

  228. 				                    Expression.Constant(index, typeof(int))),

    229. 

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

    230. 

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

    231. 

  231. 				        return object.Equals(f(), val[index]);

    232. 

  232. 				    }

    233. 

  233. 				}

    234. 

  234. 			

    235. 

  235. 			

    236. 

  236. 			public  static class Ext {

    237. 

  237. 			    public static void StartCapture() {

    238. 

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

    239. 

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

    240. 

  240. 			    }

    241. 

  241. 			

    242. 

  242. 			    public static void StopCapture() {

    243. 

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

    244. 

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

    245. 

  245. 			    }

    246. 

  246. 			

    247. 

  247. 			    public static bool IsIntegralOrEnum(Type type) {

    248. 

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

    249. 

  249. 			            case TypeCode.Byte:

    250. 

  250. 			            case TypeCode.SByte:

    251. 

  251. 			            case TypeCode.Int16:

    252. 

  252. 			            case TypeCode.Int32:

    253. 

  253. 			            case TypeCode.Int64:

    254. 

  254. 			            case TypeCode.UInt16:

    255. 

  255. 			            case TypeCode.UInt32:

    256. 

  256. 			            case TypeCode.UInt64:

    257. 

  257. 			                return true;

    258. 

  258. 			            default:

    259. 

  259. 			                return false;

    260. 

  260. 			        }

    261. 

  261. 			    }

    262. 

  262. 			

    263. 

  263. 			    public static bool IsFloating(Type type) {

    264. 

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

    265. 

  265. 			            case TypeCode.Single:

    266. 

  266. 			            case TypeCode.Double:

    267. 

  267. 			                return true;

    268. 

  268. 			            default:

    269. 

  269. 			                return false;

    270. 

  270. 			        }

    271. 

  271. 			    }

    272. 

  272. 			

    273. 

  273. 			    public static Type GetNonNullableType(Type type) {

    274. 

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

    275. 

  275. 			                type.GetGenericArguments()[0] :

    276. 

  276. 			                type;

    277. 

  277. 			    }

    278. 

  278. 			}

    279. 

  279. 			

    280. 

  280. 		

    281. 

  281. 	}

    282. 

  282. 			

    283. 

  283. 			//-------- Scenario 3126

    284. 

  284. 			namespace Scenario3126{

    285. 

  285. 				

    286. 

  286. 				public class Test

    287. 

  287. 				{

    288. 

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

    289. 

  289. 			    public static Expression uint_ArrayIndex__() {

    290. 

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

    291. 

  291. 			           throw new Exception();

    292. 

  292. 			       } else { 

    293. 

  293. 			           return Expression.Constant(0);

    294. 

  294. 			       }

    295. 

  295. 			    }

    296. 

  296. 				public     static int Main()

    297. 

  297. 				    {

    298. 

  298. 				        Ext.StartCapture();

    299. 

  299. 				        bool success = false;

    300. 

  300. 				        try

    301. 

  301. 				        {

    302. 

  302. 				            success = check_uint_ArrayIndex();

    303. 

  303. 				        }

    304. 

  304. 				        finally

    305. 

  305. 				        {

    306. 

  306. 				            Ext.StopCapture();

    307. 

  307. 				        }

    308. 

  308. 				        return success ? 0 : 1;

    309. 

  309. 				    }

    310. 

  310. 				

    311. 

  311. 				    static bool check_uint_ArrayIndex()

    312. 

  312. 				    {

    313. 

  313. 				        return checkEx_uint_ArrayIndex(null, -1) &

    314. 

  314. 				            checkEx_uint_ArrayIndex(null, 0) &

    315. 

  315. 				            checkEx_uint_ArrayIndex(null, 1) &

    316. 

  316. 				

    317. 

  317. 				            check_uint_ArrayIndex(genArruint_ArrayIndex(0)) &

    318. 

  318. 				            check_uint_ArrayIndex(genArruint_ArrayIndex(1)) &

    319. 

  319. 				            check_uint_ArrayIndex(genArruint_ArrayIndex(5));

    320. 

  320. 				    }

    321. 

  321. 				

    322. 

  322. 				    static uint[] genArruint_ArrayIndex(int size)

    323. 

  323. 				    {

    324. 

  324. 				        uint[] vals = new uint[] { 0, 1, uint.MaxValue };

    325. 

  325. 				        uint[] result = new uint[size];

    326. 

  326. 				        for (int i = 0; i < size; i++)

    327. 

  327. 				        {

    328. 

  328. 				            result[i] = vals[i % vals.Length];

    329. 

  329. 				        }

    330. 

  330. 				        return result;

    331. 

  331. 				    }

    332. 

  332. 				

    333. 

  333. 				    static bool check_uint_ArrayIndex(uint[] val)

    334. 

  334. 				    {

    335. 

  335. 				        bool success = checkEx_uint_ArrayIndex(val, -1);

    336. 

  336. 				        for (int i = 0; i < val.Length; i++)

    337. 

  337. 				        {

    338. 

  338. 				            success &= check_uint_ArrayIndex(val, 0);

    339. 

  339. 				        }

    340. 

  340. 				        success &= checkEx_uint_ArrayIndex(val, val.Length);

    341. 

  341. 				        return success;

    342. 

  342. 				    }

    343. 

  343. 				

    344. 

  344. 				    static bool checkEx_uint_ArrayIndex(uint[] val, int index)

    345. 

  345. 				    {

    346. 

  346. 				        try

    347. 

  347. 				        {

    348. 

  348. 				            check_uint_ArrayIndex(val, index);

    349. 

  349. 				            Console.WriteLine("uint_ArrayIndex[" + index + "] failed");

    350. 

  350. 				            return false;

    351. 

  351. 				        }

    352. 

  352. 				        catch

    353. 

  353. 				        {

    354. 

  354. 				            return true;

    355. 

  355. 				        }

    356. 

  356. 				    }

    357. 

  357. 				

    358. 

  358. 				    static bool check_uint_ArrayIndex(uint[] val, int index)

    359. 

  359. 				    {

    360. 

  360. 				        Expression<Func<uint>> e =

    361. 

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

    362. 

  362. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(uint[])),

    363. 

  363. 				                    Expression.Constant(index, typeof(int))),

    364. 

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

    365. 

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

    366. 

  366. 				        return object.Equals(f(), val[index]);

    367. 

  367. 				    }

    368. 

  368. 				}

    369. 

  369. 			

    370. 

  370. 			

    371. 

  371. 			public  static class Ext {

    372. 

  372. 			    public static void StartCapture() {

    373. 

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

    374. 

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

    375. 

  375. 			    }

    376. 

  376. 			

    377. 

  377. 			    public static void StopCapture() {

    378. 

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

    379. 

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

    380. 

  380. 			    }

    381. 

  381. 			

    382. 

  382. 			    public static bool IsIntegralOrEnum(Type type) {

    383. 

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

    384. 

  384. 			            case TypeCode.Byte:

    385. 

  385. 			            case TypeCode.SByte:

    386. 

  386. 			            case TypeCode.Int16:

    387. 

  387. 			            case TypeCode.Int32:

    388. 

  388. 			            case TypeCode.Int64:

    389. 

  389. 			            case TypeCode.UInt16:

    390. 

  390. 			            case TypeCode.UInt32:

    391. 

  391. 			            case TypeCode.UInt64:

    392. 

  392. 			                return true;

    393. 

  393. 			            default:

    394. 

  394. 			                return false;

    395. 

  395. 			        }

    396. 

  396. 			    }

    397. 

  397. 			

    398. 

  398. 			    public static bool IsFloating(Type type) {

    399. 

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

    400. 

  400. 			            case TypeCode.Single:

    401. 

  401. 			            case TypeCode.Double:

    402. 

  402. 			                return true;

    403. 

  403. 			            default:

    404. 

  404. 			                return false;

    405. 

  405. 			        }

    406. 

  406. 			    }

    407. 

  407. 			

    408. 

  408. 			    public static Type GetNonNullableType(Type type) {

    409. 

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

    410. 

  410. 			                type.GetGenericArguments()[0] :

    411. 

  411. 			                type;

    412. 

  412. 			    }

    413. 

  413. 			}

    414. 

  414. 			

    415. 

  415. 		

    416. 

  416. 	}

    417. 

  417. 			

    418. 

  418. 			//-------- Scenario 3127

    419. 

  419. 			namespace Scenario3127{

    420. 

  420. 				

    421. 

  421. 				public class Test

    422. 

  422. 				{

    423. 

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

    424. 

  424. 			    public static Expression ulong_ArrayIndex__() {

    425. 

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

    426. 

  426. 			           throw new Exception();

    427. 

  427. 			       } else { 

    428. 

  428. 			           return Expression.Constant(0);

    429. 

  429. 			       }

    430. 

  430. 			    }

    431. 

  431. 				public     static int Main()

    432. 

  432. 				    {

    433. 

  433. 				        Ext.StartCapture();

    434. 

  434. 				        bool success = false;

    435. 

  435. 				        try

    436. 

  436. 				        {

    437. 

  437. 				            success = check_ulong_ArrayIndex();

    438. 

  438. 				        }

    439. 

  439. 				        finally

    440. 

  440. 				        {

    441. 

  441. 				            Ext.StopCapture();

    442. 

  442. 				        }

    443. 

  443. 				        return success ? 0 : 1;

    444. 

  444. 				    }

    445. 

  445. 				

    446. 

  446. 				    static bool check_ulong_ArrayIndex()

    447. 

  447. 				    {

    448. 

  448. 				        return checkEx_ulong_ArrayIndex(null, -1) &

    449. 

  449. 				            checkEx_ulong_ArrayIndex(null, 0) &

    450. 

  450. 				            checkEx_ulong_ArrayIndex(null, 1) &

    451. 

  451. 				

    452. 

  452. 				            check_ulong_ArrayIndex(genArrulong_ArrayIndex(0)) &

    453. 

  453. 				            check_ulong_ArrayIndex(genArrulong_ArrayIndex(1)) &

    454. 

  454. 				            check_ulong_ArrayIndex(genArrulong_ArrayIndex(5));

    455. 

  455. 				    }

    456. 

  456. 				

    457. 

  457. 				    static ulong[] genArrulong_ArrayIndex(int size)

    458. 

  458. 				    {

    459. 

  459. 				        ulong[] vals = new ulong[] { 0, 1, ulong.MaxValue };

    460. 

  460. 				        ulong[] result = new ulong[size];

    461. 

  461. 				        for (int i = 0; i < size; i++)

    462. 

  462. 				        {

    463. 

  463. 				            result[i] = vals[i % vals.Length];

    464. 

  464. 				        }

    465. 

  465. 				        return result;

    466. 

  466. 				    }

    467. 

  467. 				

    468. 

  468. 				    static bool check_ulong_ArrayIndex(ulong[] val)

    469. 

  469. 				    {

    470. 

  470. 				        bool success = checkEx_ulong_ArrayIndex(val, -1);

    471. 

  471. 				        for (int i = 0; i < val.Length; i++)

    472. 

  472. 				        {

    473. 

  473. 				            success &= check_ulong_ArrayIndex(val, 0);

    474. 

  474. 				        }

    475. 

  475. 				        success &= checkEx_ulong_ArrayIndex(val, val.Length);

    476. 

  476. 				        return success;

    477. 

  477. 				    }

    478. 

  478. 				

    479. 

  479. 				    static bool checkEx_ulong_ArrayIndex(ulong[] val, int index)

    480. 

  480. 				    {

    481. 

  481. 				        try

    482. 

  482. 				        {

    483. 

  483. 				            check_ulong_ArrayIndex(val, index);

    484. 

  484. 				            Console.WriteLine("ulong_ArrayIndex[" + index + "] failed");

    485. 

  485. 				            return false;

    486. 

  486. 				        }

    487. 

  487. 				        catch

    488. 

  488. 				        {

    489. 

  489. 				            return true;

    490. 

  490. 				        }

    491. 

  491. 				    }

    492. 

  492. 				

    493. 

  493. 				    static bool check_ulong_ArrayIndex(ulong[] val, int index)

    494. 

  494. 				    {

    495. 

  495. 				        Expression<Func<ulong>> e =

    496. 

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

    497. 

  497. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(ulong[])),

    498. 

  498. 				                    Expression.Constant(index, typeof(int))),

    499. 

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

    500. 

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

    501. 

  501. 				        return object.Equals(f(), val[index]);

    502. 

  502. 				    }

    503. 

  503. 				}

    504. 

  504. 			

    505. 

  505. 			

    506. 

  506. 			public  static class Ext {

    507. 

  507. 			    public static void StartCapture() {

    508. 

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

    509. 

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

    510. 

  510. 			    }

    511. 

  511. 			

    512. 

  512. 			    public static void StopCapture() {

    513. 

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

    514. 

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

    515. 

  515. 			    }

    516. 

  516. 			

    517. 

  517. 			    public static bool IsIntegralOrEnum(Type type) {

    518. 

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

    519. 

  519. 			            case TypeCode.Byte:

    520. 

  520. 			            case TypeCode.SByte:

    521. 

  521. 			            case TypeCode.Int16:

    522. 

  522. 			            case TypeCode.Int32:

    523. 

  523. 			            case TypeCode.Int64:

    524. 

  524. 			            case TypeCode.UInt16:

    525. 

  525. 			            case TypeCode.UInt32:

    526. 

  526. 			            case TypeCode.UInt64:

    527. 

  527. 			                return true;

    528. 

  528. 			            default:

    529. 

  529. 			                return false;

    530. 

  530. 			        }

    531. 

  531. 			    }

    532. 

  532. 			

    533. 

  533. 			    public static bool IsFloating(Type type) {

    534. 

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

    535. 

  535. 			            case TypeCode.Single:

    536. 

  536. 			            case TypeCode.Double:

    537. 

  537. 			                return true;

    538. 

  538. 			            default:

    539. 

  539. 			                return false;

    540. 

  540. 			        }

    541. 

  541. 			    }

    542. 

  542. 			

    543. 

  543. 			    public static Type GetNonNullableType(Type type) {

    544. 

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

    545. 

  545. 			                type.GetGenericArguments()[0] :

    546. 

  546. 			                type;

    547. 

  547. 			    }

    548. 

  548. 			}

    549. 

  549. 			

    550. 

  550. 		

    551. 

  551. 	}

    552. 

  552. 			

    553. 

  553. 			//-------- Scenario 3128

    554. 

  554. 			namespace Scenario3128{

    555. 

  555. 				

    556. 

  556. 				public class Test

    557. 

  557. 				{

    558. 

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

    559. 

  559. 			    public static Expression sbyte_ArrayIndex__() {

    560. 

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

    561. 

  561. 			           throw new Exception();

    562. 

  562. 			       } else { 

    563. 

  563. 			           return Expression.Constant(0);

    564. 

  564. 			       }

    565. 

  565. 			    }

    566. 

  566. 				public     static int Main()

    567. 

  567. 				    {

    568. 

  568. 				        Ext.StartCapture();

    569. 

  569. 				        bool success = false;

    570. 

  570. 				        try

    571. 

  571. 				        {

    572. 

  572. 				            success = check_sbyte_ArrayIndex();

    573. 

  573. 				        }

    574. 

  574. 				        finally

    575. 

  575. 				        {

    576. 

  576. 				            Ext.StopCapture();

    577. 

  577. 				        }

    578. 

  578. 				        return success ? 0 : 1;

    579. 

  579. 				    }

    580. 

  580. 				

    581. 

  581. 				    static bool check_sbyte_ArrayIndex()

    582. 

  582. 				    {

    583. 

  583. 				        return checkEx_sbyte_ArrayIndex(null, -1) &

    584. 

  584. 				            checkEx_sbyte_ArrayIndex(null, 0) &

    585. 

  585. 				            checkEx_sbyte_ArrayIndex(null, 1) &

    586. 

  586. 				

    587. 

  587. 				            check_sbyte_ArrayIndex(genArrsbyte_ArrayIndex(0)) &

    588. 

  588. 				            check_sbyte_ArrayIndex(genArrsbyte_ArrayIndex(1)) &

    589. 

  589. 				            check_sbyte_ArrayIndex(genArrsbyte_ArrayIndex(5));

    590. 

  590. 				    }

    591. 

  591. 				

    592. 

  592. 				    static sbyte[] genArrsbyte_ArrayIndex(int size)

    593. 

  593. 				    {

    594. 

  594. 				        sbyte[] vals = new sbyte[] { 0, 1, -1, sbyte.MinValue, sbyte.MaxValue };

    595. 

  595. 				        sbyte[] result = new sbyte[size];

    596. 

  596. 				        for (int i = 0; i < size; i++)

    597. 

  597. 				        {

    598. 

  598. 				            result[i] = vals[i % vals.Length];

    599. 

  599. 				        }

    600. 

  600. 				        return result;

    601. 

  601. 				    }

    602. 

  602. 				

    603. 

  603. 				    static bool check_sbyte_ArrayIndex(sbyte[] val)

    604. 

  604. 				    {

    605. 

  605. 				        bool success = checkEx_sbyte_ArrayIndex(val, -1);

    606. 

  606. 				        for (int i = 0; i < val.Length; i++)

    607. 

  607. 				        {

    608. 

  608. 				            success &= check_sbyte_ArrayIndex(val, 0);

    609. 

  609. 				        }

    610. 

  610. 				        success &= checkEx_sbyte_ArrayIndex(val, val.Length);

    611. 

  611. 				        return success;

    612. 

  612. 				    }

    613. 

  613. 				

    614. 

  614. 				    static bool checkEx_sbyte_ArrayIndex(sbyte[] val, int index)

    615. 

  615. 				    {

    616. 

  616. 				        try

    617. 

  617. 				        {

    618. 

  618. 				            check_sbyte_ArrayIndex(val, index);

    619. 

  619. 				            Console.WriteLine("sbyte_ArrayIndex[" + index + "] failed");

    620. 

  620. 				            return false;

    621. 

  621. 				        }

    622. 

  622. 				        catch

    623. 

  623. 				        {

    624. 

  624. 				            return true;

    625. 

  625. 				        }

    626. 

  626. 				    }

    627. 

  627. 				

    628. 

  628. 				    static bool check_sbyte_ArrayIndex(sbyte[] val, int index)

    629. 

  629. 				    {

    630. 

  630. 				        Expression<Func<sbyte>> e =

    631. 

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

    632. 

  632. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(sbyte[])),

    633. 

  633. 				                    Expression.Constant(index, typeof(int))),

    634. 

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

    635. 

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

    636. 

  636. 				        return object.Equals(f(), val[index]);

    637. 

  637. 				    }

    638. 

  638. 				}

    639. 

  639. 			

    640. 

  640. 			

    641. 

  641. 			public  static class Ext {

    642. 

  642. 			    public static void StartCapture() {

    643. 

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

    644. 

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

    645. 

  645. 			    }

    646. 

  646. 			

    647. 

  647. 			    public static void StopCapture() {

    648. 

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

    649. 

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

    650. 

  650. 			    }

    651. 

  651. 			

    652. 

  652. 			    public static bool IsIntegralOrEnum(Type type) {

    653. 

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

    654. 

  654. 			            case TypeCode.Byte:

    655. 

  655. 			            case TypeCode.SByte:

    656. 

  656. 			            case TypeCode.Int16:

    657. 

  657. 			            case TypeCode.Int32:

    658. 

  658. 			            case TypeCode.Int64:

    659. 

  659. 			            case TypeCode.UInt16:

    660. 

  660. 			            case TypeCode.UInt32:

    661. 

  661. 			            case TypeCode.UInt64:

    662. 

  662. 			                return true;

    663. 

  663. 			            default:

    664. 

  664. 			                return false;

    665. 

  665. 			        }

    666. 

  666. 			    }

    667. 

  667. 			

    668. 

  668. 			    public static bool IsFloating(Type type) {

    669. 

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

    670. 

  670. 			            case TypeCode.Single:

    671. 

  671. 			            case TypeCode.Double:

    672. 

  672. 			                return true;

    673. 

  673. 			            default:

    674. 

  674. 			                return false;

    675. 

  675. 			        }

    676. 

  676. 			    }

    677. 

  677. 			

    678. 

  678. 			    public static Type GetNonNullableType(Type type) {

    679. 

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

    680. 

  680. 			                type.GetGenericArguments()[0] :

    681. 

  681. 			                type;

    682. 

  682. 			    }

    683. 

  683. 			}

    684. 

  684. 			

    685. 

  685. 		

    686. 

  686. 	}

    687. 

  687. 			

    688. 

  688. 			//-------- Scenario 3129

    689. 

  689. 			namespace Scenario3129{

    690. 

  690. 				

    691. 

  691. 				public class Test

    692. 

  692. 				{

    693. 

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

    694. 

  694. 			    public static Expression short_ArrayIndex__() {

    695. 

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

    696. 

  696. 			           throw new Exception();

    697. 

  697. 			       } else { 

    698. 

  698. 			           return Expression.Constant(0);

    699. 

  699. 			       }

    700. 

  700. 			    }

    701. 

  701. 				public     static int Main()

    702. 

  702. 				    {

    703. 

  703. 				        Ext.StartCapture();

    704. 

  704. 				        bool success = false;

    705. 

  705. 				        try

    706. 

  706. 				        {

    707. 

  707. 				            success = check_short_ArrayIndex();

    708. 

  708. 				        }

    709. 

  709. 				        finally

    710. 

  710. 				        {

    711. 

  711. 				            Ext.StopCapture();

    712. 

  712. 				        }

    713. 

  713. 				        return success ? 0 : 1;

    714. 

  714. 				    }

    715. 

  715. 				

    716. 

  716. 				    static bool check_short_ArrayIndex()

    717. 

  717. 				    {

    718. 

  718. 				        return checkEx_short_ArrayIndex(null, -1) &

    719. 

  719. 				            checkEx_short_ArrayIndex(null, 0) &

    720. 

  720. 				            checkEx_short_ArrayIndex(null, 1) &

    721. 

  721. 				

    722. 

  722. 				            check_short_ArrayIndex(genArrshort_ArrayIndex(0)) &

    723. 

  723. 				            check_short_ArrayIndex(genArrshort_ArrayIndex(1)) &

    724. 

  724. 				            check_short_ArrayIndex(genArrshort_ArrayIndex(5));

    725. 

  725. 				    }

    726. 

  726. 				

    727. 

  727. 				    static short[] genArrshort_ArrayIndex(int size)

    728. 

  728. 				    {

    729. 

  729. 				        short[] vals = new short[] { 0, 1, -1, short.MinValue, short.MaxValue };

    730. 

  730. 				        short[] result = new short[size];

    731. 

  731. 				        for (int i = 0; i < size; i++)

    732. 

  732. 				        {

    733. 

  733. 				            result[i] = vals[i % vals.Length];

    734. 

  734. 				        }

    735. 

  735. 				        return result;

    736. 

  736. 				    }

    737. 

  737. 				

    738. 

  738. 				    static bool check_short_ArrayIndex(short[] val)

    739. 

  739. 				    {

    740. 

  740. 				        bool success = checkEx_short_ArrayIndex(val, -1);

    741. 

  741. 				        for (int i = 0; i < val.Length; i++)

    742. 

  742. 				        {

    743. 

  743. 				            success &= check_short_ArrayIndex(val, 0);

    744. 

  744. 				        }

    745. 

  745. 				        success &= checkEx_short_ArrayIndex(val, val.Length);

    746. 

  746. 				        return success;

    747. 

  747. 				    }

    748. 

  748. 				

    749. 

  749. 				    static bool checkEx_short_ArrayIndex(short[] val, int index)

    750. 

  750. 				    {

    751. 

  751. 				        try

    752. 

  752. 				        {

    753. 

  753. 				            check_short_ArrayIndex(val, index);

    754. 

  754. 				            Console.WriteLine("short_ArrayIndex[" + index + "] failed");

    755. 

  755. 				            return false;

    756. 

  756. 				        }

    757. 

  757. 				        catch

    758. 

  758. 				        {

    759. 

  759. 				            return true;

    760. 

  760. 				        }

    761. 

  761. 				    }

    762. 

  762. 				

    763. 

  763. 				    static bool check_short_ArrayIndex(short[] val, int index)

    764. 

  764. 				    {

    765. 

  765. 				        Expression<Func<short>> e =

    766. 

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

    767. 

  767. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(short[])),

    768. 

  768. 				                    Expression.Constant(index, typeof(int))),

    769. 

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

    770. 

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

    771. 

  771. 				        return object.Equals(f(), val[index]);

    772. 

  772. 				    }

    773. 

  773. 				}

    774. 

  774. 			

    775. 

  775. 			

    776. 

  776. 			public  static class Ext {

    777. 

  777. 			    public static void StartCapture() {

    778. 

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

    779. 

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

    780. 

  780. 			    }

    781. 

  781. 			

    782. 

  782. 			    public static void StopCapture() {

    783. 

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

    784. 

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

    785. 

  785. 			    }

    786. 

  786. 			

    787. 

  787. 			    public static bool IsIntegralOrEnum(Type type) {

    788. 

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

    789. 

  789. 			            case TypeCode.Byte:

    790. 

  790. 			            case TypeCode.SByte:

    791. 

  791. 			            case TypeCode.Int16:

    792. 

  792. 			            case TypeCode.Int32:

    793. 

  793. 			            case TypeCode.Int64:

    794. 

  794. 			            case TypeCode.UInt16:

    795. 

  795. 			            case TypeCode.UInt32:

    796. 

  796. 			            case TypeCode.UInt64:

    797. 

  797. 			                return true;

    798. 

  798. 			            default:

    799. 

  799. 			                return false;

    800. 

  800. 			        }

    801. 

  801. 			    }

    802. 

  802. 			

    803. 

  803. 			    public static bool IsFloating(Type type) {

    804. 

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

    805. 

  805. 			            case TypeCode.Single:

    806. 

  806. 			            case TypeCode.Double:

    807. 

  807. 			                return true;

    808. 

  808. 			            default:

    809. 

  809. 			                return false;

    810. 

  810. 			        }

    811. 

  811. 			    }

    812. 

  812. 			

    813. 

  813. 			    public static Type GetNonNullableType(Type type) {

    814. 

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

    815. 

  815. 			                type.GetGenericArguments()[0] :

    816. 

  816. 			                type;

    817. 

  817. 			    }

    818. 

  818. 			}

    819. 

  819. 			

    820. 

  820. 		

    821. 

  821. 	}

    822. 

  822. 			

    823. 

  823. 			//-------- Scenario 3130

    824. 

  824. 			namespace Scenario3130{

    825. 

  825. 				

    826. 

  826. 				public class Test

    827. 

  827. 				{

    828. 

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

    829. 

  829. 			    public static Expression int_ArrayIndex__() {

    830. 

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

    831. 

  831. 			           throw new Exception();

    832. 

  832. 			       } else { 

    833. 

  833. 			           return Expression.Constant(0);

    834. 

  834. 			       }

    835. 

  835. 			    }

    836. 

  836. 				public     static int Main()

    837. 

  837. 				    {

    838. 

  838. 				        Ext.StartCapture();

    839. 

  839. 				        bool success = false;

    840. 

  840. 				        try

    841. 

  841. 				        {

    842. 

  842. 				            success = check_int_ArrayIndex();

    843. 

  843. 				        }

    844. 

  844. 				        finally

    845. 

  845. 				        {

    846. 

  846. 				            Ext.StopCapture();

    847. 

  847. 				        }

    848. 

  848. 				        return success ? 0 : 1;

    849. 

  849. 				    }

    850. 

  850. 				

    851. 

  851. 				    static bool check_int_ArrayIndex()

    852. 

  852. 				    {

    853. 

  853. 				        return checkEx_int_ArrayIndex(null, -1) &

    854. 

  854. 				            checkEx_int_ArrayIndex(null, 0) &

    855. 

  855. 				            checkEx_int_ArrayIndex(null, 1) &

    856. 

  856. 				

    857. 

  857. 				            check_int_ArrayIndex(genArrint_ArrayIndex(0)) &

    858. 

  858. 				            check_int_ArrayIndex(genArrint_ArrayIndex(1)) &

    859. 

  859. 				            check_int_ArrayIndex(genArrint_ArrayIndex(5));

    860. 

  860. 				    }

    861. 

  861. 				

    862. 

  862. 				    static int[] genArrint_ArrayIndex(int size)

    863. 

  863. 				    {

    864. 

  864. 				        int[] vals = new int[] { 0, 1, -1, int.MinValue, int.MaxValue };

    865. 

  865. 				        int[] result = new int[size];

    866. 

  866. 				        for (int i = 0; i < size; i++)

    867. 

  867. 				        {

    868. 

  868. 				            result[i] = vals[i % vals.Length];

    869. 

  869. 				        }

    870. 

  870. 				        return result;

    871. 

  871. 				    }

    872. 

  872. 				

    873. 

  873. 				    static bool check_int_ArrayIndex(int[] val)

    874. 

  874. 				    {

    875. 

  875. 				        bool success = checkEx_int_ArrayIndex(val, -1);

    876. 

  876. 				        for (int i = 0; i < val.Length; i++)

    877. 

  877. 				        {

    878. 

  878. 				            success &= check_int_ArrayIndex(val, 0);

    879. 

  879. 				        }

    880. 

  880. 				        success &= checkEx_int_ArrayIndex(val, val.Length);

    881. 

  881. 				        return success;

    882. 

  882. 				    }

    883. 

  883. 				

    884. 

  884. 				    static bool checkEx_int_ArrayIndex(int[] val, int index)

    885. 

  885. 				    {

    886. 

  886. 				        try

    887. 

  887. 				        {

    888. 

  888. 				            check_int_ArrayIndex(val, index);

    889. 

  889. 				            Console.WriteLine("int_ArrayIndex[" + index + "] failed");

    890. 

  890. 				            return false;

    891. 

  891. 				        }

    892. 

  892. 				        catch

    893. 

  893. 				        {

    894. 

  894. 				            return true;

    895. 

  895. 				        }

    896. 

  896. 				    }

    897. 

  897. 				

    898. 

  898. 				    static bool check_int_ArrayIndex(int[] val, int index)

    899. 

  899. 				    {

    900. 

  900. 				        Expression<Func<int>> e =

    901. 

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

    902. 

  902. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(int[])),

    903. 

  903. 				                    Expression.Constant(index, typeof(int))),

    904. 

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

    905. 

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

    906. 

  906. 				        return object.Equals(f(), val[index]);

    907. 

  907. 				    }

    908. 

  908. 				}

    909. 

  909. 			

    910. 

  910. 			

    911. 

  911. 			public  static class Ext {

    912. 

  912. 			    public static void StartCapture() {

    913. 

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

    914. 

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

    915. 

  915. 			    }

    916. 

  916. 			

    917. 

  917. 			    public static void StopCapture() {

    918. 

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

    919. 

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

    920. 

  920. 			    }

    921. 

  921. 			

    922. 

  922. 			    public static bool IsIntegralOrEnum(Type type) {

    923. 

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

    924. 

  924. 			            case TypeCode.Byte:

    925. 

  925. 			            case TypeCode.SByte:

    926. 

  926. 			            case TypeCode.Int16:

    927. 

  927. 			            case TypeCode.Int32:

    928. 

  928. 			            case TypeCode.Int64:

    929. 

  929. 			            case TypeCode.UInt16:

    930. 

  930. 			            case TypeCode.UInt32:

    931. 

  931. 			            case TypeCode.UInt64:

    932. 

  932. 			                return true;

    933. 

  933. 			            default:

    934. 

  934. 			                return false;

    935. 

  935. 			        }

    936. 

  936. 			    }

    937. 

  937. 			

    938. 

  938. 			    public static bool IsFloating(Type type) {

    939. 

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

    940. 

  940. 			            case TypeCode.Single:

    941. 

  941. 			            case TypeCode.Double:

    942. 

  942. 			                return true;

    943. 

  943. 			            default:

    944. 

  944. 			                return false;

    945. 

  945. 			        }

    946. 

  946. 			    }

    947. 

  947. 			

    948. 

  948. 			    public static Type GetNonNullableType(Type type) {

    949. 

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

    950. 

  950. 			                type.GetGenericArguments()[0] :

    951. 

  951. 			                type;

    952. 

  952. 			    }

    953. 

  953. 			}

    954. 

  954. 			

    955. 

  955. 		

    956. 

  956. 	}

    957. 

  957. 			

    958. 

  958. 			//-------- Scenario 3131

    959. 

  959. 			namespace Scenario3131{

    960. 

  960. 				

    961. 

  961. 				public class Test

    962. 

  962. 				{

    963. 

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

    964. 

  964. 			    public static Expression long_ArrayIndex__() {

    965. 

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

    966. 

  966. 			           throw new Exception();

    967. 

  967. 			       } else { 

    968. 

  968. 			           return Expression.Constant(0);

    969. 

  969. 			       }

    970. 

  970. 			    }

    971. 

  971. 				public     static int Main()

    972. 

  972. 				    {

    973. 

  973. 				        Ext.StartCapture();

    974. 

  974. 				        bool success = false;

    975. 

  975. 				        try

    976. 

  976. 				        {

    977. 

  977. 				            success = check_long_ArrayIndex();

    978. 

  978. 				        }

    979. 

  979. 				        finally

    980. 

  980. 				        {

    981. 

  981. 				            Ext.StopCapture();

    982. 

  982. 				        }

    983. 

  983. 				        return success ? 0 : 1;

    984. 

  984. 				    }

    985. 

  985. 				

    986. 

  986. 				    static bool check_long_ArrayIndex()

    987. 

  987. 				    {

    988. 

  988. 				        return checkEx_long_ArrayIndex(null, -1) &

    989. 

  989. 				            checkEx_long_ArrayIndex(null, 0) &

    990. 

  990. 				            checkEx_long_ArrayIndex(null, 1) &

    991. 

  991. 				

    992. 

  992. 				            check_long_ArrayIndex(genArrlong_ArrayIndex(0)) &

    993. 

  993. 				            check_long_ArrayIndex(genArrlong_ArrayIndex(1)) &

    994. 

  994. 				            check_long_ArrayIndex(genArrlong_ArrayIndex(5));

    995. 

  995. 				    }

    996. 

  996. 				

    997. 

  997. 				    static long[] genArrlong_ArrayIndex(int size)

    998. 

  998. 				    {

    999. 

  999. 				        long[] vals = new long[] { 0, 1, -1, long.MinValue, long.MaxValue };

    1000. 

  1000. 				        long[] result = new long[size];

    1001. 

  1001. 				        for (int i = 0; i < size; i++)

    1002. 

  1002. 				        {

    1003. 

  1003. 				            result[i] = vals[i % vals.Length];

    1004. 

  1004. 				        }

    1005. 

  1005. 				        return result;

    1006. 

  1006. 				    }

    1007. 

  1007. 				

    1008. 

  1008. 				    static bool check_long_ArrayIndex(long[] val)

    1009. 

  1009. 				    {

    1010. 

  1010. 				        bool success = checkEx_long_ArrayIndex(val, -1);

    1011. 

  1011. 				        for (int i = 0; i < val.Length; i++)

    1012. 

  1012. 				        {

    1013. 

  1013. 				            success &= check_long_ArrayIndex(val, 0);

    1014. 

  1014. 				        }

    1015. 

  1015. 				        success &= checkEx_long_ArrayIndex(val, val.Length);

    1016. 

  1016. 				        return success;

    1017. 

  1017. 				    }

    1018. 

  1018. 				

    1019. 

  1019. 				    static bool checkEx_long_ArrayIndex(long[] val, int index)

    1020. 

  1020. 				    {

    1021. 

  1021. 				        try

    1022. 

  1022. 				        {

    1023. 

  1023. 				            check_long_ArrayIndex(val, index);

    1024. 

  1024. 				            Console.WriteLine("long_ArrayIndex[" + index + "] failed");

    1025. 

  1025. 				            return false;

    1026. 

  1026. 				        }

    1027. 

  1027. 				        catch

    1028. 

  1028. 				        {

    1029. 

  1029. 				            return true;

    1030. 

  1030. 				        }

    1031. 

  1031. 				    }

    1032. 

  1032. 				

    1033. 

  1033. 				    static bool check_long_ArrayIndex(long[] val, int index)

    1034. 

  1034. 				    {

    1035. 

  1035. 				        Expression<Func<long>> e =

    1036. 

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

    1037. 

  1037. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(long[])),

    1038. 

  1038. 				                    Expression.Constant(index, typeof(int))),

    1039. 

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

    1040. 

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

    1041. 

  1041. 				        return object.Equals(f(), val[index]);

    1042. 

  1042. 				    }

    1043. 

  1043. 				}

    1044. 

  1044. 			

    1045. 

  1045. 			

    1046. 

  1046. 			public  static class Ext {

    1047. 

  1047. 			    public static void StartCapture() {

    1048. 

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

    1049. 

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

    1050. 

  1050. 			    }

    1051. 

  1051. 			

    1052. 

  1052. 			    public static void StopCapture() {

    1053. 

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

    1054. 

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

    1055. 

  1055. 			    }

    1056. 

  1056. 			

    1057. 

  1057. 			    public static bool IsIntegralOrEnum(Type type) {

    1058. 

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

    1059. 

  1059. 			            case TypeCode.Byte:

    1060. 

  1060. 			            case TypeCode.SByte:

    1061. 

  1061. 			            case TypeCode.Int16:

    1062. 

  1062. 			            case TypeCode.Int32:

    1063. 

  1063. 			            case TypeCode.Int64:

    1064. 

  1064. 			            case TypeCode.UInt16:

    1065. 

  1065. 			            case TypeCode.UInt32:

    1066. 

  1066. 			            case TypeCode.UInt64:

    1067. 

  1067. 			                return true;

    1068. 

  1068. 			            default:

    1069. 

  1069. 			                return false;

    1070. 

  1070. 			        }

    1071. 

  1071. 			    }

    1072. 

  1072. 			

    1073. 

  1073. 			    public static bool IsFloating(Type type) {

    1074. 

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

    1075. 

  1075. 			            case TypeCode.Single:

    1076. 

  1076. 			            case TypeCode.Double:

    1077. 

  1077. 			                return true;

    1078. 

  1078. 			            default:

    1079. 

  1079. 			                return false;

    1080. 

  1080. 			        }

    1081. 

  1081. 			    }

    1082. 

  1082. 			

    1083. 

  1083. 			    public static Type GetNonNullableType(Type type) {

    1084. 

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

    1085. 

  1085. 			                type.GetGenericArguments()[0] :

    1086. 

  1086. 			                type;

    1087. 

  1087. 			    }

    1088. 

  1088. 			}

    1089. 

  1089. 			

    1090. 

  1090. 		

    1091. 

  1091. 	}

    1092. 

  1092. 			

    1093. 

  1093. 			//-------- Scenario 3132

    1094. 

  1094. 			namespace Scenario3132{

    1095. 

  1095. 				

    1096. 

  1096. 				public class Test

    1097. 

  1097. 				{

    1098. 

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

    1099. 

  1099. 			    public static Expression float_ArrayIndex__() {

    1100. 

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

    1101. 

  1101. 			           throw new Exception();

    1102. 

  1102. 			       } else { 

    1103. 

  1103. 			           return Expression.Constant(0);

    1104. 

  1104. 			       }

    1105. 

  1105. 			    }

    1106. 

  1106. 				public     static int Main()

    1107. 

  1107. 				    {

    1108. 

  1108. 				        Ext.StartCapture();

    1109. 

  1109. 				        bool success = false;

    1110. 

  1110. 				        try

    1111. 

  1111. 				        {

    1112. 

  1112. 				            success = check_float_ArrayIndex();

    1113. 

  1113. 				        }

    1114. 

  1114. 				        finally

    1115. 

  1115. 				        {

    1116. 

  1116. 				            Ext.StopCapture();

    1117. 

  1117. 				        }

    1118. 

  1118. 				        return success ? 0 : 1;

    1119. 

  1119. 				    }

    1120. 

  1120. 				

    1121. 

  1121. 				    static bool check_float_ArrayIndex()

    1122. 

  1122. 				    {

    1123. 

  1123. 				        return checkEx_float_ArrayIndex(null, -1) &

    1124. 

  1124. 				            checkEx_float_ArrayIndex(null, 0) &

    1125. 

  1125. 				            checkEx_float_ArrayIndex(null, 1) &

    1126. 

  1126. 				

    1127. 

  1127. 				            check_float_ArrayIndex(genArrfloat_ArrayIndex(0)) &

    1128. 

  1128. 				            check_float_ArrayIndex(genArrfloat_ArrayIndex(1)) &

    1129. 

  1129. 				            check_float_ArrayIndex(genArrfloat_ArrayIndex(5));

    1130. 

  1130. 				    }

    1131. 

  1131. 				

    1132. 

  1132. 				    static float[] genArrfloat_ArrayIndex(int size)

    1133. 

  1133. 				    {

    1134. 

  1134. 				        float[] vals = new float[] { 0, 1, -1, float.MinValue, float.MaxValue, float.Epsilon, float.NegativeInfinity, float.PositiveInfinity, float.NaN };

    1135. 

  1135. 				        float[] result = new float[size];

    1136. 

  1136. 				        for (int i = 0; i < size; i++)

    1137. 

  1137. 				        {

    1138. 

  1138. 				            result[i] = vals[i % vals.Length];

    1139. 

  1139. 				        }

    1140. 

  1140. 				        return result;

    1141. 

  1141. 				    }

    1142. 

  1142. 				

    1143. 

  1143. 				    static bool check_float_ArrayIndex(float[] val)

    1144. 

  1144. 				    {

    1145. 

  1145. 				        bool success = checkEx_float_ArrayIndex(val, -1);

    1146. 

  1146. 				        for (int i = 0; i < val.Length; i++)

    1147. 

  1147. 				        {

    1148. 

  1148. 				            success &= check_float_ArrayIndex(val, 0);

    1149. 

  1149. 				        }

    1150. 

  1150. 				        success &= checkEx_float_ArrayIndex(val, val.Length);

    1151. 

  1151. 				        return success;

    1152. 

  1152. 				    }

    1153. 

  1153. 				

    1154. 

  1154. 				    static bool checkEx_float_ArrayIndex(float[] val, int index)

    1155. 

  1155. 				    {

    1156. 

  1156. 				        try

    1157. 

  1157. 				        {

    1158. 

  1158. 				            check_float_ArrayIndex(val, index);

    1159. 

  1159. 				            Console.WriteLine("float_ArrayIndex[" + index + "] failed");

    1160. 

  1160. 				            return false;

    1161. 

  1161. 				        }

    1162. 

  1162. 				        catch

    1163. 

  1163. 				        {

    1164. 

  1164. 				            return true;

    1165. 

  1165. 				        }

    1166. 

  1166. 				    }

    1167. 

  1167. 				

    1168. 

  1168. 				    static bool check_float_ArrayIndex(float[] val, int index)

    1169. 

  1169. 				    {

    1170. 

  1170. 				        Expression<Func<float>> e =

    1171. 

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

    1172. 

  1172. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(float[])),

    1173. 

  1173. 				                    Expression.Constant(index, typeof(int))),

    1174. 

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

    1175. 

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

    1176. 

  1176. 				        return object.Equals(f(), val[index]);

    1177. 

  1177. 				    }

    1178. 

  1178. 				}

    1179. 

  1179. 			

    1180. 

  1180. 			

    1181. 

  1181. 			public  static class Ext {

    1182. 

  1182. 			    public static void StartCapture() {

    1183. 

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

    1184. 

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

    1185. 

  1185. 			    }

    1186. 

  1186. 			

    1187. 

  1187. 			    public static void StopCapture() {

    1188. 

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

    1189. 

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

    1190. 

  1190. 			    }

    1191. 

  1191. 			

    1192. 

  1192. 			    public static bool IsIntegralOrEnum(Type type) {

    1193. 

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

    1194. 

  1194. 			            case TypeCode.Byte:

    1195. 

  1195. 			            case TypeCode.SByte:

    1196. 

  1196. 			            case TypeCode.Int16:

    1197. 

  1197. 			            case TypeCode.Int32:

    1198. 

  1198. 			            case TypeCode.Int64:

    1199. 

  1199. 			            case TypeCode.UInt16:

    1200. 

  1200. 			            case TypeCode.UInt32:

    1201. 

  1201. 			            case TypeCode.UInt64:

    1202. 

  1202. 			                return true;

    1203. 

  1203. 			            default:

    1204. 

  1204. 			                return false;

    1205. 

  1205. 			        }

    1206. 

  1206. 			    }

    1207. 

  1207. 			

    1208. 

  1208. 			    public static bool IsFloating(Type type) {

    1209. 

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

    1210. 

  1210. 			            case TypeCode.Single:

    1211. 

  1211. 			            case TypeCode.Double:

    1212. 

  1212. 			                return true;

    1213. 

  1213. 			            default:

    1214. 

  1214. 			                return false;

    1215. 

  1215. 			        }

    1216. 

  1216. 			    }

    1217. 

  1217. 			

    1218. 

  1218. 			    public static Type GetNonNullableType(Type type) {

    1219. 

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

    1220. 

  1220. 			                type.GetGenericArguments()[0] :

    1221. 

  1221. 			                type;

    1222. 

  1222. 			    }

    1223. 

  1223. 			}

    1224. 

  1224. 			

    1225. 

  1225. 		

    1226. 

  1226. 	}

    1227. 

  1227. 			

    1228. 

  1228. 			//-------- Scenario 3133

    1229. 

  1229. 			namespace Scenario3133{

    1230. 

  1230. 				

    1231. 

  1231. 				public class Test

    1232. 

  1232. 				{

    1233. 

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

    1234. 

  1234. 			    public static Expression double_ArrayIndex__() {

    1235. 

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

    1236. 

  1236. 			           throw new Exception();

    1237. 

  1237. 			       } else { 

    1238. 

  1238. 			           return Expression.Constant(0);

    1239. 

  1239. 			       }

    1240. 

  1240. 			    }

    1241. 

  1241. 				public     static int Main()

    1242. 

  1242. 				    {

    1243. 

  1243. 				        Ext.StartCapture();

    1244. 

  1244. 				        bool success = false;

    1245. 

  1245. 				        try

    1246. 

  1246. 				        {

    1247. 

  1247. 				            success = check_double_ArrayIndex();

    1248. 

  1248. 				        }

    1249. 

  1249. 				        finally

    1250. 

  1250. 				        {

    1251. 

  1251. 				            Ext.StopCapture();

    1252. 

  1252. 				        }

    1253. 

  1253. 				        return success ? 0 : 1;

    1254. 

  1254. 				    }

    1255. 

  1255. 				

    1256. 

  1256. 				    static bool check_double_ArrayIndex()

    1257. 

  1257. 				    {

    1258. 

  1258. 				        return checkEx_double_ArrayIndex(null, -1) &

    1259. 

  1259. 				            checkEx_double_ArrayIndex(null, 0) &

    1260. 

  1260. 				            checkEx_double_ArrayIndex(null, 1) &

    1261. 

  1261. 				

    1262. 

  1262. 				            check_double_ArrayIndex(genArrdouble_ArrayIndex(0)) &

    1263. 

  1263. 				            check_double_ArrayIndex(genArrdouble_ArrayIndex(1)) &

    1264. 

  1264. 				            check_double_ArrayIndex(genArrdouble_ArrayIndex(5));

    1265. 

  1265. 				    }

    1266. 

  1266. 				

    1267. 

  1267. 				    static double[] genArrdouble_ArrayIndex(int size)

    1268. 

  1268. 				    {

    1269. 

  1269. 				        double[] vals = new double[] { 0, 1, -1, double.MinValue, double.MaxValue, double.Epsilon, double.NegativeInfinity, double.PositiveInfinity, double.NaN };

    1270. 

  1270. 				        double[] result = new double[size];

    1271. 

  1271. 				        for (int i = 0; i < size; i++)

    1272. 

  1272. 				        {

    1273. 

  1273. 				            result[i] = vals[i % vals.Length];

    1274. 

  1274. 				        }

    1275. 

  1275. 				        return result;

    1276. 

  1276. 				    }

    1277. 

  1277. 				

    1278. 

  1278. 				    static bool check_double_ArrayIndex(double[] val)

    1279. 

  1279. 				    {

    1280. 

  1280. 				        bool success = checkEx_double_ArrayIndex(val, -1);

    1281. 

  1281. 				        for (int i = 0; i < val.Length; i++)

    1282. 

  1282. 				        {

    1283. 

  1283. 				            success &= check_double_ArrayIndex(val, 0);

    1284. 

  1284. 				        }

    1285. 

  1285. 				        success &= checkEx_double_ArrayIndex(val, val.Length);

    1286. 

  1286. 				        return success;

    1287. 

  1287. 				    }

    1288. 

  1288. 				

    1289. 

  1289. 				    static bool checkEx_double_ArrayIndex(double[] val, int index)

    1290. 

  1290. 				    {

    1291. 

  1291. 				        try

    1292. 

  1292. 				        {

    1293. 

  1293. 				            check_double_ArrayIndex(val, index);

    1294. 

  1294. 				            Console.WriteLine("double_ArrayIndex[" + index + "] failed");

    1295. 

  1295. 				            return false;

    1296. 

  1296. 				        }

    1297. 

  1297. 				        catch

    1298. 

  1298. 				        {

    1299. 

  1299. 				            return true;

    1300. 

  1300. 				        }

    1301. 

  1301. 				    }

    1302. 

  1302. 				

    1303. 

  1303. 				    static bool check_double_ArrayIndex(double[] val, int index)

    1304. 

  1304. 				    {

    1305. 

  1305. 				        Expression<Func<double>> e =

    1306. 

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

    1307. 

  1307. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(double[])),

    1308. 

  1308. 				                    Expression.Constant(index, typeof(int))),

    1309. 

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

    1310. 

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

    1311. 

  1311. 				        return object.Equals(f(), val[index]);

    1312. 

  1312. 				    }

    1313. 

  1313. 				}

    1314. 

  1314. 			

    1315. 

  1315. 			

    1316. 

  1316. 			public  static class Ext {

    1317. 

  1317. 			    public static void StartCapture() {

    1318. 

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

    1319. 

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

    1320. 

  1320. 			    }

    1321. 

  1321. 			

    1322. 

  1322. 			    public static void StopCapture() {

    1323. 

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

    1324. 

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

    1325. 

  1325. 			    }

    1326. 

  1326. 			

    1327. 

  1327. 			    public static bool IsIntegralOrEnum(Type type) {

    1328. 

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

    1329. 

  1329. 			            case TypeCode.Byte:

    1330. 

  1330. 			            case TypeCode.SByte:

    1331. 

  1331. 			            case TypeCode.Int16:

    1332. 

  1332. 			            case TypeCode.Int32:

    1333. 

  1333. 			            case TypeCode.Int64:

    1334. 

  1334. 			            case TypeCode.UInt16:

    1335. 

  1335. 			            case TypeCode.UInt32:

    1336. 

  1336. 			            case TypeCode.UInt64:

    1337. 

  1337. 			                return true;

    1338. 

  1338. 			            default:

    1339. 

  1339. 			                return false;

    1340. 

  1340. 			        }

    1341. 

  1341. 			    }

    1342. 

  1342. 			

    1343. 

  1343. 			    public static bool IsFloating(Type type) {

    1344. 

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

    1345. 

  1345. 			            case TypeCode.Single:

    1346. 

  1346. 			            case TypeCode.Double:

    1347. 

  1347. 			                return true;

    1348. 

  1348. 			            default:

    1349. 

  1349. 			                return false;

    1350. 

  1350. 			        }

    1351. 

  1351. 			    }

    1352. 

  1352. 			

    1353. 

  1353. 			    public static Type GetNonNullableType(Type type) {

    1354. 

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

    1355. 

  1355. 			                type.GetGenericArguments()[0] :

    1356. 

  1356. 			                type;

    1357. 

  1357. 			    }

    1358. 

  1358. 			}

    1359. 

  1359. 			

    1360. 

  1360. 		

    1361. 

  1361. 	}

    1362. 

  1362. 			

    1363. 

  1363. 			//-------- Scenario 3134

    1364. 

  1364. 			namespace Scenario3134{

    1365. 

  1365. 				

    1366. 

  1366. 				public class Test

    1367. 

  1367. 				{

    1368. 

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

    1369. 

  1369. 			    public static Expression decimal_ArrayIndex__() {

    1370. 

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

    1371. 

  1371. 			           throw new Exception();

    1372. 

  1372. 			       } else { 

    1373. 

  1373. 			           return Expression.Constant(0);

    1374. 

  1374. 			       }

    1375. 

  1375. 			    }

    1376. 

  1376. 				public     static int Main()

    1377. 

  1377. 				    {

    1378. 

  1378. 				        Ext.StartCapture();

    1379. 

  1379. 				        bool success = false;

    1380. 

  1380. 				        try

    1381. 

  1381. 				        {

    1382. 

  1382. 				            success = check_decimal_ArrayIndex();

    1383. 

  1383. 				        }

    1384. 

  1384. 				        finally

    1385. 

  1385. 				        {

    1386. 

  1386. 				            Ext.StopCapture();

    1387. 

  1387. 				        }

    1388. 

  1388. 				        return success ? 0 : 1;

    1389. 

  1389. 				    }

    1390. 

  1390. 				

    1391. 

  1391. 				    static bool check_decimal_ArrayIndex()

    1392. 

  1392. 				    {

    1393. 

  1393. 				        return checkEx_decimal_ArrayIndex(null, -1) &

    1394. 

  1394. 				            checkEx_decimal_ArrayIndex(null, 0) &

    1395. 

  1395. 				            checkEx_decimal_ArrayIndex(null, 1) &

    1396. 

  1396. 				

    1397. 

  1397. 				            check_decimal_ArrayIndex(genArrdecimal_ArrayIndex(0)) &

    1398. 

  1398. 				            check_decimal_ArrayIndex(genArrdecimal_ArrayIndex(1)) &

    1399. 

  1399. 				            check_decimal_ArrayIndex(genArrdecimal_ArrayIndex(5));

    1400. 

  1400. 				    }

    1401. 

  1401. 				

    1402. 

  1402. 				    static decimal[] genArrdecimal_ArrayIndex(int size)

    1403. 

  1403. 				    {

    1404. 

  1404. 				        decimal[] vals = new decimal[] { decimal.Zero, decimal.One, decimal.MinusOne, decimal.MinValue, decimal.MaxValue };

    1405. 

  1405. 				        decimal[] result = new decimal[size];

    1406. 

  1406. 				        for (int i = 0; i < size; i++)

    1407. 

  1407. 				        {

    1408. 

  1408. 				            result[i] = vals[i % vals.Length];

    1409. 

  1409. 				        }

    1410. 

  1410. 				        return result;

    1411. 

  1411. 				    }

    1412. 

  1412. 				

    1413. 

  1413. 				    static bool check_decimal_ArrayIndex(decimal[] val)

    1414. 

  1414. 				    {

    1415. 

  1415. 				        bool success = checkEx_decimal_ArrayIndex(val, -1);

    1416. 

  1416. 				        for (int i = 0; i < val.Length; i++)

    1417. 

  1417. 				        {

    1418. 

  1418. 				            success &= check_decimal_ArrayIndex(val, 0);

    1419. 

  1419. 				        }

    1420. 

  1420. 				        success &= checkEx_decimal_ArrayIndex(val, val.Length);

    1421. 

  1421. 				        return success;

    1422. 

  1422. 				    }

    1423. 

  1423. 				

    1424. 

  1424. 				    static bool checkEx_decimal_ArrayIndex(decimal[] val, int index)

    1425. 

  1425. 				    {

    1426. 

  1426. 				        try

    1427. 

  1427. 				        {

    1428. 

  1428. 				            check_decimal_ArrayIndex(val, index);

    1429. 

  1429. 				            Console.WriteLine("decimal_ArrayIndex[" + index + "] failed");

    1430. 

  1430. 				            return false;

    1431. 

  1431. 				        }

    1432. 

  1432. 				        catch

    1433. 

  1433. 				        {

    1434. 

  1434. 				            return true;

    1435. 

  1435. 				        }

    1436. 

  1436. 				    }

    1437. 

  1437. 				

    1438. 

  1438. 				    static bool check_decimal_ArrayIndex(decimal[] val, int index)

    1439. 

  1439. 				    {

    1440. 

  1440. 				        Expression<Func<decimal>> e =

    1441. 

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

    1442. 

  1442. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(decimal[])),

    1443. 

  1443. 				                    Expression.Constant(index, typeof(int))),

    1444. 

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

    1445. 

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

    1446. 

  1446. 				        return object.Equals(f(), val[index]);

    1447. 

  1447. 				    }

    1448. 

  1448. 				}

    1449. 

  1449. 			

    1450. 

  1450. 			

    1451. 

  1451. 			public  static class Ext {

    1452. 

  1452. 			    public static void StartCapture() {

    1453. 

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

    1454. 

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

    1455. 

  1455. 			    }

    1456. 

  1456. 			

    1457. 

  1457. 			    public static void StopCapture() {

    1458. 

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

    1459. 

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

    1460. 

  1460. 			    }

    1461. 

  1461. 			

    1462. 

  1462. 			    public static bool IsIntegralOrEnum(Type type) {

    1463. 

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

    1464. 

  1464. 			            case TypeCode.Byte:

    1465. 

  1465. 			            case TypeCode.SByte:

    1466. 

  1466. 			            case TypeCode.Int16:

    1467. 

  1467. 			            case TypeCode.Int32:

    1468. 

  1468. 			            case TypeCode.Int64:

    1469. 

  1469. 			            case TypeCode.UInt16:

    1470. 

  1470. 			            case TypeCode.UInt32:

    1471. 

  1471. 			            case TypeCode.UInt64:

    1472. 

  1472. 			                return true;

    1473. 

  1473. 			            default:

    1474. 

  1474. 			                return false;

    1475. 

  1475. 			        }

    1476. 

  1476. 			    }

    1477. 

  1477. 			

    1478. 

  1478. 			    public static bool IsFloating(Type type) {

    1479. 

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

    1480. 

  1480. 			            case TypeCode.Single:

    1481. 

  1481. 			            case TypeCode.Double:

    1482. 

  1482. 			                return true;

    1483. 

  1483. 			            default:

    1484. 

  1484. 			                return false;

    1485. 

  1485. 			        }

    1486. 

  1486. 			    }

    1487. 

  1487. 			

    1488. 

  1488. 			    public static Type GetNonNullableType(Type type) {

    1489. 

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

    1490. 

  1490. 			                type.GetGenericArguments()[0] :

    1491. 

  1491. 			                type;

    1492. 

  1492. 			    }

    1493. 

  1493. 			}

    1494. 

  1494. 			

    1495. 

  1495. 		

    1496. 

  1496. 	}

    1497. 

  1497. 			

    1498. 

  1498. 			//-------- Scenario 3135

    1499. 

  1499. 			namespace Scenario3135{

    1500. 

  1500. 				

    1501. 

  1501. 				public class Test

    1502. 

  1502. 				{

    1503. 

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

    1504. 

  1504. 			    public static Expression char_ArrayIndex__() {

    1505. 

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

    1506. 

  1506. 			           throw new Exception();

    1507. 

  1507. 			       } else { 

    1508. 

  1508. 			           return Expression.Constant(0);

    1509. 

  1509. 			       }

    1510. 

  1510. 			    }

    1511. 

  1511. 				public     static int Main()

    1512. 

  1512. 				    {

    1513. 

  1513. 				        Ext.StartCapture();

    1514. 

  1514. 				        bool success = false;

    1515. 

  1515. 				        try

    1516. 

  1516. 				        {

    1517. 

  1517. 				            success = check_char_ArrayIndex();

    1518. 

  1518. 				        }

    1519. 

  1519. 				        finally

    1520. 

  1520. 				        {

    1521. 

  1521. 				            Ext.StopCapture();

    1522. 

  1522. 				        }

    1523. 

  1523. 				        return success ? 0 : 1;

    1524. 

  1524. 				    }

    1525. 

  1525. 				

    1526. 

  1526. 				    static bool check_char_ArrayIndex()

    1527. 

  1527. 				    {

    1528. 

  1528. 				        return checkEx_char_ArrayIndex(null, -1) &

    1529. 

  1529. 				            checkEx_char_ArrayIndex(null, 0) &

    1530. 

  1530. 				            checkEx_char_ArrayIndex(null, 1) &

    1531. 

  1531. 				

    1532. 

  1532. 				            check_char_ArrayIndex(genArrchar_ArrayIndex(0)) &

    1533. 

  1533. 				            check_char_ArrayIndex(genArrchar_ArrayIndex(1)) &

    1534. 

  1534. 				            check_char_ArrayIndex(genArrchar_ArrayIndex(5));

    1535. 

  1535. 				    }

    1536. 

  1536. 				

    1537. 

  1537. 				    static char[] genArrchar_ArrayIndex(int size)

    1538. 

  1538. 				    {

    1539. 

  1539. 				        char[] vals = new char[] { '\0', '\b', 'A', '\uffff' };

    1540. 

  1540. 				        char[] result = new char[size];

    1541. 

  1541. 				        for (int i = 0; i < size; i++)

    1542. 

  1542. 				        {

    1543. 

  1543. 				            result[i] = vals[i % vals.Length];

    1544. 

  1544. 				        }

    1545. 

  1545. 				        return result;

    1546. 

  1546. 				    }

    1547. 

  1547. 				

    1548. 

  1548. 				    static bool check_char_ArrayIndex(char[] val)

    1549. 

  1549. 				    {

    1550. 

  1550. 				        bool success = checkEx_char_ArrayIndex(val, -1);

    1551. 

  1551. 				        for (int i = 0; i < val.Length; i++)

    1552. 

  1552. 				        {

    1553. 

  1553. 				            success &= check_char_ArrayIndex(val, 0);

    1554. 

  1554. 				        }

    1555. 

  1555. 				        success &= checkEx_char_ArrayIndex(val, val.Length);

    1556. 

  1556. 				        return success;

    1557. 

  1557. 				    }

    1558. 

  1558. 				

    1559. 

  1559. 				    static bool checkEx_char_ArrayIndex(char[] val, int index)

    1560. 

  1560. 				    {

    1561. 

  1561. 				        try

    1562. 

  1562. 				        {

    1563. 

  1563. 				            check_char_ArrayIndex(val, index);

    1564. 

  1564. 				            Console.WriteLine("char_ArrayIndex[" + index + "] failed");

    1565. 

  1565. 				            return false;

    1566. 

  1566. 				        }

    1567. 

  1567. 				        catch

    1568. 

  1568. 				        {

    1569. 

  1569. 				            return true;

    1570. 

  1570. 				        }

    1571. 

  1571. 				    }

    1572. 

  1572. 				

    1573. 

  1573. 				    static bool check_char_ArrayIndex(char[] val, int index)

    1574. 

  1574. 				    {

    1575. 

  1575. 				        Expression<Func<char>> e =

    1576. 

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

    1577. 

  1577. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(char[])),

    1578. 

  1578. 				                    Expression.Constant(index, typeof(int))),

    1579. 

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

    1580. 

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

    1581. 

  1581. 				        return object.Equals(f(), val[index]);

    1582. 

  1582. 				    }

    1583. 

  1583. 				}

    1584. 

  1584. 			

    1585. 

  1585. 			

    1586. 

  1586. 			public  static class Ext {

    1587. 

  1587. 			    public static void StartCapture() {

    1588. 

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

    1589. 

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

    1590. 

  1590. 			    }

    1591. 

  1591. 			

    1592. 

  1592. 			    public static void StopCapture() {

    1593. 

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

    1594. 

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

    1595. 

  1595. 			    }

    1596. 

  1596. 			

    1597. 

  1597. 			    public static bool IsIntegralOrEnum(Type type) {

    1598. 

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

    1599. 

  1599. 			            case TypeCode.Byte:

    1600. 

  1600. 			            case TypeCode.SByte:

    1601. 

  1601. 			            case TypeCode.Int16:

    1602. 

  1602. 			            case TypeCode.Int32:

    1603. 

  1603. 			            case TypeCode.Int64:

    1604. 

  1604. 			            case TypeCode.UInt16:

    1605. 

  1605. 			            case TypeCode.UInt32:

    1606. 

  1606. 			            case TypeCode.UInt64:

    1607. 

  1607. 			                return true;

    1608. 

  1608. 			            default:

    1609. 

  1609. 			                return false;

    1610. 

  1610. 			        }

    1611. 

  1611. 			    }

    1612. 

  1612. 			

    1613. 

  1613. 			    public static bool IsFloating(Type type) {

    1614. 

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

    1615. 

  1615. 			            case TypeCode.Single:

    1616. 

  1616. 			            case TypeCode.Double:

    1617. 

  1617. 			                return true;

    1618. 

  1618. 			            default:

    1619. 

  1619. 			                return false;

    1620. 

  1620. 			        }

    1621. 

  1621. 			    }

    1622. 

  1622. 			

    1623. 

  1623. 			    public static Type GetNonNullableType(Type type) {

    1624. 

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

    1625. 

  1625. 			                type.GetGenericArguments()[0] :

    1626. 

  1626. 			                type;

    1627. 

  1627. 			    }

    1628. 

  1628. 			}

    1629. 

  1629. 			

    1630. 

  1630. 		

    1631. 

  1631. 	}

    1632. 

  1632. 			

    1633. 

  1633. 			//-------- Scenario 3136

    1634. 

  1634. 			namespace Scenario3136{

    1635. 

  1635. 				

    1636. 

  1636. 				public class Test

    1637. 

  1637. 				{

    1638. 

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

    1639. 

  1639. 			    public static Expression bool_ArrayIndex__() {

    1640. 

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

    1641. 

  1641. 			           throw new Exception();

    1642. 

  1642. 			       } else { 

    1643. 

  1643. 			           return Expression.Constant(0);

    1644. 

  1644. 			       }

    1645. 

  1645. 			    }

    1646. 

  1646. 				public     static int Main()

    1647. 

  1647. 				    {

    1648. 

  1648. 				        Ext.StartCapture();

    1649. 

  1649. 				        bool success = false;

    1650. 

  1650. 				        try

    1651. 

  1651. 				        {

    1652. 

  1652. 				            success = check_bool_ArrayIndex();

    1653. 

  1653. 				        }

    1654. 

  1654. 				        finally

    1655. 

  1655. 				        {

    1656. 

  1656. 				            Ext.StopCapture();

    1657. 

  1657. 				        }

    1658. 

  1658. 				        return success ? 0 : 1;

    1659. 

  1659. 				    }

    1660. 

  1660. 				

    1661. 

  1661. 				    static bool check_bool_ArrayIndex()

    1662. 

  1662. 				    {

    1663. 

  1663. 				        return checkEx_bool_ArrayIndex(null, -1) &

    1664. 

  1664. 				            checkEx_bool_ArrayIndex(null, 0) &

    1665. 

  1665. 				            checkEx_bool_ArrayIndex(null, 1) &

    1666. 

  1666. 				

    1667. 

  1667. 				            check_bool_ArrayIndex(genArrbool_ArrayIndex(0)) &

    1668. 

  1668. 				            check_bool_ArrayIndex(genArrbool_ArrayIndex(1)) &

    1669. 

  1669. 				            check_bool_ArrayIndex(genArrbool_ArrayIndex(5));

    1670. 

  1670. 				    }

    1671. 

  1671. 				

    1672. 

  1672. 				    static bool[] genArrbool_ArrayIndex(int size)

    1673. 

  1673. 				    {

    1674. 

  1674. 				        bool[] vals = new bool[] { true, false };

    1675. 

  1675. 				        bool[] result = new bool[size];

    1676. 

  1676. 				        for (int i = 0; i < size; i++)

    1677. 

  1677. 				        {

    1678. 

  1678. 				            result[i] = vals[i % vals.Length];

    1679. 

  1679. 				        }

    1680. 

  1680. 				        return result;

    1681. 

  1681. 				    }

    1682. 

  1682. 				

    1683. 

  1683. 				    static bool check_bool_ArrayIndex(bool[] val)

    1684. 

  1684. 				    {

    1685. 

  1685. 				        bool success = checkEx_bool_ArrayIndex(val, -1);

    1686. 

  1686. 				        for (int i = 0; i < val.Length; i++)

    1687. 

  1687. 				        {

    1688. 

  1688. 				            success &= check_bool_ArrayIndex(val, 0);

    1689. 

  1689. 				        }

    1690. 

  1690. 				        success &= checkEx_bool_ArrayIndex(val, val.Length);

    1691. 

  1691. 				        return success;

    1692. 

  1692. 				    }

    1693. 

  1693. 				

    1694. 

  1694. 				    static bool checkEx_bool_ArrayIndex(bool[] val, int index)

    1695. 

  1695. 				    {

    1696. 

  1696. 				        try

    1697. 

  1697. 				        {

    1698. 

  1698. 				            check_bool_ArrayIndex(val, index);

    1699. 

  1699. 				            Console.WriteLine("bool_ArrayIndex[" + index + "] failed");

    1700. 

  1700. 				            return false;

    1701. 

  1701. 				        }

    1702. 

  1702. 				        catch

    1703. 

  1703. 				        {

    1704. 

  1704. 				            return true;

    1705. 

  1705. 				        }

    1706. 

  1706. 				    }

    1707. 

  1707. 				

    1708. 

  1708. 				    static bool check_bool_ArrayIndex(bool[] val, int index)

    1709. 

  1709. 				    {

    1710. 

  1710. 				        Expression<Func<bool>> e =

    1711. 

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

    1712. 

  1712. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(bool[])),

    1713. 

  1713. 				                    Expression.Constant(index, typeof(int))),

    1714. 

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

    1715. 

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

    1716. 

  1716. 				        return object.Equals(f(), val[index]);

    1717. 

  1717. 				    }

    1718. 

  1718. 				}

    1719. 

  1719. 			

    1720. 

  1720. 			

    1721. 

  1721. 			public  static class Ext {

    1722. 

  1722. 			    public static void StartCapture() {

    1723. 

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

    1724. 

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

    1725. 

  1725. 			    }

    1726. 

  1726. 			

    1727. 

  1727. 			    public static void StopCapture() {

    1728. 

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

    1729. 

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

    1730. 

  1730. 			    }

    1731. 

  1731. 			

    1732. 

  1732. 			    public static bool IsIntegralOrEnum(Type type) {

    1733. 

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

    1734. 

  1734. 			            case TypeCode.Byte:

    1735. 

  1735. 			            case TypeCode.SByte:

    1736. 

  1736. 			            case TypeCode.Int16:

    1737. 

  1737. 			            case TypeCode.Int32:

    1738. 

  1738. 			            case TypeCode.Int64:

    1739. 

  1739. 			            case TypeCode.UInt16:

    1740. 

  1740. 			            case TypeCode.UInt32:

    1741. 

  1741. 			            case TypeCode.UInt64:

    1742. 

  1742. 			                return true;

    1743. 

  1743. 			            default:

    1744. 

  1744. 			                return false;

    1745. 

  1745. 			        }

    1746. 

  1746. 			    }

    1747. 

  1747. 			

    1748. 

  1748. 			    public static bool IsFloating(Type type) {

    1749. 

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

    1750. 

  1750. 			            case TypeCode.Single:

    1751. 

  1751. 			            case TypeCode.Double:

    1752. 

  1752. 			                return true;

    1753. 

  1753. 			            default:

    1754. 

  1754. 			                return false;

    1755. 

  1755. 			        }

    1756. 

  1756. 			    }

    1757. 

  1757. 			

    1758. 

  1758. 			    public static Type GetNonNullableType(Type type) {

    1759. 

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

    1760. 

  1760. 			                type.GetGenericArguments()[0] :

    1761. 

  1761. 			                type;

    1762. 

  1762. 			    }

    1763. 

  1763. 			}

    1764. 

  1764. 			

    1765. 

  1765. 		

    1766. 

  1766. 	}

    1767. 

  1767. 				

    1768. 

  1768. 				//-------- Scenario 3137

    1769. 

  1769. 				namespace Scenario3137{

    1770. 

  1770. 					

    1771. 

  1771. 					public class Test

    1772. 

  1772. 					{

    1773. 

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

    1774. 

  1774. 				    public static Expression S_ArrayIndex__() {

    1775. 

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

    1776. 

  1776. 				           throw new Exception();

    1777. 

  1777. 				       } else { 

    1778. 

  1778. 				           return Expression.Constant(0);

    1779. 

  1779. 				       }

    1780. 

  1780. 				    }

    1781. 

  1781. 					public     static int Main()

    1782. 

  1782. 					    {

    1783. 

  1783. 					        Ext.StartCapture();

    1784. 

  1784. 					        bool success = false;

    1785. 

  1785. 					        try

    1786. 

  1786. 					        {

    1787. 

  1787. 					            success = check_S_ArrayIndex();

    1788. 

  1788. 					        }

    1789. 

  1789. 					        finally

    1790. 

  1790. 					        {

    1791. 

  1791. 					            Ext.StopCapture();

    1792. 

  1792. 					        }

    1793. 

  1793. 					        return success ? 0 : 1;

    1794. 

  1794. 					    }

    1795. 

  1795. 					

    1796. 

  1796. 					    static bool check_S_ArrayIndex()

    1797. 

  1797. 					    {

    1798. 

  1798. 					        return checkEx_S_ArrayIndex(null, -1) &

    1799. 

  1799. 					            checkEx_S_ArrayIndex(null, 0) &

    1800. 

  1800. 					            checkEx_S_ArrayIndex(null, 1) &

    1801. 

  1801. 					

    1802. 

  1802. 					            check_S_ArrayIndex(genArrS_ArrayIndex(0)) &

    1803. 

  1803. 					            check_S_ArrayIndex(genArrS_ArrayIndex(1)) &

    1804. 

  1804. 					            check_S_ArrayIndex(genArrS_ArrayIndex(5));

    1805. 

  1805. 					    }

    1806. 

  1806. 					

    1807. 

  1807. 					    static S[] genArrS_ArrayIndex(int size)

    1808. 

  1808. 					    {

    1809. 

  1809. 					        S[] vals = new S[] { default(S), new S() };

    1810. 

  1810. 					        S[] result = new S[size];

    1811. 

  1811. 					        for (int i = 0; i < size; i++)

    1812. 

  1812. 					        {

    1813. 

  1813. 					            result[i] = vals[i % vals.Length];

    1814. 

  1814. 					        }

    1815. 

  1815. 					        return result;

    1816. 

  1816. 					    }

    1817. 

  1817. 					

    1818. 

  1818. 					    static bool check_S_ArrayIndex(S[] val)

    1819. 

  1819. 					    {

    1820. 

  1820. 					        bool success = checkEx_S_ArrayIndex(val, -1);

    1821. 

  1821. 					        for (int i = 0; i < val.Length; i++)

    1822. 

  1822. 					        {

    1823. 

  1823. 					            success &= check_S_ArrayIndex(val, 0);

    1824. 

  1824. 					        }

    1825. 

  1825. 					        success &= checkEx_S_ArrayIndex(val, val.Length);

    1826. 

  1826. 					        return success;

    1827. 

  1827. 					    }

    1828. 

  1828. 					

    1829. 

  1829. 					    static bool checkEx_S_ArrayIndex(S[] val, int index)

    1830. 

  1830. 					    {

    1831. 

  1831. 					        try

    1832. 

  1832. 					        {

    1833. 

  1833. 					            check_S_ArrayIndex(val, index);

    1834. 

  1834. 					            Console.WriteLine("S_ArrayIndex[" + index + "] failed");

    1835. 

  1835. 					            return false;

    1836. 

  1836. 					        }

    1837. 

  1837. 					        catch

    1838. 

  1838. 					        {

    1839. 

  1839. 					            return true;

    1840. 

  1840. 					        }

    1841. 

  1841. 					    }

    1842. 

  1842. 					

    1843. 

  1843. 					    static bool check_S_ArrayIndex(S[] val, int index)

    1844. 

  1844. 					    {

    1845. 

  1845. 					        Expression<Func<S>> e =

    1846. 

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

    1847. 

  1847. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(S[])),

    1848. 

  1848. 					                    Expression.Constant(index, typeof(int))),

    1849. 

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

    1850. 

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

    1851. 

  1851. 					        return object.Equals(f(), val[index]);

    1852. 

  1852. 					    }

    1853. 

  1853. 					}

    1854. 

  1854. 				

    1855. 

  1855. 				

    1856. 

  1856. 				public  static class Ext {

    1857. 

  1857. 				    public static void StartCapture() {

    1858. 

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

    1859. 

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

    1860. 

  1860. 				    }

    1861. 

  1861. 				

    1862. 

  1862. 				    public static void StopCapture() {

    1863. 

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

    1864. 

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

    1865. 

  1865. 				    }

    1866. 

  1866. 				

    1867. 

  1867. 				    public static bool IsIntegralOrEnum(Type type) {

    1868. 

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

    1869. 

  1869. 				            case TypeCode.Byte:

    1870. 

  1870. 				            case TypeCode.SByte:

    1871. 

  1871. 				            case TypeCode.Int16:

    1872. 

  1872. 				            case TypeCode.Int32:

    1873. 

  1873. 				            case TypeCode.Int64:

    1874. 

  1874. 				            case TypeCode.UInt16:

    1875. 

  1875. 				            case TypeCode.UInt32:

    1876. 

  1876. 				            case TypeCode.UInt64:

    1877. 

  1877. 				                return true;

    1878. 

  1878. 				            default:

    1879. 

  1879. 				                return false;

    1880. 

  1880. 				        }

    1881. 

  1881. 				    }

    1882. 

  1882. 				

    1883. 

  1883. 				    public static bool IsFloating(Type type) {

    1884. 

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

    1885. 

  1885. 				            case TypeCode.Single:

    1886. 

  1886. 				            case TypeCode.Double:

    1887. 

  1887. 				                return true;

    1888. 

  1888. 				            default:

    1889. 

  1889. 				                return false;

    1890. 

  1890. 				        }

    1891. 

  1891. 				    }

    1892. 

  1892. 				

    1893. 

  1893. 				    public static Type GetNonNullableType(Type type) {

    1894. 

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

    1895. 

  1895. 				                type.GetGenericArguments()[0] :

    1896. 

  1896. 				                type;

    1897. 

  1897. 				    }

    1898. 

  1898. 				}

    1899. 

  1899. 				

    1900. 

  1900. 			

    1901. 

  1901. 			

    1902. 

  1902. 			

    1903. 

  1903. 			public interface I

    1904. 

  1904. 			{

    1905. 

  1905. 			    void M();

    1906. 

  1906. 			}

    1907. 

  1907. 			

    1908. 

  1908. 			public  class C : IEquatable<C>, I

    1909. 

  1909. 			{

    1910. 

  1910. 			    void I.M()

    1911. 

  1911. 			    {

    1912. 

  1912. 			    }

    1913. 

  1913. 			

    1914. 

  1914. 			    public override bool Equals(object o)

    1915. 

  1915. 			    {

    1916. 

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

    1917. 

  1917. 			    }

    1918. 

  1918. 			

    1919. 

  1919. 			    public bool Equals(C c)

    1920. 

  1920. 			    {

    1921. 

  1921. 			        return c != null;

    1922. 

  1922. 			    }

    1923. 

  1923. 			

    1924. 

  1924. 			    public override int GetHashCode()

    1925. 

  1925. 			    {

    1926. 

  1926. 			        return 0;

    1927. 

  1927. 			    }

    1928. 

  1928. 			}

    1929. 

  1929. 			

    1930. 

  1930. 			public  class D : C, IEquatable<D>

    1931. 

  1931. 			{

    1932. 

  1932. 			    public int Val;

    1933. 

  1933. 			    public D()

    1934. 

  1934. 			    {

    1935. 

  1935. 			    }

    1936. 

  1936. 			    public D(int val)

    1937. 

  1937. 			    {

    1938. 

  1938. 			        Val = val;

    1939. 

  1939. 			    }

    1940. 

  1940. 			

    1941. 

  1941. 			    public override bool Equals(object o)

    1942. 

  1942. 			    {

    1943. 

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

    1944. 

  1944. 			    }

    1945. 

  1945. 			

    1946. 

  1946. 			    public bool Equals(D d)

    1947. 

  1947. 			    {

    1948. 

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

    1949. 

  1949. 			    }

    1950. 

  1950. 			

    1951. 

  1951. 			    public override int GetHashCode()

    1952. 

  1952. 			    {

    1953. 

  1953. 			        return Val;

    1954. 

  1954. 			    }

    1955. 

  1955. 			}

    1956. 

  1956. 			

    1957. 

  1957. 			public enum E

    1958. 

  1958. 			{

    1959. 

  1959. 			    A = 1, B = 2

    1960. 

  1960. 			}

    1961. 

  1961. 			

    1962. 

  1962. 			public enum El : long

    1963. 

  1963. 			{

    1964. 

  1964. 			    A, B, C

    1965. 

  1965. 			}

    1966. 

  1966. 			

    1967. 

  1967. 			public struct S : IEquatable<S>

    1968. 

  1968. 			{

    1969. 

  1969. 			    public override bool Equals(object o)

    1970. 

  1970. 			    {

    1971. 

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

    1972. 

  1972. 			    }

    1973. 

  1973. 			    public bool Equals(S other)

    1974. 

  1974. 			    {

    1975. 

  1975. 			        return true;

    1976. 

  1976. 			    }

    1977. 

  1977. 			    public override int GetHashCode()

    1978. 

  1978. 			    {

    1979. 

  1979. 			        return 0;

    1980. 

  1980. 			    }

    1981. 

  1981. 			}

    1982. 

  1982. 			

    1983. 

  1983. 			public struct Sp : IEquatable<Sp>

    1984. 

  1984. 			{

    1985. 

  1985. 			    public Sp(int i, double d)

    1986. 

  1986. 			    {

    1987. 

  1987. 			        I = i;

    1988. 

  1988. 			        D = d;

    1989. 

  1989. 			    }

    1990. 

  1990. 			

    1991. 

  1991. 			    public int I;

    1992. 

  1992. 			    public double D;

    1993. 

  1993. 			

    1994. 

  1994. 			    public override bool Equals(object o)

    1995. 

  1995. 			    {

    1996. 

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

    1997. 

  1997. 			    }

    1998. 

  1998. 			    public bool Equals(Sp other)

    1999. 

  1999. 			    {

    2000. 

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

    2001. 

  2001. 			    }

    2002. 

  2002. 			    public override int GetHashCode()

    2003. 

  2003. 			    {

    2004. 

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

    2005. 

  2005. 			    }

    2006. 

  2006. 			}

    2007. 

  2007. 			

    2008. 

  2008. 			public struct Ss : IEquatable<Ss>

    2009. 

  2009. 			{

    2010. 

  2010. 			    public Ss(S s)

    2011. 

  2011. 			    {

    2012. 

  2012. 			        Val = s;

    2013. 

  2013. 			    }

    2014. 

  2014. 			

    2015. 

  2015. 			    public S Val;

    2016. 

  2016. 			

    2017. 

  2017. 			    public override bool Equals(object o)

    2018. 

  2018. 			    {

    2019. 

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

    2020. 

  2020. 			    }

    2021. 

  2021. 			    public bool Equals(Ss other)

    2022. 

  2022. 			    {

    2023. 

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

    2024. 

  2024. 			    }

    2025. 

  2025. 			    public override int GetHashCode()

    2026. 

  2026. 			    {

    2027. 

  2027. 			        return Val.GetHashCode();

    2028. 

  2028. 			    }

    2029. 

  2029. 			}

    2030. 

  2030. 			

    2031. 

  2031. 			public struct Sc : IEquatable<Sc>

    2032. 

  2032. 			{

    2033. 

  2033. 			    public Sc(string s)

    2034. 

  2034. 			    {

    2035. 

  2035. 			        S = s;

    2036. 

  2036. 			    }

    2037. 

  2037. 			

    2038. 

  2038. 			    public string S;

    2039. 

  2039. 			

    2040. 

  2040. 			    public override bool Equals(object o)

    2041. 

  2041. 			    {

    2042. 

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

    2043. 

  2043. 			    }

    2044. 

  2044. 			    public bool Equals(Sc other)

    2045. 

  2045. 			    {

    2046. 

  2046. 			        return other.S == S;

    2047. 

  2047. 			    }

    2048. 

  2048. 			    public override int GetHashCode()

    2049. 

  2049. 			    {

    2050. 

  2050. 			        return S.GetHashCode();

    2051. 

  2051. 			    }

    2052. 

  2052. 			}

    2053. 

  2053. 			

    2054. 

  2054. 			public struct Scs : IEquatable<Scs>

    2055. 

  2055. 			{

    2056. 

  2056. 			    public Scs(string s, S val)

    2057. 

  2057. 			    {

    2058. 

  2058. 			        S = s;

    2059. 

  2059. 			        Val = val;

    2060. 

  2060. 			    }

    2061. 

  2061. 			

    2062. 

  2062. 			    public string S;

    2063. 

  2063. 			    public S Val;

    2064. 

  2064. 			

    2065. 

  2065. 			    public override bool Equals(object o)

    2066. 

  2066. 			    {

    2067. 

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

    2068. 

  2068. 			    }

    2069. 

  2069. 			    public bool Equals(Scs other)

    2070. 

  2070. 			    {

    2071. 

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

    2072. 

  2072. 			    }

    2073. 

  2073. 			    public override int GetHashCode()

    2074. 

  2074. 			    {

    2075. 

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

    2076. 

  2076. 			    }

    2077. 

  2077. 			}

    2078. 

  2078. 			

    2079. 

  2079. 		

    2080. 

  2080. 	}

    2081. 

  2081. 				

    2082. 

  2082. 				//-------- Scenario 3138

    2083. 

  2083. 				namespace Scenario3138{

    2084. 

  2084. 					

    2085. 

  2085. 					public class Test

    2086. 

  2086. 					{

    2087. 

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

    2088. 

  2088. 				    public static Expression Sp_ArrayIndex__() {

    2089. 

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

    2090. 

  2090. 				           throw new Exception();

    2091. 

  2091. 				       } else { 

    2092. 

  2092. 				           return Expression.Constant(0);

    2093. 

  2093. 				       }

    2094. 

  2094. 				    }

    2095. 

  2095. 					public     static int Main()

    2096. 

  2096. 					    {

    2097. 

  2097. 					        Ext.StartCapture();

    2098. 

  2098. 					        bool success = false;

    2099. 

  2099. 					        try

    2100. 

  2100. 					        {

    2101. 

  2101. 					            success = check_Sp_ArrayIndex();

    2102. 

  2102. 					        }

    2103. 

  2103. 					        finally

    2104. 

  2104. 					        {

    2105. 

  2105. 					            Ext.StopCapture();

    2106. 

  2106. 					        }

    2107. 

  2107. 					        return success ? 0 : 1;

    2108. 

  2108. 					    }

    2109. 

  2109. 					

    2110. 

  2110. 					    static bool check_Sp_ArrayIndex()

    2111. 

  2111. 					    {

    2112. 

  2112. 					        return checkEx_Sp_ArrayIndex(null, -1) &

    2113. 

  2113. 					            checkEx_Sp_ArrayIndex(null, 0) &

    2114. 

  2114. 					            checkEx_Sp_ArrayIndex(null, 1) &

    2115. 

  2115. 					

    2116. 

  2116. 					            check_Sp_ArrayIndex(genArrSp_ArrayIndex(0)) &

    2117. 

  2117. 					            check_Sp_ArrayIndex(genArrSp_ArrayIndex(1)) &

    2118. 

  2118. 					            check_Sp_ArrayIndex(genArrSp_ArrayIndex(5));

    2119. 

  2119. 					    }

    2120. 

  2120. 					

    2121. 

  2121. 					    static Sp[] genArrSp_ArrayIndex(int size)

    2122. 

  2122. 					    {

    2123. 

  2123. 					        Sp[] vals = new Sp[] { default(Sp), new Sp(), new Sp(5, 5.0) };

    2124. 

  2124. 					        Sp[] result = new Sp[size];

    2125. 

  2125. 					        for (int i = 0; i < size; i++)

    2126. 

  2126. 					        {

    2127. 

  2127. 					            result[i] = vals[i % vals.Length];

    2128. 

  2128. 					        }

    2129. 

  2129. 					        return result;

    2130. 

  2130. 					    }

    2131. 

  2131. 					

    2132. 

  2132. 					    static bool check_Sp_ArrayIndex(Sp[] val)

    2133. 

  2133. 					    {

    2134. 

  2134. 					        bool success = checkEx_Sp_ArrayIndex(val, -1);

    2135. 

  2135. 					        for (int i = 0; i < val.Length; i++)

    2136. 

  2136. 					        {

    2137. 

  2137. 					            success &= check_Sp_ArrayIndex(val, 0);

    2138. 

  2138. 					        }

    2139. 

  2139. 					        success &= checkEx_Sp_ArrayIndex(val, val.Length);

    2140. 

  2140. 					        return success;

    2141. 

  2141. 					    }

    2142. 

  2142. 					

    2143. 

  2143. 					    static bool checkEx_Sp_ArrayIndex(Sp[] val, int index)

    2144. 

  2144. 					    {

    2145. 

  2145. 					        try

    2146. 

  2146. 					        {

    2147. 

  2147. 					            check_Sp_ArrayIndex(val, index);

    2148. 

  2148. 					            Console.WriteLine("Sp_ArrayIndex[" + index + "] failed");

    2149. 

  2149. 					            return false;

    2150. 

  2150. 					        }

    2151. 

  2151. 					        catch

    2152. 

  2152. 					        {

    2153. 

  2153. 					            return true;

    2154. 

  2154. 					        }

    2155. 

  2155. 					    }

    2156. 

  2156. 					

    2157. 

  2157. 					    static bool check_Sp_ArrayIndex(Sp[] val, int index)

    2158. 

  2158. 					    {

    2159. 

  2159. 					        Expression<Func<Sp>> e =

    2160. 

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

    2161. 

  2161. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Sp[])),

    2162. 

  2162. 					                    Expression.Constant(index, typeof(int))),

    2163. 

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

    2164. 

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

    2165. 

  2165. 					        return object.Equals(f(), val[index]);

    2166. 

  2166. 					    }

    2167. 

  2167. 					}

    2168. 

  2168. 				

    2169. 

  2169. 				

    2170. 

  2170. 				public  static class Ext {

    2171. 

  2171. 				    public static void StartCapture() {

    2172. 

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

    2173. 

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

    2174. 

  2174. 				    }

    2175. 

  2175. 				

    2176. 

  2176. 				    public static void StopCapture() {

    2177. 

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

    2178. 

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

    2179. 

  2179. 				    }

    2180. 

  2180. 				

    2181. 

  2181. 				    public static bool IsIntegralOrEnum(Type type) {

    2182. 

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

    2183. 

  2183. 				            case TypeCode.Byte:

    2184. 

  2184. 				            case TypeCode.SByte:

    2185. 

  2185. 				            case TypeCode.Int16:

    2186. 

  2186. 				            case TypeCode.Int32:

    2187. 

  2187. 				            case TypeCode.Int64:

    2188. 

  2188. 				            case TypeCode.UInt16:

    2189. 

  2189. 				            case TypeCode.UInt32:

    2190. 

  2190. 				            case TypeCode.UInt64:

    2191. 

  2191. 				                return true;

    2192. 

  2192. 				            default:

    2193. 

  2193. 				                return false;

    2194. 

  2194. 				        }

    2195. 

  2195. 				    }

    2196. 

  2196. 				

    2197. 

  2197. 				    public static bool IsFloating(Type type) {

    2198. 

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

    2199. 

  2199. 				            case TypeCode.Single:

    2200. 

  2200. 				            case TypeCode.Double:

    2201. 

  2201. 				                return true;

    2202. 

  2202. 				            default:

    2203. 

  2203. 				                return false;

    2204. 

  2204. 				        }

    2205. 

  2205. 				    }

    2206. 

  2206. 				

    2207. 

  2207. 				    public static Type GetNonNullableType(Type type) {

    2208. 

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

    2209. 

  2209. 				                type.GetGenericArguments()[0] :

    2210. 

  2210. 				                type;

    2211. 

  2211. 				    }

    2212. 

  2212. 				}

    2213. 

  2213. 				

    2214. 

  2214. 			

    2215. 

  2215. 			

    2216. 

  2216. 			

    2217. 

  2217. 			public interface I

    2218. 

  2218. 			{

    2219. 

  2219. 			    void M();

    2220. 

  2220. 			}

    2221. 

  2221. 			

    2222. 

  2222. 			public  class C : IEquatable<C>, I

    2223. 

  2223. 			{

    2224. 

  2224. 			    void I.M()

    2225. 

  2225. 			    {

    2226. 

  2226. 			    }

    2227. 

  2227. 			

    2228. 

  2228. 			    public override bool Equals(object o)

    2229. 

  2229. 			    {

    2230. 

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

    2231. 

  2231. 			    }

    2232. 

  2232. 			

    2233. 

  2233. 			    public bool Equals(C c)

    2234. 

  2234. 			    {

    2235. 

  2235. 			        return c != null;

    2236. 

  2236. 			    }

    2237. 

  2237. 			

    2238. 

  2238. 			    public override int GetHashCode()

    2239. 

  2239. 			    {

    2240. 

  2240. 			        return 0;

    2241. 

  2241. 			    }

    2242. 

  2242. 			}

    2243. 

  2243. 			

    2244. 

  2244. 			public  class D : C, IEquatable<D>

    2245. 

  2245. 			{

    2246. 

  2246. 			    public int Val;

    2247. 

  2247. 			    public D()

    2248. 

  2248. 			    {

    2249. 

  2249. 			    }

    2250. 

  2250. 			    public D(int val)

    2251. 

  2251. 			    {

    2252. 

  2252. 			        Val = val;

    2253. 

  2253. 			    }

    2254. 

  2254. 			

    2255. 

  2255. 			    public override bool Equals(object o)

    2256. 

  2256. 			    {

    2257. 

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

    2258. 

  2258. 			    }

    2259. 

  2259. 			

    2260. 

  2260. 			    public bool Equals(D d)

    2261. 

  2261. 			    {

    2262. 

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

    2263. 

  2263. 			    }

    2264. 

  2264. 			

    2265. 

  2265. 			    public override int GetHashCode()

    2266. 

  2266. 			    {

    2267. 

  2267. 			        return Val;

    2268. 

  2268. 			    }

    2269. 

  2269. 			}

    2270. 

  2270. 			

    2271. 

  2271. 			public enum E

    2272. 

  2272. 			{

    2273. 

  2273. 			    A = 1, B = 2

    2274. 

  2274. 			}

    2275. 

  2275. 			

    2276. 

  2276. 			public enum El : long

    2277. 

  2277. 			{

    2278. 

  2278. 			    A, B, C

    2279. 

  2279. 			}

    2280. 

  2280. 			

    2281. 

  2281. 			public struct S : IEquatable<S>

    2282. 

  2282. 			{

    2283. 

  2283. 			    public override bool Equals(object o)

    2284. 

  2284. 			    {

    2285. 

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

    2286. 

  2286. 			    }

    2287. 

  2287. 			    public bool Equals(S other)

    2288. 

  2288. 			    {

    2289. 

  2289. 			        return true;

    2290. 

  2290. 			    }

    2291. 

  2291. 			    public override int GetHashCode()

    2292. 

  2292. 			    {

    2293. 

  2293. 			        return 0;

    2294. 

  2294. 			    }

    2295. 

  2295. 			}

    2296. 

  2296. 			

    2297. 

  2297. 			public struct Sp : IEquatable<Sp>

    2298. 

  2298. 			{

    2299. 

  2299. 			    public Sp(int i, double d)

    2300. 

  2300. 			    {

    2301. 

  2301. 			        I = i;

    2302. 

  2302. 			        D = d;

    2303. 

  2303. 			    }

    2304. 

  2304. 			

    2305. 

  2305. 			    public int I;

    2306. 

  2306. 			    public double D;

    2307. 

  2307. 			

    2308. 

  2308. 			    public override bool Equals(object o)

    2309. 

  2309. 			    {

    2310. 

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

    2311. 

  2311. 			    }

    2312. 

  2312. 			    public bool Equals(Sp other)

    2313. 

  2313. 			    {

    2314. 

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

    2315. 

  2315. 			    }

    2316. 

  2316. 			    public override int GetHashCode()

    2317. 

  2317. 			    {

    2318. 

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

    2319. 

  2319. 			    }

    2320. 

  2320. 			}

    2321. 

  2321. 			

    2322. 

  2322. 			public struct Ss : IEquatable<Ss>

    2323. 

  2323. 			{

    2324. 

  2324. 			    public Ss(S s)

    2325. 

  2325. 			    {

    2326. 

  2326. 			        Val = s;

    2327. 

  2327. 			    }

    2328. 

  2328. 			

    2329. 

  2329. 			    public S Val;

    2330. 

  2330. 			

    2331. 

  2331. 			    public override bool Equals(object o)

    2332. 

  2332. 			    {

    2333. 

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

    2334. 

  2334. 			    }

    2335. 

  2335. 			    public bool Equals(Ss other)

    2336. 

  2336. 			    {

    2337. 

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

    2338. 

  2338. 			    }

    2339. 

  2339. 			    public override int GetHashCode()

    2340. 

  2340. 			    {

    2341. 

  2341. 			        return Val.GetHashCode();

    2342. 

  2342. 			    }

    2343. 

  2343. 			}

    2344. 

  2344. 			

    2345. 

  2345. 			public struct Sc : IEquatable<Sc>

    2346. 

  2346. 			{

    2347. 

  2347. 			    public Sc(string s)

    2348. 

  2348. 			    {

    2349. 

  2349. 			        S = s;

    2350. 

  2350. 			    }

    2351. 

  2351. 			

    2352. 

  2352. 			    public string S;

    2353. 

  2353. 			

    2354. 

  2354. 			    public override bool Equals(object o)

    2355. 

  2355. 			    {

    2356. 

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

    2357. 

  2357. 			    }

    2358. 

  2358. 			    public bool Equals(Sc other)

    2359. 

  2359. 			    {

    2360. 

  2360. 			        return other.S == S;

    2361. 

  2361. 			    }

    2362. 

  2362. 			    public override int GetHashCode()

    2363. 

  2363. 			    {

    2364. 

  2364. 			        return S.GetHashCode();

    2365. 

  2365. 			    }

    2366. 

  2366. 			}

    2367. 

  2367. 			

    2368. 

  2368. 			public struct Scs : IEquatable<Scs>

    2369. 

  2369. 			{

    2370. 

  2370. 			    public Scs(string s, S val)

    2371. 

  2371. 			    {

    2372. 

  2372. 			        S = s;

    2373. 

  2373. 			        Val = val;

    2374. 

  2374. 			    }

    2375. 

  2375. 			

    2376. 

  2376. 			    public string S;

    2377. 

  2377. 			    public S Val;

    2378. 

  2378. 			

    2379. 

  2379. 			    public override bool Equals(object o)

    2380. 

  2380. 			    {

    2381. 

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

    2382. 

  2382. 			    }

    2383. 

  2383. 			    public bool Equals(Scs other)

    2384. 

  2384. 			    {

    2385. 

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

    2386. 

  2386. 			    }

    2387. 

  2387. 			    public override int GetHashCode()

    2388. 

  2388. 			    {

    2389. 

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

    2390. 

  2390. 			    }

    2391. 

  2391. 			}

    2392. 

  2392. 			

    2393. 

  2393. 		

    2394. 

  2394. 	}

    2395. 

  2395. 				

    2396. 

  2396. 				//-------- Scenario 3139

    2397. 

  2397. 				namespace Scenario3139{

    2398. 

  2398. 					

    2399. 

  2399. 					public class Test

    2400. 

  2400. 					{

    2401. 

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

    2402. 

  2402. 				    public static Expression Ss_ArrayIndex__() {

    2403. 

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

    2404. 

  2404. 				           throw new Exception();

    2405. 

  2405. 				       } else { 

    2406. 

  2406. 				           return Expression.Constant(0);

    2407. 

  2407. 				       }

    2408. 

  2408. 				    }

    2409. 

  2409. 					public     static int Main()

    2410. 

  2410. 					    {

    2411. 

  2411. 					        Ext.StartCapture();

    2412. 

  2412. 					        bool success = false;

    2413. 

  2413. 					        try

    2414. 

  2414. 					        {

    2415. 

  2415. 					            success = check_Ss_ArrayIndex();

    2416. 

  2416. 					        }

    2417. 

  2417. 					        finally

    2418. 

  2418. 					        {

    2419. 

  2419. 					            Ext.StopCapture();

    2420. 

  2420. 					        }

    2421. 

  2421. 					        return success ? 0 : 1;

    2422. 

  2422. 					    }

    2423. 

  2423. 					

    2424. 

  2424. 					    static bool check_Ss_ArrayIndex()

    2425. 

  2425. 					    {

    2426. 

  2426. 					        return checkEx_Ss_ArrayIndex(null, -1) &

    2427. 

  2427. 					            checkEx_Ss_ArrayIndex(null, 0) &

    2428. 

  2428. 					            checkEx_Ss_ArrayIndex(null, 1) &

    2429. 

  2429. 					

    2430. 

  2430. 					            check_Ss_ArrayIndex(genArrSs_ArrayIndex(0)) &

    2431. 

  2431. 					            check_Ss_ArrayIndex(genArrSs_ArrayIndex(1)) &

    2432. 

  2432. 					            check_Ss_ArrayIndex(genArrSs_ArrayIndex(5));

    2433. 

  2433. 					    }

    2434. 

  2434. 					

    2435. 

  2435. 					    static Ss[] genArrSs_ArrayIndex(int size)

    2436. 

  2436. 					    {

    2437. 

  2437. 					        Ss[] vals = new Ss[] { default(Ss), new Ss(), new Ss(new S()) };

    2438. 

  2438. 					        Ss[] result = new Ss[size];

    2439. 

  2439. 					        for (int i = 0; i < size; i++)

    2440. 

  2440. 					        {

    2441. 

  2441. 					            result[i] = vals[i % vals.Length];

    2442. 

  2442. 					        }

    2443. 

  2443. 					        return result;

    2444. 

  2444. 					    }

    2445. 

  2445. 					

    2446. 

  2446. 					    static bool check_Ss_ArrayIndex(Ss[] val)

    2447. 

  2447. 					    {

    2448. 

  2448. 					        bool success = checkEx_Ss_ArrayIndex(val, -1);

    2449. 

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

    2450. 

  2450. 					        {

    2451. 

  2451. 					            success &= check_Ss_ArrayIndex(val, 0);

    2452. 

  2452. 					        }

    2453. 

  2453. 					        success &= checkEx_Ss_ArrayIndex(val, val.Length);

    2454. 

  2454. 					        return success;

    2455. 

  2455. 					    }

    2456. 

  2456. 					

    2457. 

  2457. 					    static bool checkEx_Ss_ArrayIndex(Ss[] val, int index)

    2458. 

  2458. 					    {

    2459. 

  2459. 					        try

    2460. 

  2460. 					        {

    2461. 

  2461. 					            check_Ss_ArrayIndex(val, index);

    2462. 

  2462. 					            Console.WriteLine("Ss_ArrayIndex[" + index + "] failed");

    2463. 

  2463. 					            return false;

    2464. 

  2464. 					        }

    2465. 

  2465. 					        catch

    2466. 

  2466. 					        {

    2467. 

  2467. 					            return true;

    2468. 

  2468. 					        }

    2469. 

  2469. 					    }

    2470. 

  2470. 					

    2471. 

  2471. 					    static bool check_Ss_ArrayIndex(Ss[] val, int index)

    2472. 

  2472. 					    {

    2473. 

  2473. 					        Expression<Func<Ss>> e =

    2474. 

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

    2475. 

  2475. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Ss[])),

    2476. 

  2476. 					                    Expression.Constant(index, typeof(int))),

    2477. 

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

    2478. 

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

    2479. 

  2479. 					        return object.Equals(f(), val[index]);

    2480. 

  2480. 					    }

    2481. 

  2481. 					}

    2482. 

  2482. 				

    2483. 

  2483. 				

    2484. 

  2484. 				public  static class Ext {

    2485. 

  2485. 				    public static void StartCapture() {

    2486. 

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

    2487. 

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

    2488. 

  2488. 				    }

    2489. 

  2489. 				

    2490. 

  2490. 				    public static void StopCapture() {

    2491. 

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

    2492. 

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

    2493. 

  2493. 				    }

    2494. 

  2494. 				

    2495. 

  2495. 				    public static bool IsIntegralOrEnum(Type type) {

    2496. 

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

    2497. 

  2497. 				            case TypeCode.Byte:

    2498. 

  2498. 				            case TypeCode.SByte:

    2499. 

  2499. 				            case TypeCode.Int16:

    2500. 

  2500. 				            case TypeCode.Int32:

    2501. 

  2501. 				            case TypeCode.Int64:

    2502. 

  2502. 				            case TypeCode.UInt16:

    2503. 

  2503. 				            case TypeCode.UInt32:

    2504. 

  2504. 				            case TypeCode.UInt64:

    2505. 

  2505. 				                return true;

    2506. 

  2506. 				            default:

    2507. 

  2507. 				                return false;

    2508. 

  2508. 				        }

    2509. 

  2509. 				    }

    2510. 

  2510. 				

    2511. 

  2511. 				    public static bool IsFloating(Type type) {

    2512. 

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

    2513. 

  2513. 				            case TypeCode.Single:

    2514. 

  2514. 				            case TypeCode.Double:

    2515. 

  2515. 				                return true;

    2516. 

  2516. 				            default:

    2517. 

  2517. 				                return false;

    2518. 

  2518. 				        }

    2519. 

  2519. 				    }

    2520. 

  2520. 				

    2521. 

  2521. 				    public static Type GetNonNullableType(Type type) {

    2522. 

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

    2523. 

  2523. 				                type.GetGenericArguments()[0] :

    2524. 

  2524. 				                type;

    2525. 

  2525. 				    }

    2526. 

  2526. 				}

    2527. 

  2527. 				

    2528. 

  2528. 			

    2529. 

  2529. 			

    2530. 

  2530. 			

    2531. 

  2531. 			public interface I

    2532. 

  2532. 			{

    2533. 

  2533. 			    void M();

    2534. 

  2534. 			}

    2535. 

  2535. 			

    2536. 

  2536. 			public  class C : IEquatable<C>, I

    2537. 

  2537. 			{

    2538. 

  2538. 			    void I.M()

    2539. 

  2539. 			    {

    2540. 

  2540. 			    }

    2541. 

  2541. 			

    2542. 

  2542. 			    public override bool Equals(object o)

    2543. 

  2543. 			    {

    2544. 

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

    2545. 

  2545. 			    }

    2546. 

  2546. 			

    2547. 

  2547. 			    public bool Equals(C c)

    2548. 

  2548. 			    {

    2549. 

  2549. 			        return c != null;

    2550. 

  2550. 			    }

    2551. 

  2551. 			

    2552. 

  2552. 			    public override int GetHashCode()

    2553. 

  2553. 			    {

    2554. 

  2554. 			        return 0;

    2555. 

  2555. 			    }

    2556. 

  2556. 			}

    2557. 

  2557. 			

    2558. 

  2558. 			public  class D : C, IEquatable<D>

    2559. 

  2559. 			{

    2560. 

  2560. 			    public int Val;

    2561. 

  2561. 			    public D()

    2562. 

  2562. 			    {

    2563. 

  2563. 			    }

    2564. 

  2564. 			    public D(int val)

    2565. 

  2565. 			    {

    2566. 

  2566. 			        Val = val;

    2567. 

  2567. 			    }

    2568. 

  2568. 			

    2569. 

  2569. 			    public override bool Equals(object o)

    2570. 

  2570. 			    {

    2571. 

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

    2572. 

  2572. 			    }

    2573. 

  2573. 			

    2574. 

  2574. 			    public bool Equals(D d)

    2575. 

  2575. 			    {

    2576. 

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

    2577. 

  2577. 			    }

    2578. 

  2578. 			

    2579. 

  2579. 			    public override int GetHashCode()

    2580. 

  2580. 			    {

    2581. 

  2581. 			        return Val;

    2582. 

  2582. 			    }

    2583. 

  2583. 			}

    2584. 

  2584. 			

    2585. 

  2585. 			public enum E

    2586. 

  2586. 			{

    2587. 

  2587. 			    A = 1, B = 2

    2588. 

  2588. 			}

    2589. 

  2589. 			

    2590. 

  2590. 			public enum El : long

    2591. 

  2591. 			{

    2592. 

  2592. 			    A, B, C

    2593. 

  2593. 			}

    2594. 

  2594. 			

    2595. 

  2595. 			public struct S : IEquatable<S>

    2596. 

  2596. 			{

    2597. 

  2597. 			    public override bool Equals(object o)

    2598. 

  2598. 			    {

    2599. 

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

    2600. 

  2600. 			    }

    2601. 

  2601. 			    public bool Equals(S other)

    2602. 

  2602. 			    {

    2603. 

  2603. 			        return true;

    2604. 

  2604. 			    }

    2605. 

  2605. 			    public override int GetHashCode()

    2606. 

  2606. 			    {

    2607. 

  2607. 			        return 0;

    2608. 

  2608. 			    }

    2609. 

  2609. 			}

    2610. 

  2610. 			

    2611. 

  2611. 			public struct Sp : IEquatable<Sp>

    2612. 

  2612. 			{

    2613. 

  2613. 			    public Sp(int i, double d)

    2614. 

  2614. 			    {

    2615. 

  2615. 			        I = i;

    2616. 

  2616. 			        D = d;

    2617. 

  2617. 			    }

    2618. 

  2618. 			

    2619. 

  2619. 			    public int I;

    2620. 

  2620. 			    public double D;

    2621. 

  2621. 			

    2622. 

  2622. 			    public override bool Equals(object o)

    2623. 

  2623. 			    {

    2624. 

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

    2625. 

  2625. 			    }

    2626. 

  2626. 			    public bool Equals(Sp other)

    2627. 

  2627. 			    {

    2628. 

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

    2629. 

  2629. 			    }

    2630. 

  2630. 			    public override int GetHashCode()

    2631. 

  2631. 			    {

    2632. 

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

    2633. 

  2633. 			    }

    2634. 

  2634. 			}

    2635. 

  2635. 			

    2636. 

  2636. 			public struct Ss : IEquatable<Ss>

    2637. 

  2637. 			{

    2638. 

  2638. 			    public Ss(S s)

    2639. 

  2639. 			    {

    2640. 

  2640. 			        Val = s;

    2641. 

  2641. 			    }

    2642. 

  2642. 			

    2643. 

  2643. 			    public S Val;

    2644. 

  2644. 			

    2645. 

  2645. 			    public override bool Equals(object o)

    2646. 

  2646. 			    {

    2647. 

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

    2648. 

  2648. 			    }

    2649. 

  2649. 			    public bool Equals(Ss other)

    2650. 

  2650. 			    {

    2651. 

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

    2652. 

  2652. 			    }

    2653. 

  2653. 			    public override int GetHashCode()

    2654. 

  2654. 			    {

    2655. 

  2655. 			        return Val.GetHashCode();

    2656. 

  2656. 			    }

    2657. 

  2657. 			}

    2658. 

  2658. 			

    2659. 

  2659. 			public struct Sc : IEquatable<Sc>

    2660. 

  2660. 			{

    2661. 

  2661. 			    public Sc(string s)

    2662. 

  2662. 			    {

    2663. 

  2663. 			        S = s;

    2664. 

  2664. 			    }

    2665. 

  2665. 			

    2666. 

  2666. 			    public string S;

    2667. 

  2667. 			

    2668. 

  2668. 			    public override bool Equals(object o)

    2669. 

  2669. 			    {

    2670. 

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

    2671. 

  2671. 			    }

    2672. 

  2672. 			    public bool Equals(Sc other)

    2673. 

  2673. 			    {

    2674. 

  2674. 			        return other.S == S;

    2675. 

  2675. 			    }

    2676. 

  2676. 			    public override int GetHashCode()

    2677. 

  2677. 			    {

    2678. 

  2678. 			        return S.GetHashCode();

    2679. 

  2679. 			    }

    2680. 

  2680. 			}

    2681. 

  2681. 			

    2682. 

  2682. 			public struct Scs : IEquatable<Scs>

    2683. 

  2683. 			{

    2684. 

  2684. 			    public Scs(string s, S val)

    2685. 

  2685. 			    {

    2686. 

  2686. 			        S = s;

    2687. 

  2687. 			        Val = val;

    2688. 

  2688. 			    }

    2689. 

  2689. 			

    2690. 

  2690. 			    public string S;

    2691. 

  2691. 			    public S Val;

    2692. 

  2692. 			

    2693. 

  2693. 			    public override bool Equals(object o)

    2694. 

  2694. 			    {

    2695. 

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

    2696. 

  2696. 			    }

    2697. 

  2697. 			    public bool Equals(Scs other)

    2698. 

  2698. 			    {

    2699. 

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

    2700. 

  2700. 			    }

    2701. 

  2701. 			    public override int GetHashCode()

    2702. 

  2702. 			    {

    2703. 

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

    2704. 

  2704. 			    }

    2705. 

  2705. 			}

    2706. 

  2706. 			

    2707. 

  2707. 		

    2708. 

  2708. 	}

    2709. 

  2709. 				

    2710. 

  2710. 				//-------- Scenario 3140

    2711. 

  2711. 				namespace Scenario3140{

    2712. 

  2712. 					

    2713. 

  2713. 					public class Test

    2714. 

  2714. 					{

    2715. 

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

    2716. 

  2716. 				    public static Expression Sc_ArrayIndex__() {

    2717. 

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

    2718. 

  2718. 				           throw new Exception();

    2719. 

  2719. 				       } else { 

    2720. 

  2720. 				           return Expression.Constant(0);

    2721. 

  2721. 				       }

    2722. 

  2722. 				    }

    2723. 

  2723. 					public     static int Main()

    2724. 

  2724. 					    {

    2725. 

  2725. 					        Ext.StartCapture();

    2726. 

  2726. 					        bool success = false;

    2727. 

  2727. 					        try

    2728. 

  2728. 					        {

    2729. 

  2729. 					            success = check_Sc_ArrayIndex();

    2730. 

  2730. 					        }

    2731. 

  2731. 					        finally

    2732. 

  2732. 					        {

    2733. 

  2733. 					            Ext.StopCapture();

    2734. 

  2734. 					        }

    2735. 

  2735. 					        return success ? 0 : 1;

    2736. 

  2736. 					    }

    2737. 

  2737. 					

    2738. 

  2738. 					    static bool check_Sc_ArrayIndex()

    2739. 

  2739. 					    {

    2740. 

  2740. 					        return checkEx_Sc_ArrayIndex(null, -1) &

    2741. 

  2741. 					            checkEx_Sc_ArrayIndex(null, 0) &

    2742. 

  2742. 					            checkEx_Sc_ArrayIndex(null, 1) &

    2743. 

  2743. 					

    2744. 

  2744. 					            check_Sc_ArrayIndex(genArrSc_ArrayIndex(0)) &

    2745. 

  2745. 					            check_Sc_ArrayIndex(genArrSc_ArrayIndex(1)) &

    2746. 

  2746. 					            check_Sc_ArrayIndex(genArrSc_ArrayIndex(5));

    2747. 

  2747. 					    }

    2748. 

  2748. 					

    2749. 

  2749. 					    static Sc[] genArrSc_ArrayIndex(int size)

    2750. 

  2750. 					    {

    2751. 

  2751. 					        Sc[] vals = new Sc[] { default(Sc), new Sc(), new Sc(null) };

    2752. 

  2752. 					        Sc[] result = new Sc[size];

    2753. 

  2753. 					        for (int i = 0; i < size; i++)

    2754. 

  2754. 					        {

    2755. 

  2755. 					            result[i] = vals[i % vals.Length];

    2756. 

  2756. 					        }

    2757. 

  2757. 					        return result;

    2758. 

  2758. 					    }

    2759. 

  2759. 					

    2760. 

  2760. 					    static bool check_Sc_ArrayIndex(Sc[] val)

    2761. 

  2761. 					    {

    2762. 

  2762. 					        bool success = checkEx_Sc_ArrayIndex(val, -1);

    2763. 

  2763. 					        for (int i = 0; i < val.Length; i++)

    2764. 

  2764. 					        {

    2765. 

  2765. 					            success &= check_Sc_ArrayIndex(val, 0);

    2766. 

  2766. 					        }

    2767. 

  2767. 					        success &= checkEx_Sc_ArrayIndex(val, val.Length);

    2768. 

  2768. 					        return success;

    2769. 

  2769. 					    }

    2770. 

  2770. 					

    2771. 

  2771. 					    static bool checkEx_Sc_ArrayIndex(Sc[] val, int index)

    2772. 

  2772. 					    {

    2773. 

  2773. 					        try

    2774. 

  2774. 					        {

    2775. 

  2775. 					            check_Sc_ArrayIndex(val, index);

    2776. 

  2776. 					            Console.WriteLine("Sc_ArrayIndex[" + index + "] failed");

    2777. 

  2777. 					            return false;

    2778. 

  2778. 					        }

    2779. 

  2779. 					        catch

    2780. 

  2780. 					        {

    2781. 

  2781. 					            return true;

    2782. 

  2782. 					        }

    2783. 

  2783. 					    }

    2784. 

  2784. 					

    2785. 

  2785. 					    static bool check_Sc_ArrayIndex(Sc[] val, int index)

    2786. 

  2786. 					    {

    2787. 

  2787. 					        Expression<Func<Sc>> e =

    2788. 

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

    2789. 

  2789. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Sc[])),

    2790. 

  2790. 					                    Expression.Constant(index, typeof(int))),

    2791. 

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

    2792. 

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

    2793. 

  2793. 					        return object.Equals(f(), val[index]);

    2794. 

  2794. 					    }

    2795. 

  2795. 					}

    2796. 

  2796. 				

    2797. 

  2797. 				

    2798. 

  2798. 				public  static class Ext {

    2799. 

  2799. 				    public static void StartCapture() {

    2800. 

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

    2801. 

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

    2802. 

  2802. 				    }

    2803. 

  2803. 				

    2804. 

  2804. 				    public static void StopCapture() {

    2805. 

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

    2806. 

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

    2807. 

  2807. 				    }

    2808. 

  2808. 				

    2809. 

  2809. 				    public static bool IsIntegralOrEnum(Type type) {

    2810. 

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

    2811. 

  2811. 				            case TypeCode.Byte:

    2812. 

  2812. 				            case TypeCode.SByte:

    2813. 

  2813. 				            case TypeCode.Int16:

    2814. 

  2814. 				            case TypeCode.Int32:

    2815. 

  2815. 				            case TypeCode.Int64:

    2816. 

  2816. 				            case TypeCode.UInt16:

    2817. 

  2817. 				            case TypeCode.UInt32:

    2818. 

  2818. 				            case TypeCode.UInt64:

    2819. 

  2819. 				                return true;

    2820. 

  2820. 				            default:

    2821. 

  2821. 				                return false;

    2822. 

  2822. 				        }

    2823. 

  2823. 				    }

    2824. 

  2824. 				

    2825. 

  2825. 				    public static bool IsFloating(Type type) {

    2826. 

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

    2827. 

  2827. 				            case TypeCode.Single:

    2828. 

  2828. 				            case TypeCode.Double:

    2829. 

  2829. 				                return true;

    2830. 

  2830. 				            default:

    2831. 

  2831. 				                return false;

    2832. 

  2832. 				        }

    2833. 

  2833. 				    }

    2834. 

  2834. 				

    2835. 

  2835. 				    public static Type GetNonNullableType(Type type) {

    2836. 

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

    2837. 

  2837. 				                type.GetGenericArguments()[0] :

    2838. 

  2838. 				                type;

    2839. 

  2839. 				    }

    2840. 

  2840. 				}

    2841. 

  2841. 				

    2842. 

  2842. 			

    2843. 

  2843. 			

    2844. 

  2844. 			

    2845. 

  2845. 			public interface I

    2846. 

  2846. 			{

    2847. 

  2847. 			    void M();

    2848. 

  2848. 			}

    2849. 

  2849. 			

    2850. 

  2850. 			public  class C : IEquatable<C>, I

    2851. 

  2851. 			{

    2852. 

  2852. 			    void I.M()

    2853. 

  2853. 			    {

    2854. 

  2854. 			    }

    2855. 

  2855. 			

    2856. 

  2856. 			    public override bool Equals(object o)

    2857. 

  2857. 			    {

    2858. 

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

    2859. 

  2859. 			    }

    2860. 

  2860. 			

    2861. 

  2861. 			    public bool Equals(C c)

    2862. 

  2862. 			    {

    2863. 

  2863. 			        return c != null;

    2864. 

  2864. 			    }

    2865. 

  2865. 			

    2866. 

  2866. 			    public override int GetHashCode()

    2867. 

  2867. 			    {

    2868. 

  2868. 			        return 0;

    2869. 

  2869. 			    }

    2870. 

  2870. 			}

    2871. 

  2871. 			

    2872. 

  2872. 			public  class D : C, IEquatable<D>

    2873. 

  2873. 			{

    2874. 

  2874. 			    public int Val;

    2875. 

  2875. 			    public D()

    2876. 

  2876. 			    {

    2877. 

  2877. 			    }

    2878. 

  2878. 			    public D(int val)

    2879. 

  2879. 			    {

    2880. 

  2880. 			        Val = val;

    2881. 

  2881. 			    }

    2882. 

  2882. 			

    2883. 

  2883. 			    public override bool Equals(object o)

    2884. 

  2884. 			    {

    2885. 

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

    2886. 

  2886. 			    }

    2887. 

  2887. 			

    2888. 

  2888. 			    public bool Equals(D d)

    2889. 

  2889. 			    {

    2890. 

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

    2891. 

  2891. 			    }

    2892. 

  2892. 			

    2893. 

  2893. 			    public override int GetHashCode()

    2894. 

  2894. 			    {

    2895. 

  2895. 			        return Val;

    2896. 

  2896. 			    }

    2897. 

  2897. 			}

    2898. 

  2898. 			

    2899. 

  2899. 			public enum E

    2900. 

  2900. 			{

    2901. 

  2901. 			    A = 1, B = 2

    2902. 

  2902. 			}

    2903. 

  2903. 			

    2904. 

  2904. 			public enum El : long

    2905. 

  2905. 			{

    2906. 

  2906. 			    A, B, C

    2907. 

  2907. 			}

    2908. 

  2908. 			

    2909. 

  2909. 			public struct S : IEquatable<S>

    2910. 

  2910. 			{

    2911. 

  2911. 			    public override bool Equals(object o)

    2912. 

  2912. 			    {

    2913. 

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

    2914. 

  2914. 			    }

    2915. 

  2915. 			    public bool Equals(S other)

    2916. 

  2916. 			    {

    2917. 

  2917. 			        return true;

    2918. 

  2918. 			    }

    2919. 

  2919. 			    public override int GetHashCode()

    2920. 

  2920. 			    {

    2921. 

  2921. 			        return 0;

    2922. 

  2922. 			    }

    2923. 

  2923. 			}

    2924. 

  2924. 			

    2925. 

  2925. 			public struct Sp : IEquatable<Sp>

    2926. 

  2926. 			{

    2927. 

  2927. 			    public Sp(int i, double d)

    2928. 

  2928. 			    {

    2929. 

  2929. 			        I = i;

    2930. 

  2930. 			        D = d;

    2931. 

  2931. 			    }

    2932. 

  2932. 			

    2933. 

  2933. 			    public int I;

    2934. 

  2934. 			    public double D;

    2935. 

  2935. 			

    2936. 

  2936. 			    public override bool Equals(object o)

    2937. 

  2937. 			    {

    2938. 

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

    2939. 

  2939. 			    }

    2940. 

  2940. 			    public bool Equals(Sp other)

    2941. 

  2941. 			    {

    2942. 

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

    2943. 

  2943. 			    }

    2944. 

  2944. 			    public override int GetHashCode()

    2945. 

  2945. 			    {

    2946. 

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

    2947. 

  2947. 			    }

    2948. 

  2948. 			}

    2949. 

  2949. 			

    2950. 

  2950. 			public struct Ss : IEquatable<Ss>

    2951. 

  2951. 			{

    2952. 

  2952. 			    public Ss(S s)

    2953. 

  2953. 			    {

    2954. 

  2954. 			        Val = s;

    2955. 

  2955. 			    }

    2956. 

  2956. 			

    2957. 

  2957. 			    public S Val;

    2958. 

  2958. 			

    2959. 

  2959. 			    public override bool Equals(object o)

    2960. 

  2960. 			    {

    2961. 

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

    2962. 

  2962. 			    }

    2963. 

  2963. 			    public bool Equals(Ss other)

    2964. 

  2964. 			    {

    2965. 

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

    2966. 

  2966. 			    }

    2967. 

  2967. 			    public override int GetHashCode()

    2968. 

  2968. 			    {

    2969. 

  2969. 			        return Val.GetHashCode();

    2970. 

  2970. 			    }

    2971. 

  2971. 			}

    2972. 

  2972. 			

    2973. 

  2973. 			public struct Sc : IEquatable<Sc>

    2974. 

  2974. 			{

    2975. 

  2975. 			    public Sc(string s)

    2976. 

  2976. 			    {

    2977. 

  2977. 			        S = s;

    2978. 

  2978. 			    }

    2979. 

  2979. 			

    2980. 

  2980. 			    public string S;

    2981. 

  2981. 			

    2982. 

  2982. 			    public override bool Equals(object o)

    2983. 

  2983. 			    {

    2984. 

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

    2985. 

  2985. 			    }

    2986. 

  2986. 			    public bool Equals(Sc other)

    2987. 

  2987. 			    {

    2988. 

  2988. 			        return other.S == S;

    2989. 

  2989. 			    }

    2990. 

  2990. 			    public override int GetHashCode()

    2991. 

  2991. 			    {

    2992. 

  2992. 			        return S.GetHashCode();

    2993. 

  2993. 			    }

    2994. 

  2994. 			}

    2995. 

  2995. 			

    2996. 

  2996. 			public struct Scs : IEquatable<Scs>

    2997. 

  2997. 			{

    2998. 

  2998. 			    public Scs(string s, S val)

    2999. 

  2999. 			    {

    3000. 

  3000. 			        S = s;

    3001. 

  3001. 			        Val = val;

    3002. 

  3002. 			    }

    3003. 

  3003. 			

    3004. 

  3004. 			    public string S;

    3005. 

  3005. 			    public S Val;

    3006. 

  3006. 			

    3007. 

  3007. 			    public override bool Equals(object o)

    3008. 

  3008. 			    {

    3009. 

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

    3010. 

  3010. 			    }

    3011. 

  3011. 			    public bool Equals(Scs other)

    3012. 

  3012. 			    {

    3013. 

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

    3014. 

  3014. 			    }

    3015. 

  3015. 			    public override int GetHashCode()

    3016. 

  3016. 			    {

    3017. 

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

    3018. 

  3018. 			    }

    3019. 

  3019. 			}

    3020. 

  3020. 			

    3021. 

  3021. 		

    3022. 

  3022. 	}

    3023. 

  3023. 				

    3024. 

  3024. 				//-------- Scenario 3141

    3025. 

  3025. 				namespace Scenario3141{

    3026. 

  3026. 					

    3027. 

  3027. 					public class Test

    3028. 

  3028. 					{

    3029. 

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

    3030. 

  3030. 				    public static Expression Scs_ArrayIndex__() {

    3031. 

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

    3032. 

  3032. 				           throw new Exception();

    3033. 

  3033. 				       } else { 

    3034. 

  3034. 				           return Expression.Constant(0);

    3035. 

  3035. 				       }

    3036. 

  3036. 				    }

    3037. 

  3037. 					public     static int Main()

    3038. 

  3038. 					    {

    3039. 

  3039. 					        Ext.StartCapture();

    3040. 

  3040. 					        bool success = false;

    3041. 

  3041. 					        try

    3042. 

  3042. 					        {

    3043. 

  3043. 					            success = check_Scs_ArrayIndex();

    3044. 

  3044. 					        }

    3045. 

  3045. 					        finally

    3046. 

  3046. 					        {

    3047. 

  3047. 					            Ext.StopCapture();

    3048. 

  3048. 					        }

    3049. 

  3049. 					        return success ? 0 : 1;

    3050. 

  3050. 					    }

    3051. 

  3051. 					

    3052. 

  3052. 					    static bool check_Scs_ArrayIndex()

    3053. 

  3053. 					    {

    3054. 

  3054. 					        return checkEx_Scs_ArrayIndex(null, -1) &

    3055. 

  3055. 					            checkEx_Scs_ArrayIndex(null, 0) &

    3056. 

  3056. 					            checkEx_Scs_ArrayIndex(null, 1) &

    3057. 

  3057. 					

    3058. 

  3058. 					            check_Scs_ArrayIndex(genArrScs_ArrayIndex(0)) &

    3059. 

  3059. 					            check_Scs_ArrayIndex(genArrScs_ArrayIndex(1)) &

    3060. 

  3060. 					            check_Scs_ArrayIndex(genArrScs_ArrayIndex(5));

    3061. 

  3061. 					    }

    3062. 

  3062. 					

    3063. 

  3063. 					    static Scs[] genArrScs_ArrayIndex(int size)

    3064. 

  3064. 					    {

    3065. 

  3065. 					        Scs[] vals = new Scs[] { default(Scs), new Scs(), new Scs(null, new S()) };

    3066. 

  3066. 					        Scs[] result = new Scs[size];

    3067. 

  3067. 					        for (int i = 0; i < size; i++)

    3068. 

  3068. 					        {

    3069. 

  3069. 					            result[i] = vals[i % vals.Length];

    3070. 

  3070. 					        }

    3071. 

  3071. 					        return result;

    3072. 

  3072. 					    }

    3073. 

  3073. 					

    3074. 

  3074. 					    static bool check_Scs_ArrayIndex(Scs[] val)

    3075. 

  3075. 					    {

    3076. 

  3076. 					        bool success = checkEx_Scs_ArrayIndex(val, -1);

    3077. 

  3077. 					        for (int i = 0; i < val.Length; i++)

    3078. 

  3078. 					        {

    3079. 

  3079. 					            success &= check_Scs_ArrayIndex(val, 0);

    3080. 

  3080. 					        }

    3081. 

  3081. 					        success &= checkEx_Scs_ArrayIndex(val, val.Length);

    3082. 

  3082. 					        return success;

    3083. 

  3083. 					    }

    3084. 

  3084. 					

    3085. 

  3085. 					    static bool checkEx_Scs_ArrayIndex(Scs[] val, int index)

    3086. 

  3086. 					    {

    3087. 

  3087. 					        try

    3088. 

  3088. 					        {

    3089. 

  3089. 					            check_Scs_ArrayIndex(val, index);

    3090. 

  3090. 					            Console.WriteLine("Scs_ArrayIndex[" + index + "] failed");

    3091. 

  3091. 					            return false;

    3092. 

  3092. 					        }

    3093. 

  3093. 					        catch

    3094. 

  3094. 					        {

    3095. 

  3095. 					            return true;

    3096. 

  3096. 					        }

    3097. 

  3097. 					    }

    3098. 

  3098. 					

    3099. 

  3099. 					    static bool check_Scs_ArrayIndex(Scs[] val, int index)

    3100. 

  3100. 					    {

    3101. 

  3101. 					        Expression<Func<Scs>> e =

    3102. 

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

    3103. 

  3103. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Scs[])),

    3104. 

  3104. 					                    Expression.Constant(index, typeof(int))),

    3105. 

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

    3106. 

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

    3107. 

  3107. 					        return object.Equals(f(), val[index]);

    3108. 

  3108. 					    }

    3109. 

  3109. 					}

    3110. 

  3110. 				

    3111. 

  3111. 				

    3112. 

  3112. 				public  static class Ext {

    3113. 

  3113. 				    public static void StartCapture() {

    3114. 

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

    3115. 

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

    3116. 

  3116. 				    }

    3117. 

  3117. 				

    3118. 

  3118. 				    public static void StopCapture() {

    3119. 

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

    3120. 

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

    3121. 

  3121. 				    }

    3122. 

  3122. 				

    3123. 

  3123. 				    public static bool IsIntegralOrEnum(Type type) {

    3124. 

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

    3125. 

  3125. 				            case TypeCode.Byte:

    3126. 

  3126. 				            case TypeCode.SByte:

    3127. 

  3127. 				            case TypeCode.Int16:

    3128. 

  3128. 				            case TypeCode.Int32:

    3129. 

  3129. 				            case TypeCode.Int64:

    3130. 

  3130. 				            case TypeCode.UInt16:

    3131. 

  3131. 				            case TypeCode.UInt32:

    3132. 

  3132. 				            case TypeCode.UInt64:

    3133. 

  3133. 				                return true;

    3134. 

  3134. 				            default:

    3135. 

  3135. 				                return false;

    3136. 

  3136. 				        }

    3137. 

  3137. 				    }

    3138. 

  3138. 				

    3139. 

  3139. 				    public static bool IsFloating(Type type) {

    3140. 

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

    3141. 

  3141. 				            case TypeCode.Single:

    3142. 

  3142. 				            case TypeCode.Double:

    3143. 

  3143. 				                return true;

    3144. 

  3144. 				            default:

    3145. 

  3145. 				                return false;

    3146. 

  3146. 				        }

    3147. 

  3147. 				    }

    3148. 

  3148. 				

    3149. 

  3149. 				    public static Type GetNonNullableType(Type type) {

    3150. 

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

    3151. 

  3151. 				                type.GetGenericArguments()[0] :

    3152. 

  3152. 				                type;

    3153. 

  3153. 				    }

    3154. 

  3154. 				}

    3155. 

  3155. 				

    3156. 

  3156. 			

    3157. 

  3157. 			

    3158. 

  3158. 			

    3159. 

  3159. 			public interface I

    3160. 

  3160. 			{

    3161. 

  3161. 			    void M();

    3162. 

  3162. 			}

    3163. 

  3163. 			

    3164. 

  3164. 			public  class C : IEquatable<C>, I

    3165. 

  3165. 			{

    3166. 

  3166. 			    void I.M()

    3167. 

  3167. 			    {

    3168. 

  3168. 			    }

    3169. 

  3169. 			

    3170. 

  3170. 			    public override bool Equals(object o)

    3171. 

  3171. 			    {

    3172. 

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

    3173. 

  3173. 			    }

    3174. 

  3174. 			

    3175. 

  3175. 			    public bool Equals(C c)

    3176. 

  3176. 			    {

    3177. 

  3177. 			        return c != null;

    3178. 

  3178. 			    }

    3179. 

  3179. 			

    3180. 

  3180. 			    public override int GetHashCode()

    3181. 

  3181. 			    {

    3182. 

  3182. 			        return 0;

    3183. 

  3183. 			    }

    3184. 

  3184. 			}

    3185. 

  3185. 			

    3186. 

  3186. 			public  class D : C, IEquatable<D>

    3187. 

  3187. 			{

    3188. 

  3188. 			    public int Val;

    3189. 

  3189. 			    public D()

    3190. 

  3190. 			    {

    3191. 

  3191. 			    }

    3192. 

  3192. 			    public D(int val)

    3193. 

  3193. 			    {

    3194. 

  3194. 			        Val = val;

    3195. 

  3195. 			    }

    3196. 

  3196. 			

    3197. 

  3197. 			    public override bool Equals(object o)

    3198. 

  3198. 			    {

    3199. 

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

    3200. 

  3200. 			    }

    3201. 

  3201. 			

    3202. 

  3202. 			    public bool Equals(D d)

    3203. 

  3203. 			    {

    3204. 

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

    3205. 

  3205. 			    }

    3206. 

  3206. 			

    3207. 

  3207. 			    public override int GetHashCode()

    3208. 

  3208. 			    {

    3209. 

  3209. 			        return Val;

    3210. 

  3210. 			    }

    3211. 

  3211. 			}

    3212. 

  3212. 			

    3213. 

  3213. 			public enum E

    3214. 

  3214. 			{

    3215. 

  3215. 			    A = 1, B = 2

    3216. 

  3216. 			}

    3217. 

  3217. 			

    3218. 

  3218. 			public enum El : long

    3219. 

  3219. 			{

    3220. 

  3220. 			    A, B, C

    3221. 

  3221. 			}

    3222. 

  3222. 			

    3223. 

  3223. 			public struct S : IEquatable<S>

    3224. 

  3224. 			{

    3225. 

  3225. 			    public override bool Equals(object o)

    3226. 

  3226. 			    {

    3227. 

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

    3228. 

  3228. 			    }

    3229. 

  3229. 			    public bool Equals(S other)

    3230. 

  3230. 			    {

    3231. 

  3231. 			        return true;

    3232. 

  3232. 			    }

    3233. 

  3233. 			    public override int GetHashCode()

    3234. 

  3234. 			    {

    3235. 

  3235. 			        return 0;

    3236. 

  3236. 			    }

    3237. 

  3237. 			}

    3238. 

  3238. 			

    3239. 

  3239. 			public struct Sp : IEquatable<Sp>

    3240. 

  3240. 			{

    3241. 

  3241. 			    public Sp(int i, double d)

    3242. 

  3242. 			    {

    3243. 

  3243. 			        I = i;

    3244. 

  3244. 			        D = d;

    3245. 

  3245. 			    }

    3246. 

  3246. 			

    3247. 

  3247. 			    public int I;

    3248. 

  3248. 			    public double D;

    3249. 

  3249. 			

    3250. 

  3250. 			    public override bool Equals(object o)

    3251. 

  3251. 			    {

    3252. 

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

    3253. 

  3253. 			    }

    3254. 

  3254. 			    public bool Equals(Sp other)

    3255. 

  3255. 			    {

    3256. 

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

    3257. 

  3257. 			    }

    3258. 

  3258. 			    public override int GetHashCode()

    3259. 

  3259. 			    {

    3260. 

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

    3261. 

  3261. 			    }

    3262. 

  3262. 			}

    3263. 

  3263. 			

    3264. 

  3264. 			public struct Ss : IEquatable<Ss>

    3265. 

  3265. 			{

    3266. 

  3266. 			    public Ss(S s)

    3267. 

  3267. 			    {

    3268. 

  3268. 			        Val = s;

    3269. 

  3269. 			    }

    3270. 

  3270. 			

    3271. 

  3271. 			    public S Val;

    3272. 

  3272. 			

    3273. 

  3273. 			    public override bool Equals(object o)

    3274. 

  3274. 			    {

    3275. 

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

    3276. 

  3276. 			    }

    3277. 

  3277. 			    public bool Equals(Ss other)

    3278. 

  3278. 			    {

    3279. 

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

    3280. 

  3280. 			    }

    3281. 

  3281. 			    public override int GetHashCode()

    3282. 

  3282. 			    {

    3283. 

  3283. 			        return Val.GetHashCode();

    3284. 

  3284. 			    }

    3285. 

  3285. 			}

    3286. 

  3286. 			

    3287. 

  3287. 			public struct Sc : IEquatable<Sc>

    3288. 

  3288. 			{

    3289. 

  3289. 			    public Sc(string s)

    3290. 

  3290. 			    {

    3291. 

  3291. 			        S = s;

    3292. 

  3292. 			    }

    3293. 

  3293. 			

    3294. 

  3294. 			    public string S;

    3295. 

  3295. 			

    3296. 

  3296. 			    public override bool Equals(object o)

    3297. 

  3297. 			    {

    3298. 

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

    3299. 

  3299. 			    }

    3300. 

  3300. 			    public bool Equals(Sc other)

    3301. 

  3301. 			    {

    3302. 

  3302. 			        return other.S == S;

    3303. 

  3303. 			    }

    3304. 

  3304. 			    public override int GetHashCode()

    3305. 

  3305. 			    {

    3306. 

  3306. 			        return S.GetHashCode();

    3307. 

  3307. 			    }

    3308. 

  3308. 			}

    3309. 

  3309. 			

    3310. 

  3310. 			public struct Scs : IEquatable<Scs>

    3311. 

  3311. 			{

    3312. 

  3312. 			    public Scs(string s, S val)

    3313. 

  3313. 			    {

    3314. 

  3314. 			        S = s;

    3315. 

  3315. 			        Val = val;

    3316. 

  3316. 			    }

    3317. 

  3317. 			

    3318. 

  3318. 			    public string S;

    3319. 

  3319. 			    public S Val;

    3320. 

  3320. 			

    3321. 

  3321. 			    public override bool Equals(object o)

    3322. 

  3322. 			    {

    3323. 

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

    3324. 

  3324. 			    }

    3325. 

  3325. 			    public bool Equals(Scs other)

    3326. 

  3326. 			    {

    3327. 

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

    3328. 

  3328. 			    }

    3329. 

  3329. 			    public override int GetHashCode()

    3330. 

  3330. 			    {

    3331. 

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

    3332. 

  3332. 			    }

    3333. 

  3333. 			}

    3334. 

  3334. 			

    3335. 

  3335. 		

    3336. 

  3336. 	}

    3337. 

  3337. 				

    3338. 

  3338. 				//-------- Scenario 3142

    3339. 

  3339. 				namespace Scenario3142{

    3340. 

  3340. 					

    3341. 

  3341. 					public class Test

    3342. 

  3342. 					{

    3343. 

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

    3344. 

  3344. 				    public static Expression Ts_ArrayIndex_S___() {

    3345. 

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

    3346. 

  3346. 				           throw new Exception();

    3347. 

  3347. 				       } else { 

    3348. 

  3348. 				           return Expression.Constant(0);

    3349. 

  3349. 				       }

    3350. 

  3350. 				    }

    3351. 

  3351. 					public     static int Main()

    3352. 

  3352. 					    {

    3353. 

  3353. 					        Ext.StartCapture();

    3354. 

  3354. 					        bool success = false;

    3355. 

  3355. 					        try

    3356. 

  3356. 					        {

    3357. 

  3357. 					            success = check_Ts_ArrayIndex<S>();

    3358. 

  3358. 					        }

    3359. 

  3359. 					        finally

    3360. 

  3360. 					        {

    3361. 

  3361. 					            Ext.StopCapture();

    3362. 

  3362. 					        }

    3363. 

  3363. 					        return success ? 0 : 1;

    3364. 

  3364. 					    }

    3365. 

  3365. 					

    3366. 

  3366. 					    static bool check_Ts_ArrayIndex<Ts>() where Ts : struct

    3367. 

  3367. 					    {

    3368. 

  3368. 					        return checkEx_Ts_ArrayIndex<Ts>(null, -1) &

    3369. 

  3369. 					            checkEx_Ts_ArrayIndex<Ts>(null, 0) &

    3370. 

  3370. 					            checkEx_Ts_ArrayIndex<Ts>(null, 1) &

    3371. 

  3371. 					

    3372. 

  3372. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(0)) &

    3373. 

  3373. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(1)) &

    3374. 

  3374. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(5));

    3375. 

  3375. 					    }

    3376. 

  3376. 					

    3377. 

  3377. 					    static Ts[] genArrTs_ArrayIndex<Ts>(int size) where Ts : struct

    3378. 

  3378. 					    {

    3379. 

  3379. 					        Ts[] vals = new Ts[] { default(Ts), new Ts() };

    3380. 

  3380. 					        Ts[] result = new Ts[size];

    3381. 

  3381. 					        for (int i = 0; i < size; i++)

    3382. 

  3382. 					        {

    3383. 

  3383. 					            result[i] = vals[i % vals.Length];

    3384. 

  3384. 					        }

    3385. 

  3385. 					        return result;

    3386. 

  3386. 					    }

    3387. 

  3387. 					

    3388. 

  3388. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val) where Ts : struct

    3389. 

  3389. 					    {

    3390. 

  3390. 					        bool success = checkEx_Ts_ArrayIndex<Ts>(val, -1);

    3391. 

  3391. 					        for (int i = 0; i < val.Length; i++)

    3392. 

  3392. 					        {

    3393. 

  3393. 					            success &= check_Ts_ArrayIndex<Ts>(val, 0);

    3394. 

  3394. 					        }

    3395. 

  3395. 					        success &= checkEx_Ts_ArrayIndex<Ts>(val, val.Length);

    3396. 

  3396. 					        return success;

    3397. 

  3397. 					    }

    3398. 

  3398. 					

    3399. 

  3399. 					    static bool checkEx_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    3400. 

  3400. 					    {

    3401. 

  3401. 					        try

    3402. 

  3402. 					        {

    3403. 

  3403. 					            check_Ts_ArrayIndex<Ts>(val, index);

    3404. 

  3404. 					            Console.WriteLine("Ts_ArrayIndex[" + index + "] failed");

    3405. 

  3405. 					            return false;

    3406. 

  3406. 					        }

    3407. 

  3407. 					        catch

    3408. 

  3408. 					        {

    3409. 

  3409. 					            return true;

    3410. 

  3410. 					        }

    3411. 

  3411. 					    }

    3412. 

  3412. 					

    3413. 

  3413. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    3414. 

  3414. 					    {

    3415. 

  3415. 					        Expression<Func<Ts>> e =

    3416. 

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

    3417. 

  3417. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Ts[])),

    3418. 

  3418. 					                    Expression.Constant(index, typeof(int))),

    3419. 

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

    3420. 

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

    3421. 

  3421. 					        return object.Equals(f(), val[index]);

    3422. 

  3422. 					    }

    3423. 

  3423. 					}

    3424. 

  3424. 				

    3425. 

  3425. 				

    3426. 

  3426. 				public  static class Ext {

    3427. 

  3427. 				    public static void StartCapture() {

    3428. 

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

    3429. 

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

    3430. 

  3430. 				    }

    3431. 

  3431. 				

    3432. 

  3432. 				    public static void StopCapture() {

    3433. 

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

    3434. 

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

    3435. 

  3435. 				    }

    3436. 

  3436. 				

    3437. 

  3437. 				    public static bool IsIntegralOrEnum(Type type) {

    3438. 

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

    3439. 

  3439. 				            case TypeCode.Byte:

    3440. 

  3440. 				            case TypeCode.SByte:

    3441. 

  3441. 				            case TypeCode.Int16:

    3442. 

  3442. 				            case TypeCode.Int32:

    3443. 

  3443. 				            case TypeCode.Int64:

    3444. 

  3444. 				            case TypeCode.UInt16:

    3445. 

  3445. 				            case TypeCode.UInt32:

    3446. 

  3446. 				            case TypeCode.UInt64:

    3447. 

  3447. 				                return true;

    3448. 

  3448. 				            default:

    3449. 

  3449. 				                return false;

    3450. 

  3450. 				        }

    3451. 

  3451. 				    }

    3452. 

  3452. 				

    3453. 

  3453. 				    public static bool IsFloating(Type type) {

    3454. 

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

    3455. 

  3455. 				            case TypeCode.Single:

    3456. 

  3456. 				            case TypeCode.Double:

    3457. 

  3457. 				                return true;

    3458. 

  3458. 				            default:

    3459. 

  3459. 				                return false;

    3460. 

  3460. 				        }

    3461. 

  3461. 				    }

    3462. 

  3462. 				

    3463. 

  3463. 				    public static Type GetNonNullableType(Type type) {

    3464. 

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

    3465. 

  3465. 				                type.GetGenericArguments()[0] :

    3466. 

  3466. 				                type;

    3467. 

  3467. 				    }

    3468. 

  3468. 				}

    3469. 

  3469. 				

    3470. 

  3470. 			

    3471. 

  3471. 			

    3472. 

  3472. 			

    3473. 

  3473. 			public interface I

    3474. 

  3474. 			{

    3475. 

  3475. 			    void M();

    3476. 

  3476. 			}

    3477. 

  3477. 			

    3478. 

  3478. 			public  class C : IEquatable<C>, I

    3479. 

  3479. 			{

    3480. 

  3480. 			    void I.M()

    3481. 

  3481. 			    {

    3482. 

  3482. 			    }

    3483. 

  3483. 			

    3484. 

  3484. 			    public override bool Equals(object o)

    3485. 

  3485. 			    {

    3486. 

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

    3487. 

  3487. 			    }

    3488. 

  3488. 			

    3489. 

  3489. 			    public bool Equals(C c)

    3490. 

  3490. 			    {

    3491. 

  3491. 			        return c != null;

    3492. 

  3492. 			    }

    3493. 

  3493. 			

    3494. 

  3494. 			    public override int GetHashCode()

    3495. 

  3495. 			    {

    3496. 

  3496. 			        return 0;

    3497. 

  3497. 			    }

    3498. 

  3498. 			}

    3499. 

  3499. 			

    3500. 

  3500. 			public  class D : C, IEquatable<D>

    3501. 

  3501. 			{

    3502. 

  3502. 			    public int Val;

    3503. 

  3503. 			    public D()

    3504. 

  3504. 			    {

    3505. 

  3505. 			    }

    3506. 

  3506. 			    public D(int val)

    3507. 

  3507. 			    {

    3508. 

  3508. 			        Val = val;

    3509. 

  3509. 			    }

    3510. 

  3510. 			

    3511. 

  3511. 			    public override bool Equals(object o)

    3512. 

  3512. 			    {

    3513. 

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

    3514. 

  3514. 			    }

    3515. 

  3515. 			

    3516. 

  3516. 			    public bool Equals(D d)

    3517. 

  3517. 			    {

    3518. 

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

    3519. 

  3519. 			    }

    3520. 

  3520. 			

    3521. 

  3521. 			    public override int GetHashCode()

    3522. 

  3522. 			    {

    3523. 

  3523. 			        return Val;

    3524. 

  3524. 			    }

    3525. 

  3525. 			}

    3526. 

  3526. 			

    3527. 

  3527. 			public enum E

    3528. 

  3528. 			{

    3529. 

  3529. 			    A = 1, B = 2

    3530. 

  3530. 			}

    3531. 

  3531. 			

    3532. 

  3532. 			public enum El : long

    3533. 

  3533. 			{

    3534. 

  3534. 			    A, B, C

    3535. 

  3535. 			}

    3536. 

  3536. 			

    3537. 

  3537. 			public struct S : IEquatable<S>

    3538. 

  3538. 			{

    3539. 

  3539. 			    public override bool Equals(object o)

    3540. 

  3540. 			    {

    3541. 

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

    3542. 

  3542. 			    }

    3543. 

  3543. 			    public bool Equals(S other)

    3544. 

  3544. 			    {

    3545. 

  3545. 			        return true;

    3546. 

  3546. 			    }

    3547. 

  3547. 			    public override int GetHashCode()

    3548. 

  3548. 			    {

    3549. 

  3549. 			        return 0;

    3550. 

  3550. 			    }

    3551. 

  3551. 			}

    3552. 

  3552. 			

    3553. 

  3553. 			public struct Sp : IEquatable<Sp>

    3554. 

  3554. 			{

    3555. 

  3555. 			    public Sp(int i, double d)

    3556. 

  3556. 			    {

    3557. 

  3557. 			        I = i;

    3558. 

  3558. 			        D = d;

    3559. 

  3559. 			    }

    3560. 

  3560. 			

    3561. 

  3561. 			    public int I;

    3562. 

  3562. 			    public double D;

    3563. 

  3563. 			

    3564. 

  3564. 			    public override bool Equals(object o)

    3565. 

  3565. 			    {

    3566. 

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

    3567. 

  3567. 			    }

    3568. 

  3568. 			    public bool Equals(Sp other)

    3569. 

  3569. 			    {

    3570. 

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

    3571. 

  3571. 			    }

    3572. 

  3572. 			    public override int GetHashCode()

    3573. 

  3573. 			    {

    3574. 

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

    3575. 

  3575. 			    }

    3576. 

  3576. 			}

    3577. 

  3577. 			

    3578. 

  3578. 			public struct Ss : IEquatable<Ss>

    3579. 

  3579. 			{

    3580. 

  3580. 			    public Ss(S s)

    3581. 

  3581. 			    {

    3582. 

  3582. 			        Val = s;

    3583. 

  3583. 			    }

    3584. 

  3584. 			

    3585. 

  3585. 			    public S Val;

    3586. 

  3586. 			

    3587. 

  3587. 			    public override bool Equals(object o)

    3588. 

  3588. 			    {

    3589. 

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

    3590. 

  3590. 			    }

    3591. 

  3591. 			    public bool Equals(Ss other)

    3592. 

  3592. 			    {

    3593. 

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

    3594. 

  3594. 			    }

    3595. 

  3595. 			    public override int GetHashCode()

    3596. 

  3596. 			    {

    3597. 

  3597. 			        return Val.GetHashCode();

    3598. 

  3598. 			    }

    3599. 

  3599. 			}

    3600. 

  3600. 			

    3601. 

  3601. 			public struct Sc : IEquatable<Sc>

    3602. 

  3602. 			{

    3603. 

  3603. 			    public Sc(string s)

    3604. 

  3604. 			    {

    3605. 

  3605. 			        S = s;

    3606. 

  3606. 			    }

    3607. 

  3607. 			

    3608. 

  3608. 			    public string S;

    3609. 

  3609. 			

    3610. 

  3610. 			    public override bool Equals(object o)

    3611. 

  3611. 			    {

    3612. 

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

    3613. 

  3613. 			    }

    3614. 

  3614. 			    public bool Equals(Sc other)

    3615. 

  3615. 			    {

    3616. 

  3616. 			        return other.S == S;

    3617. 

  3617. 			    }

    3618. 

  3618. 			    public override int GetHashCode()

    3619. 

  3619. 			    {

    3620. 

  3620. 			        return S.GetHashCode();

    3621. 

  3621. 			    }

    3622. 

  3622. 			}

    3623. 

  3623. 			

    3624. 

  3624. 			public struct Scs : IEquatable<Scs>

    3625. 

  3625. 			{

    3626. 

  3626. 			    public Scs(string s, S val)

    3627. 

  3627. 			    {

    3628. 

  3628. 			        S = s;

    3629. 

  3629. 			        Val = val;

    3630. 

  3630. 			    }

    3631. 

  3631. 			

    3632. 

  3632. 			    public string S;

    3633. 

  3633. 			    public S Val;

    3634. 

  3634. 			

    3635. 

  3635. 			    public override bool Equals(object o)

    3636. 

  3636. 			    {

    3637. 

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

    3638. 

  3638. 			    }

    3639. 

  3639. 			    public bool Equals(Scs other)

    3640. 

  3640. 			    {

    3641. 

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

    3642. 

  3642. 			    }

    3643. 

  3643. 			    public override int GetHashCode()

    3644. 

  3644. 			    {

    3645. 

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

    3646. 

  3646. 			    }

    3647. 

  3647. 			}

    3648. 

  3648. 			

    3649. 

  3649. 		

    3650. 

  3650. 	}

    3651. 

  3651. 				

    3652. 

  3652. 				//-------- Scenario 3143

    3653. 

  3653. 				namespace Scenario3143{

    3654. 

  3654. 					

    3655. 

  3655. 					public class Test

    3656. 

  3656. 					{

    3657. 

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

    3658. 

  3658. 				    public static Expression Ts_ArrayIndex_Scs___() {

    3659. 

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

    3660. 

  3660. 				           throw new Exception();

    3661. 

  3661. 				       } else { 

    3662. 

  3662. 				           return Expression.Constant(0);

    3663. 

  3663. 				       }

    3664. 

  3664. 				    }

    3665. 

  3665. 					public     static int Main()

    3666. 

  3666. 					    {

    3667. 

  3667. 					        Ext.StartCapture();

    3668. 

  3668. 					        bool success = false;

    3669. 

  3669. 					        try

    3670. 

  3670. 					        {

    3671. 

  3671. 					            success = check_Ts_ArrayIndex<Scs>();

    3672. 

  3672. 					        }

    3673. 

  3673. 					        finally

    3674. 

  3674. 					        {

    3675. 

  3675. 					            Ext.StopCapture();

    3676. 

  3676. 					        }

    3677. 

  3677. 					        return success ? 0 : 1;

    3678. 

  3678. 					    }

    3679. 

  3679. 					

    3680. 

  3680. 					    static bool check_Ts_ArrayIndex<Ts>() where Ts : struct

    3681. 

  3681. 					    {

    3682. 

  3682. 					        return checkEx_Ts_ArrayIndex<Ts>(null, -1) &

    3683. 

  3683. 					            checkEx_Ts_ArrayIndex<Ts>(null, 0) &

    3684. 

  3684. 					            checkEx_Ts_ArrayIndex<Ts>(null, 1) &

    3685. 

  3685. 					

    3686. 

  3686. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(0)) &

    3687. 

  3687. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(1)) &

    3688. 

  3688. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(5));

    3689. 

  3689. 					    }

    3690. 

  3690. 					

    3691. 

  3691. 					    static Ts[] genArrTs_ArrayIndex<Ts>(int size) where Ts : struct

    3692. 

  3692. 					    {

    3693. 

  3693. 					        Ts[] vals = new Ts[] { default(Ts), new Ts() };

    3694. 

  3694. 					        Ts[] result = new Ts[size];

    3695. 

  3695. 					        for (int i = 0; i < size; i++)

    3696. 

  3696. 					        {

    3697. 

  3697. 					            result[i] = vals[i % vals.Length];

    3698. 

  3698. 					        }

    3699. 

  3699. 					        return result;

    3700. 

  3700. 					    }

    3701. 

  3701. 					

    3702. 

  3702. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val) where Ts : struct

    3703. 

  3703. 					    {

    3704. 

  3704. 					        bool success = checkEx_Ts_ArrayIndex<Ts>(val, -1);

    3705. 

  3705. 					        for (int i = 0; i < val.Length; i++)

    3706. 

  3706. 					        {

    3707. 

  3707. 					            success &= check_Ts_ArrayIndex<Ts>(val, 0);

    3708. 

  3708. 					        }

    3709. 

  3709. 					        success &= checkEx_Ts_ArrayIndex<Ts>(val, val.Length);

    3710. 

  3710. 					        return success;

    3711. 

  3711. 					    }

    3712. 

  3712. 					

    3713. 

  3713. 					    static bool checkEx_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    3714. 

  3714. 					    {

    3715. 

  3715. 					        try

    3716. 

  3716. 					        {

    3717. 

  3717. 					            check_Ts_ArrayIndex<Ts>(val, index);

    3718. 

  3718. 					            Console.WriteLine("Ts_ArrayIndex[" + index + "] failed");

    3719. 

  3719. 					            return false;

    3720. 

  3720. 					        }

    3721. 

  3721. 					        catch

    3722. 

  3722. 					        {

    3723. 

  3723. 					            return true;

    3724. 

  3724. 					        }

    3725. 

  3725. 					    }

    3726. 

  3726. 					

    3727. 

  3727. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    3728. 

  3728. 					    {

    3729. 

  3729. 					        Expression<Func<Ts>> e =

    3730. 

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

    3731. 

  3731. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Ts[])),

    3732. 

  3732. 					                    Expression.Constant(index, typeof(int))),

    3733. 

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

    3734. 

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

    3735. 

  3735. 					        return object.Equals(f(), val[index]);

    3736. 

  3736. 					    }

    3737. 

  3737. 					}

    3738. 

  3738. 				

    3739. 

  3739. 				

    3740. 

  3740. 				public  static class Ext {

    3741. 

  3741. 				    public static void StartCapture() {

    3742. 

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

    3743. 

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

    3744. 

  3744. 				    }

    3745. 

  3745. 				

    3746. 

  3746. 				    public static void StopCapture() {

    3747. 

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

    3748. 

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

    3749. 

  3749. 				    }

    3750. 

  3750. 				

    3751. 

  3751. 				    public static bool IsIntegralOrEnum(Type type) {

    3752. 

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

    3753. 

  3753. 				            case TypeCode.Byte:

    3754. 

  3754. 				            case TypeCode.SByte:

    3755. 

  3755. 				            case TypeCode.Int16:

    3756. 

  3756. 				            case TypeCode.Int32:

    3757. 

  3757. 				            case TypeCode.Int64:

    3758. 

  3758. 				            case TypeCode.UInt16:

    3759. 

  3759. 				            case TypeCode.UInt32:

    3760. 

  3760. 				            case TypeCode.UInt64:

    3761. 

  3761. 				                return true;

    3762. 

  3762. 				            default:

    3763. 

  3763. 				                return false;

    3764. 

  3764. 				        }

    3765. 

  3765. 				    }

    3766. 

  3766. 				

    3767. 

  3767. 				    public static bool IsFloating(Type type) {

    3768. 

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

    3769. 

  3769. 				            case TypeCode.Single:

    3770. 

  3770. 				            case TypeCode.Double:

    3771. 

  3771. 				                return true;

    3772. 

  3772. 				            default:

    3773. 

  3773. 				                return false;

    3774. 

  3774. 				        }

    3775. 

  3775. 				    }

    3776. 

  3776. 				

    3777. 

  3777. 				    public static Type GetNonNullableType(Type type) {

    3778. 

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

    3779. 

  3779. 				                type.GetGenericArguments()[0] :

    3780. 

  3780. 				                type;

    3781. 

  3781. 				    }

    3782. 

  3782. 				}

    3783. 

  3783. 				

    3784. 

  3784. 			

    3785. 

  3785. 			

    3786. 

  3786. 			

    3787. 

  3787. 			public interface I

    3788. 

  3788. 			{

    3789. 

  3789. 			    void M();

    3790. 

  3790. 			}

    3791. 

  3791. 			

    3792. 

  3792. 			public  class C : IEquatable<C>, I

    3793. 

  3793. 			{

    3794. 

  3794. 			    void I.M()

    3795. 

  3795. 			    {

    3796. 

  3796. 			    }

    3797. 

  3797. 			

    3798. 

  3798. 			    public override bool Equals(object o)

    3799. 

  3799. 			    {

    3800. 

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

    3801. 

  3801. 			    }

    3802. 

  3802. 			

    3803. 

  3803. 			    public bool Equals(C c)

    3804. 

  3804. 			    {

    3805. 

  3805. 			        return c != null;

    3806. 

  3806. 			    }

    3807. 

  3807. 			

    3808. 

  3808. 			    public override int GetHashCode()

    3809. 

  3809. 			    {

    3810. 

  3810. 			        return 0;

    3811. 

  3811. 			    }

    3812. 

  3812. 			}

    3813. 

  3813. 			

    3814. 

  3814. 			public  class D : C, IEquatable<D>

    3815. 

  3815. 			{

    3816. 

  3816. 			    public int Val;

    3817. 

  3817. 			    public D()

    3818. 

  3818. 			    {

    3819. 

  3819. 			    }

    3820. 

  3820. 			    public D(int val)

    3821. 

  3821. 			    {

    3822. 

  3822. 			        Val = val;

    3823. 

  3823. 			    }

    3824. 

  3824. 			

    3825. 

  3825. 			    public override bool Equals(object o)

    3826. 

  3826. 			    {

    3827. 

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

    3828. 

  3828. 			    }

    3829. 

  3829. 			

    3830. 

  3830. 			    public bool Equals(D d)

    3831. 

  3831. 			    {

    3832. 

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

    3833. 

  3833. 			    }

    3834. 

  3834. 			

    3835. 

  3835. 			    public override int GetHashCode()

    3836. 

  3836. 			    {

    3837. 

  3837. 			        return Val;

    3838. 

  3838. 			    }

    3839. 

  3839. 			}

    3840. 

  3840. 			

    3841. 

  3841. 			public enum E

    3842. 

  3842. 			{

    3843. 

  3843. 			    A = 1, B = 2

    3844. 

  3844. 			}

    3845. 

  3845. 			

    3846. 

  3846. 			public enum El : long

    3847. 

  3847. 			{

    3848. 

  3848. 			    A, B, C

    3849. 

  3849. 			}

    3850. 

  3850. 			

    3851. 

  3851. 			public struct S : IEquatable<S>

    3852. 

  3852. 			{

    3853. 

  3853. 			    public override bool Equals(object o)

    3854. 

  3854. 			    {

    3855. 

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

    3856. 

  3856. 			    }

    3857. 

  3857. 			    public bool Equals(S other)

    3858. 

  3858. 			    {

    3859. 

  3859. 			        return true;

    3860. 

  3860. 			    }

    3861. 

  3861. 			    public override int GetHashCode()

    3862. 

  3862. 			    {

    3863. 

  3863. 			        return 0;

    3864. 

  3864. 			    }

    3865. 

  3865. 			}

    3866. 

  3866. 			

    3867. 

  3867. 			public struct Sp : IEquatable<Sp>

    3868. 

  3868. 			{

    3869. 

  3869. 			    public Sp(int i, double d)

    3870. 

  3870. 			    {

    3871. 

  3871. 			        I = i;

    3872. 

  3872. 			        D = d;

    3873. 

  3873. 			    }

    3874. 

  3874. 			

    3875. 

  3875. 			    public int I;

    3876. 

  3876. 			    public double D;

    3877. 

  3877. 			

    3878. 

  3878. 			    public override bool Equals(object o)

    3879. 

  3879. 			    {

    3880. 

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

    3881. 

  3881. 			    }

    3882. 

  3882. 			    public bool Equals(Sp other)

    3883. 

  3883. 			    {

    3884. 

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

    3885. 

  3885. 			    }

    3886. 

  3886. 			    public override int GetHashCode()

    3887. 

  3887. 			    {

    3888. 

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

    3889. 

  3889. 			    }

    3890. 

  3890. 			}

    3891. 

  3891. 			

    3892. 

  3892. 			public struct Ss : IEquatable<Ss>

    3893. 

  3893. 			{

    3894. 

  3894. 			    public Ss(S s)

    3895. 

  3895. 			    {

    3896. 

  3896. 			        Val = s;

    3897. 

  3897. 			    }

    3898. 

  3898. 			

    3899. 

  3899. 			    public S Val;

    3900. 

  3900. 			

    3901. 

  3901. 			    public override bool Equals(object o)

    3902. 

  3902. 			    {

    3903. 

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

    3904. 

  3904. 			    }

    3905. 

  3905. 			    public bool Equals(Ss other)

    3906. 

  3906. 			    {

    3907. 

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

    3908. 

  3908. 			    }

    3909. 

  3909. 			    public override int GetHashCode()

    3910. 

  3910. 			    {

    3911. 

  3911. 			        return Val.GetHashCode();

    3912. 

  3912. 			    }

    3913. 

  3913. 			}

    3914. 

  3914. 			

    3915. 

  3915. 			public struct Sc : IEquatable<Sc>

    3916. 

  3916. 			{

    3917. 

  3917. 			    public Sc(string s)

    3918. 

  3918. 			    {

    3919. 

  3919. 			        S = s;

    3920. 

  3920. 			    }

    3921. 

  3921. 			

    3922. 

  3922. 			    public string S;

    3923. 

  3923. 			

    3924. 

  3924. 			    public override bool Equals(object o)

    3925. 

  3925. 			    {

    3926. 

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

    3927. 

  3927. 			    }

    3928. 

  3928. 			    public bool Equals(Sc other)

    3929. 

  3929. 			    {

    3930. 

  3930. 			        return other.S == S;

    3931. 

  3931. 			    }

    3932. 

  3932. 			    public override int GetHashCode()

    3933. 

  3933. 			    {

    3934. 

  3934. 			        return S.GetHashCode();

    3935. 

  3935. 			    }

    3936. 

  3936. 			}

    3937. 

  3937. 			

    3938. 

  3938. 			public struct Scs : IEquatable<Scs>

    3939. 

  3939. 			{

    3940. 

  3940. 			    public Scs(string s, S val)

    3941. 

  3941. 			    {

    3942. 

  3942. 			        S = s;

    3943. 

  3943. 			        Val = val;

    3944. 

  3944. 			    }

    3945. 

  3945. 			

    3946. 

  3946. 			    public string S;

    3947. 

  3947. 			    public S Val;

    3948. 

  3948. 			

    3949. 

  3949. 			    public override bool Equals(object o)

    3950. 

  3950. 			    {

    3951. 

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

    3952. 

  3952. 			    }

    3953. 

  3953. 			    public bool Equals(Scs other)

    3954. 

  3954. 			    {

    3955. 

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

    3956. 

  3956. 			    }

    3957. 

  3957. 			    public override int GetHashCode()

    3958. 

  3958. 			    {

    3959. 

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

    3960. 

  3960. 			    }

    3961. 

  3961. 			}

    3962. 

  3962. 			

    3963. 

  3963. 		

    3964. 

  3964. 	}

    3965. 

  3965. 				

    3966. 

  3966. 				//-------- Scenario 3144

    3967. 

  3967. 				namespace Scenario3144{

    3968. 

  3968. 					

    3969. 

  3969. 					public class Test

    3970. 

  3970. 					{

    3971. 

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

    3972. 

  3972. 				    public static Expression Ts_ArrayIndex_E___() {

    3973. 

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

    3974. 

  3974. 				           throw new Exception();

    3975. 

  3975. 				       } else { 

    3976. 

  3976. 				           return Expression.Constant(0);

    3977. 

  3977. 				       }

    3978. 

  3978. 				    }

    3979. 

  3979. 					public     static int Main()

    3980. 

  3980. 					    {

    3981. 

  3981. 					        Ext.StartCapture();

    3982. 

  3982. 					        bool success = false;

    3983. 

  3983. 					        try

    3984. 

  3984. 					        {

    3985. 

  3985. 					            success = check_Ts_ArrayIndex<E>();

    3986. 

  3986. 					        }

    3987. 

  3987. 					        finally

    3988. 

  3988. 					        {

    3989. 

  3989. 					            Ext.StopCapture();

    3990. 

  3990. 					        }

    3991. 

  3991. 					        return success ? 0 : 1;

    3992. 

  3992. 					    }

    3993. 

  3993. 					

    3994. 

  3994. 					    static bool check_Ts_ArrayIndex<Ts>() where Ts : struct

    3995. 

  3995. 					    {

    3996. 

  3996. 					        return checkEx_Ts_ArrayIndex<Ts>(null, -1) &

    3997. 

  3997. 					            checkEx_Ts_ArrayIndex<Ts>(null, 0) &

    3998. 

  3998. 					            checkEx_Ts_ArrayIndex<Ts>(null, 1) &

    3999. 

  3999. 					

    4000. 

  4000. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(0)) &

    4001. 

  4001. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(1)) &

    4002. 

  4002. 					            check_Ts_ArrayIndex<Ts>(genArrTs_ArrayIndex<Ts>(5));

    4003. 

  4003. 					    }

    4004. 

  4004. 					

    4005. 

  4005. 					    static Ts[] genArrTs_ArrayIndex<Ts>(int size) where Ts : struct

    4006. 

  4006. 					    {

    4007. 

  4007. 					        Ts[] vals = new Ts[] { default(Ts), new Ts() };

    4008. 

  4008. 					        Ts[] result = new Ts[size];

    4009. 

  4009. 					        for (int i = 0; i < size; i++)

    4010. 

  4010. 					        {

    4011. 

  4011. 					            result[i] = vals[i % vals.Length];

    4012. 

  4012. 					        }

    4013. 

  4013. 					        return result;

    4014. 

  4014. 					    }

    4015. 

  4015. 					

    4016. 

  4016. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val) where Ts : struct

    4017. 

  4017. 					    {

    4018. 

  4018. 					        bool success = checkEx_Ts_ArrayIndex<Ts>(val, -1);

    4019. 

  4019. 					        for (int i = 0; i < val.Length; i++)

    4020. 

  4020. 					        {

    4021. 

  4021. 					            success &= check_Ts_ArrayIndex<Ts>(val, 0);

    4022. 

  4022. 					        }

    4023. 

  4023. 					        success &= checkEx_Ts_ArrayIndex<Ts>(val, val.Length);

    4024. 

  4024. 					        return success;

    4025. 

  4025. 					    }

    4026. 

  4026. 					

    4027. 

  4027. 					    static bool checkEx_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    4028. 

  4028. 					    {

    4029. 

  4029. 					        try

    4030. 

  4030. 					        {

    4031. 

  4031. 					            check_Ts_ArrayIndex<Ts>(val, index);

    4032. 

  4032. 					            Console.WriteLine("Ts_ArrayIndex[" + index + "] failed");

    4033. 

  4033. 					            return false;

    4034. 

  4034. 					        }

    4035. 

  4035. 					        catch

    4036. 

  4036. 					        {

    4037. 

  4037. 					            return true;

    4038. 

  4038. 					        }

    4039. 

  4039. 					    }

    4040. 

  4040. 					

    4041. 

  4041. 					    static bool check_Ts_ArrayIndex<Ts>(Ts[] val, int index) where Ts : struct

    4042. 

  4042. 					    {

    4043. 

  4043. 					        Expression<Func<Ts>> e =

    4044. 

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

    4045. 

  4045. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Ts[])),

    4046. 

  4046. 					                    Expression.Constant(index, typeof(int))),

    4047. 

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

    4048. 

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

    4049. 

  4049. 					        return object.Equals(f(), val[index]);

    4050. 

  4050. 					    }

    4051. 

  4051. 					}

    4052. 

  4052. 				

    4053. 

  4053. 				

    4054. 

  4054. 				public  static class Ext {

    4055. 

  4055. 				    public static void StartCapture() {

    4056. 

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

    4057. 

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

    4058. 

  4058. 				    }

    4059. 

  4059. 				

    4060. 

  4060. 				    public static void StopCapture() {

    4061. 

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

    4062. 

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

    4063. 

  4063. 				    }

    4064. 

  4064. 				

    4065. 

  4065. 				    public static bool IsIntegralOrEnum(Type type) {

    4066. 

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

    4067. 

  4067. 				            case TypeCode.Byte:

    4068. 

  4068. 				            case TypeCode.SByte:

    4069. 

  4069. 				            case TypeCode.Int16:

    4070. 

  4070. 				            case TypeCode.Int32:

    4071. 

  4071. 				            case TypeCode.Int64:

    4072. 

  4072. 				            case TypeCode.UInt16:

    4073. 

  4073. 				            case TypeCode.UInt32:

    4074. 

  4074. 				            case TypeCode.UInt64:

    4075. 

  4075. 				                return true;

    4076. 

  4076. 				            default:

    4077. 

  4077. 				                return false;

    4078. 

  4078. 				        }

    4079. 

  4079. 				    }

    4080. 

  4080. 				

    4081. 

  4081. 				    public static bool IsFloating(Type type) {

    4082. 

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

    4083. 

  4083. 				            case TypeCode.Single:

    4084. 

  4084. 				            case TypeCode.Double:

    4085. 

  4085. 				                return true;

    4086. 

  4086. 				            default:

    4087. 

  4087. 				                return false;

    4088. 

  4088. 				        }

    4089. 

  4089. 				    }

    4090. 

  4090. 				

    4091. 

  4091. 				    public static Type GetNonNullableType(Type type) {

    4092. 

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

    4093. 

  4093. 				                type.GetGenericArguments()[0] :

    4094. 

  4094. 				                type;

    4095. 

  4095. 				    }

    4096. 

  4096. 				}

    4097. 

  4097. 				

    4098. 

  4098. 			

    4099. 

  4099. 			

    4100. 

  4100. 			

    4101. 

  4101. 			public interface I

    4102. 

  4102. 			{

    4103. 

  4103. 			    void M();

    4104. 

  4104. 			}

    4105. 

  4105. 			

    4106. 

  4106. 			public  class C : IEquatable<C>, I

    4107. 

  4107. 			{

    4108. 

  4108. 			    void I.M()

    4109. 

  4109. 			    {

    4110. 

  4110. 			    }

    4111. 

  4111. 			

    4112. 

  4112. 			    public override bool Equals(object o)

    4113. 

  4113. 			    {

    4114. 

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

    4115. 

  4115. 			    }

    4116. 

  4116. 			

    4117. 

  4117. 			    public bool Equals(C c)

    4118. 

  4118. 			    {

    4119. 

  4119. 			        return c != null;

    4120. 

  4120. 			    }

    4121. 

  4121. 			

    4122. 

  4122. 			    public override int GetHashCode()

    4123. 

  4123. 			    {

    4124. 

  4124. 			        return 0;

    4125. 

  4125. 			    }

    4126. 

  4126. 			}

    4127. 

  4127. 			

    4128. 

  4128. 			public  class D : C, IEquatable<D>

    4129. 

  4129. 			{

    4130. 

  4130. 			    public int Val;

    4131. 

  4131. 			    public D()

    4132. 

  4132. 			    {

    4133. 

  4133. 			    }

    4134. 

  4134. 			    public D(int val)

    4135. 

  4135. 			    {

    4136. 

  4136. 			        Val = val;

    4137. 

  4137. 			    }

    4138. 

  4138. 			

    4139. 

  4139. 			    public override bool Equals(object o)

    4140. 

  4140. 			    {

    4141. 

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

    4142. 

  4142. 			    }

    4143. 

  4143. 			

    4144. 

  4144. 			    public bool Equals(D d)

    4145. 

  4145. 			    {

    4146. 

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

    4147. 

  4147. 			    }

    4148. 

  4148. 			

    4149. 

  4149. 			    public override int GetHashCode()

    4150. 

  4150. 			    {

    4151. 

  4151. 			        return Val;

    4152. 

  4152. 			    }

    4153. 

  4153. 			}

    4154. 

  4154. 			

    4155. 

  4155. 			public enum E

    4156. 

  4156. 			{

    4157. 

  4157. 			    A = 1, B = 2

    4158. 

  4158. 			}

    4159. 

  4159. 			

    4160. 

  4160. 			public enum El : long

    4161. 

  4161. 			{

    4162. 

  4162. 			    A, B, C

    4163. 

  4163. 			}

    4164. 

  4164. 			

    4165. 

  4165. 			public struct S : IEquatable<S>

    4166. 

  4166. 			{

    4167. 

  4167. 			    public override bool Equals(object o)

    4168. 

  4168. 			    {

    4169. 

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

    4170. 

  4170. 			    }

    4171. 

  4171. 			    public bool Equals(S other)

    4172. 

  4172. 			    {

    4173. 

  4173. 			        return true;

    4174. 

  4174. 			    }

    4175. 

  4175. 			    public override int GetHashCode()

    4176. 

  4176. 			    {

    4177. 

  4177. 			        return 0;

    4178. 

  4178. 			    }

    4179. 

  4179. 			}

    4180. 

  4180. 			

    4181. 

  4181. 			public struct Sp : IEquatable<Sp>

    4182. 

  4182. 			{

    4183. 

  4183. 			    public Sp(int i, double d)

    4184. 

  4184. 			    {

    4185. 

  4185. 			        I = i;

    4186. 

  4186. 			        D = d;

    4187. 

  4187. 			    }

    4188. 

  4188. 			

    4189. 

  4189. 			    public int I;

    4190. 

  4190. 			    public double D;

    4191. 

  4191. 			

    4192. 

  4192. 			    public override bool Equals(object o)

    4193. 

  4193. 			    {

    4194. 

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

    4195. 

  4195. 			    }

    4196. 

  4196. 			    public bool Equals(Sp other)

    4197. 

  4197. 			    {

    4198. 

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

    4199. 

  4199. 			    }

    4200. 

  4200. 			    public override int GetHashCode()

    4201. 

  4201. 			    {

    4202. 

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

    4203. 

  4203. 			    }

    4204. 

  4204. 			}

    4205. 

  4205. 			

    4206. 

  4206. 			public struct Ss : IEquatable<Ss>

    4207. 

  4207. 			{

    4208. 

  4208. 			    public Ss(S s)

    4209. 

  4209. 			    {

    4210. 

  4210. 			        Val = s;

    4211. 

  4211. 			    }

    4212. 

  4212. 			

    4213. 

  4213. 			    public S Val;

    4214. 

  4214. 			

    4215. 

  4215. 			    public override bool Equals(object o)

    4216. 

  4216. 			    {

    4217. 

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

    4218. 

  4218. 			    }

    4219. 

  4219. 			    public bool Equals(Ss other)

    4220. 

  4220. 			    {

    4221. 

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

    4222. 

  4222. 			    }

    4223. 

  4223. 			    public override int GetHashCode()

    4224. 

  4224. 			    {

    4225. 

  4225. 			        return Val.GetHashCode();

    4226. 

  4226. 			    }

    4227. 

  4227. 			}

    4228. 

  4228. 			

    4229. 

  4229. 			public struct Sc : IEquatable<Sc>

    4230. 

  4230. 			{

    4231. 

  4231. 			    public Sc(string s)

    4232. 

  4232. 			    {

    4233. 

  4233. 			        S = s;

    4234. 

  4234. 			    }

    4235. 

  4235. 			

    4236. 

  4236. 			    public string S;

    4237. 

  4237. 			

    4238. 

  4238. 			    public override bool Equals(object o)

    4239. 

  4239. 			    {

    4240. 

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

    4241. 

  4241. 			    }

    4242. 

  4242. 			    public bool Equals(Sc other)

    4243. 

  4243. 			    {

    4244. 

  4244. 			        return other.S == S;

    4245. 

  4245. 			    }

    4246. 

  4246. 			    public override int GetHashCode()

    4247. 

  4247. 			    {

    4248. 

  4248. 			        return S.GetHashCode();

    4249. 

  4249. 			    }

    4250. 

  4250. 			}

    4251. 

  4251. 			

    4252. 

  4252. 			public struct Scs : IEquatable<Scs>

    4253. 

  4253. 			{

    4254. 

  4254. 			    public Scs(string s, S val)

    4255. 

  4255. 			    {

    4256. 

  4256. 			        S = s;

    4257. 

  4257. 			        Val = val;

    4258. 

  4258. 			    }

    4259. 

  4259. 			

    4260. 

  4260. 			    public string S;

    4261. 

  4261. 			    public S Val;

    4262. 

  4262. 			

    4263. 

  4263. 			    public override bool Equals(object o)

    4264. 

  4264. 			    {

    4265. 

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

    4266. 

  4266. 			    }

    4267. 

  4267. 			    public bool Equals(Scs other)

    4268. 

  4268. 			    {

    4269. 

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

    4270. 

  4270. 			    }

    4271. 

  4271. 			    public override int GetHashCode()

    4272. 

  4272. 			    {

    4273. 

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

    4274. 

  4274. 			    }

    4275. 

  4275. 			}

    4276. 

  4276. 			

    4277. 

  4277. 		

    4278. 

  4278. 	}

    4279. 

  4279. 				

    4280. 

  4280. 				//-------- Scenario 3145

    4281. 

  4281. 				namespace Scenario3145{

    4282. 

  4282. 					

    4283. 

  4283. 					public class Test

    4284. 

  4284. 					{

    4285. 

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

    4286. 

  4286. 				    public static Expression E_ArrayIndex__() {

    4287. 

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

    4288. 

  4288. 				           throw new Exception();

    4289. 

  4289. 				       } else { 

    4290. 

  4290. 				           return Expression.Constant(0);

    4291. 

  4291. 				       }

    4292. 

  4292. 				    }

    4293. 

  4293. 					public     static int Main()

    4294. 

  4294. 					    {

    4295. 

  4295. 					        Ext.StartCapture();

    4296. 

  4296. 					        bool success = false;

    4297. 

  4297. 					        try

    4298. 

  4298. 					        {

    4299. 

  4299. 					            success = check_E_ArrayIndex();

    4300. 

  4300. 					        }

    4301. 

  4301. 					        finally

    4302. 

  4302. 					        {

    4303. 

  4303. 					            Ext.StopCapture();

    4304. 

  4304. 					        }

    4305. 

  4305. 					        return success ? 0 : 1;

    4306. 

  4306. 					    }

    4307. 

  4307. 					

    4308. 

  4308. 					    static bool check_E_ArrayIndex()

    4309. 

  4309. 					    {

    4310. 

  4310. 					        return checkEx_E_ArrayIndex(null, -1) &

    4311. 

  4311. 					            checkEx_E_ArrayIndex(null, 0) &

    4312. 

  4312. 					            checkEx_E_ArrayIndex(null, 1) &

    4313. 

  4313. 					

    4314. 

  4314. 					            check_E_ArrayIndex(genArrE_ArrayIndex(0)) &

    4315. 

  4315. 					            check_E_ArrayIndex(genArrE_ArrayIndex(1)) &

    4316. 

  4316. 					            check_E_ArrayIndex(genArrE_ArrayIndex(5));

    4317. 

  4317. 					    }

    4318. 

  4318. 					

    4319. 

  4319. 					    static E[] genArrE_ArrayIndex(int size)

    4320. 

  4320. 					    {

    4321. 

  4321. 					        E[] vals = new E[] { (E)0, E.A, E.B, (E)int.MaxValue, (E)int.MinValue };

    4322. 

  4322. 					        E[] result = new E[size];

    4323. 

  4323. 					        for (int i = 0; i < size; i++)

    4324. 

  4324. 					        {

    4325. 

  4325. 					            result[i] = vals[i % vals.Length];

    4326. 

  4326. 					        }

    4327. 

  4327. 					        return result;

    4328. 

  4328. 					    }

    4329. 

  4329. 					

    4330. 

  4330. 					    static bool check_E_ArrayIndex(E[] val)

    4331. 

  4331. 					    {

    4332. 

  4332. 					        bool success = checkEx_E_ArrayIndex(val, -1);

    4333. 

  4333. 					        for (int i = 0; i < val.Length; i++)

    4334. 

  4334. 					        {

    4335. 

  4335. 					            success &= check_E_ArrayIndex(val, 0);

    4336. 

  4336. 					        }

    4337. 

  4337. 					        success &= checkEx_E_ArrayIndex(val, val.Length);

    4338. 

  4338. 					        return success;

    4339. 

  4339. 					    }

    4340. 

  4340. 					

    4341. 

  4341. 					    static bool checkEx_E_ArrayIndex(E[] val, int index)

    4342. 

  4342. 					    {

    4343. 

  4343. 					        try

    4344. 

  4344. 					        {

    4345. 

  4345. 					            check_E_ArrayIndex(val, index);

    4346. 

  4346. 					            Console.WriteLine("E_ArrayIndex[" + index + "] failed");

    4347. 

  4347. 					            return false;

    4348. 

  4348. 					        }

    4349. 

  4349. 					        catch

    4350. 

  4350. 					        {

    4351. 

  4351. 					            return true;

    4352. 

  4352. 					        }

    4353. 

  4353. 					    }

    4354. 

  4354. 					

    4355. 

  4355. 					    static bool check_E_ArrayIndex(E[] val, int index)

    4356. 

  4356. 					    {

    4357. 

  4357. 					        Expression<Func<E>> e =

    4358. 

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

    4359. 

  4359. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(E[])),

    4360. 

  4360. 					                    Expression.Constant(index, typeof(int))),

    4361. 

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

    4362. 

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

    4363. 

  4363. 					        return object.Equals(f(), val[index]);

    4364. 

  4364. 					    }

    4365. 

  4365. 					}

    4366. 

  4366. 				

    4367. 

  4367. 				

    4368. 

  4368. 				public  static class Ext {

    4369. 

  4369. 				    public static void StartCapture() {

    4370. 

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

    4371. 

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

    4372. 

  4372. 				    }

    4373. 

  4373. 				

    4374. 

  4374. 				    public static void StopCapture() {

    4375. 

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

    4376. 

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

    4377. 

  4377. 				    }

    4378. 

  4378. 				

    4379. 

  4379. 				    public static bool IsIntegralOrEnum(Type type) {

    4380. 

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

    4381. 

  4381. 				            case TypeCode.Byte:

    4382. 

  4382. 				            case TypeCode.SByte:

    4383. 

  4383. 				            case TypeCode.Int16:

    4384. 

  4384. 				            case TypeCode.Int32:

    4385. 

  4385. 				            case TypeCode.Int64:

    4386. 

  4386. 				            case TypeCode.UInt16:

    4387. 

  4387. 				            case TypeCode.UInt32:

    4388. 

  4388. 				            case TypeCode.UInt64:

    4389. 

  4389. 				                return true;

    4390. 

  4390. 				            default:

    4391. 

  4391. 				                return false;

    4392. 

  4392. 				        }

    4393. 

  4393. 				    }

    4394. 

  4394. 				

    4395. 

  4395. 				    public static bool IsFloating(Type type) {

    4396. 

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

    4397. 

  4397. 				            case TypeCode.Single:

    4398. 

  4398. 				            case TypeCode.Double:

    4399. 

  4399. 				                return true;

    4400. 

  4400. 				            default:

    4401. 

  4401. 				                return false;

    4402. 

  4402. 				        }

    4403. 

  4403. 				    }

    4404. 

  4404. 				

    4405. 

  4405. 				    public static Type GetNonNullableType(Type type) {

    4406. 

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

    4407. 

  4407. 				                type.GetGenericArguments()[0] :

    4408. 

  4408. 				                type;

    4409. 

  4409. 				    }

    4410. 

  4410. 				}

    4411. 

  4411. 				

    4412. 

  4412. 			

    4413. 

  4413. 			

    4414. 

  4414. 			

    4415. 

  4415. 			public interface I

    4416. 

  4416. 			{

    4417. 

  4417. 			    void M();

    4418. 

  4418. 			}

    4419. 

  4419. 			

    4420. 

  4420. 			public  class C : IEquatable<C>, I

    4421. 

  4421. 			{

    4422. 

  4422. 			    void I.M()

    4423. 

  4423. 			    {

    4424. 

  4424. 			    }

    4425. 

  4425. 			

    4426. 

  4426. 			    public override bool Equals(object o)

    4427. 

  4427. 			    {

    4428. 

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

    4429. 

  4429. 			    }

    4430. 

  4430. 			

    4431. 

  4431. 			    public bool Equals(C c)

    4432. 

  4432. 			    {

    4433. 

  4433. 			        return c != null;

    4434. 

  4434. 			    }

    4435. 

  4435. 			

    4436. 

  4436. 			    public override int GetHashCode()

    4437. 

  4437. 			    {

    4438. 

  4438. 			        return 0;

    4439. 

  4439. 			    }

    4440. 

  4440. 			}

    4441. 

  4441. 			

    4442. 

  4442. 			public  class D : C, IEquatable<D>

    4443. 

  4443. 			{

    4444. 

  4444. 			    public int Val;

    4445. 

  4445. 			    public D()

    4446. 

  4446. 			    {

    4447. 

  4447. 			    }

    4448. 

  4448. 			    public D(int val)

    4449. 

  4449. 			    {

    4450. 

  4450. 			        Val = val;

    4451. 

  4451. 			    }

    4452. 

  4452. 			

    4453. 

  4453. 			    public override bool Equals(object o)

    4454. 

  4454. 			    {

    4455. 

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

    4456. 

  4456. 			    }

    4457. 

  4457. 			

    4458. 

  4458. 			    public bool Equals(D d)

    4459. 

  4459. 			    {

    4460. 

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

    4461. 

  4461. 			    }

    4462. 

  4462. 			

    4463. 

  4463. 			    public override int GetHashCode()

    4464. 

  4464. 			    {

    4465. 

  4465. 			        return Val;

    4466. 

  4466. 			    }

    4467. 

  4467. 			}

    4468. 

  4468. 			

    4469. 

  4469. 			public enum E

    4470. 

  4470. 			{

    4471. 

  4471. 			    A = 1, B = 2

    4472. 

  4472. 			}

    4473. 

  4473. 			

    4474. 

  4474. 			public enum El : long

    4475. 

  4475. 			{

    4476. 

  4476. 			    A, B, C

    4477. 

  4477. 			}

    4478. 

  4478. 			

    4479. 

  4479. 			public struct S : IEquatable<S>

    4480. 

  4480. 			{

    4481. 

  4481. 			    public override bool Equals(object o)

    4482. 

  4482. 			    {

    4483. 

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

    4484. 

  4484. 			    }

    4485. 

  4485. 			    public bool Equals(S other)

    4486. 

  4486. 			    {

    4487. 

  4487. 			        return true;

    4488. 

  4488. 			    }

    4489. 

  4489. 			    public override int GetHashCode()

    4490. 

  4490. 			    {

    4491. 

  4491. 			        return 0;

    4492. 

  4492. 			    }

    4493. 

  4493. 			}

    4494. 

  4494. 			

    4495. 

  4495. 			public struct Sp : IEquatable<Sp>

    4496. 

  4496. 			{

    4497. 

  4497. 			    public Sp(int i, double d)

    4498. 

  4498. 			    {

    4499. 

  4499. 			        I = i;

    4500. 

  4500. 			        D = d;

    4501. 

  4501. 			    }

    4502. 

  4502. 			

    4503. 

  4503. 			    public int I;

    4504. 

  4504. 			    public double D;

    4505. 

  4505. 			

    4506. 

  4506. 			    public override bool Equals(object o)

    4507. 

  4507. 			    {

    4508. 

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

    4509. 

  4509. 			    }

    4510. 

  4510. 			    public bool Equals(Sp other)

    4511. 

  4511. 			    {

    4512. 

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

    4513. 

  4513. 			    }

    4514. 

  4514. 			    public override int GetHashCode()

    4515. 

  4515. 			    {

    4516. 

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

    4517. 

  4517. 			    }

    4518. 

  4518. 			}

    4519. 

  4519. 			

    4520. 

  4520. 			public struct Ss : IEquatable<Ss>

    4521. 

  4521. 			{

    4522. 

  4522. 			    public Ss(S s)

    4523. 

  4523. 			    {

    4524. 

  4524. 			        Val = s;

    4525. 

  4525. 			    }

    4526. 

  4526. 			

    4527. 

  4527. 			    public S Val;

    4528. 

  4528. 			

    4529. 

  4529. 			    public override bool Equals(object o)

    4530. 

  4530. 			    {

    4531. 

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

    4532. 

  4532. 			    }

    4533. 

  4533. 			    public bool Equals(Ss other)

    4534. 

  4534. 			    {

    4535. 

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

    4536. 

  4536. 			    }

    4537. 

  4537. 			    public override int GetHashCode()

    4538. 

  4538. 			    {

    4539. 

  4539. 			        return Val.GetHashCode();

    4540. 

  4540. 			    }

    4541. 

  4541. 			}

    4542. 

  4542. 			

    4543. 

  4543. 			public struct Sc : IEquatable<Sc>

    4544. 

  4544. 			{

    4545. 

  4545. 			    public Sc(string s)

    4546. 

  4546. 			    {

    4547. 

  4547. 			        S = s;

    4548. 

  4548. 			    }

    4549. 

  4549. 			

    4550. 

  4550. 			    public string S;

    4551. 

  4551. 			

    4552. 

  4552. 			    public override bool Equals(object o)

    4553. 

  4553. 			    {

    4554. 

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

    4555. 

  4555. 			    }

    4556. 

  4556. 			    public bool Equals(Sc other)

    4557. 

  4557. 			    {

    4558. 

  4558. 			        return other.S == S;

    4559. 

  4559. 			    }

    4560. 

  4560. 			    public override int GetHashCode()

    4561. 

  4561. 			    {

    4562. 

  4562. 			        return S.GetHashCode();

    4563. 

  4563. 			    }

    4564. 

  4564. 			}

    4565. 

  4565. 			

    4566. 

  4566. 			public struct Scs : IEquatable<Scs>

    4567. 

  4567. 			{

    4568. 

  4568. 			    public Scs(string s, S val)

    4569. 

  4569. 			    {

    4570. 

  4570. 			        S = s;

    4571. 

  4571. 			        Val = val;

    4572. 

  4572. 			    }

    4573. 

  4573. 			

    4574. 

  4574. 			    public string S;

    4575. 

  4575. 			    public S Val;

    4576. 

  4576. 			

    4577. 

  4577. 			    public override bool Equals(object o)

    4578. 

  4578. 			    {

    4579. 

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

    4580. 

  4580. 			    }

    4581. 

  4581. 			    public bool Equals(Scs other)

    4582. 

  4582. 			    {

    4583. 

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

    4584. 

  4584. 			    }

    4585. 

  4585. 			    public override int GetHashCode()

    4586. 

  4586. 			    {

    4587. 

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

    4588. 

  4588. 			    }

    4589. 

  4589. 			}

    4590. 

  4590. 			

    4591. 

  4591. 		

    4592. 

  4592. 	}

    4593. 

  4593. 				

    4594. 

  4594. 				//-------- Scenario 3146

    4595. 

  4595. 				namespace Scenario3146{

    4596. 

  4596. 					

    4597. 

  4597. 					public class Test

    4598. 

  4598. 					{

    4599. 

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

    4600. 

  4600. 				    public static Expression El_ArrayIndex__() {

    4601. 

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

    4602. 

  4602. 				           throw new Exception();

    4603. 

  4603. 				       } else { 

    4604. 

  4604. 				           return Expression.Constant(0);

    4605. 

  4605. 				       }

    4606. 

  4606. 				    }

    4607. 

  4607. 					public     static int Main()

    4608. 

  4608. 					    {

    4609. 

  4609. 					        Ext.StartCapture();

    4610. 

  4610. 					        bool success = false;

    4611. 

  4611. 					        try

    4612. 

  4612. 					        {

    4613. 

  4613. 					            success = check_El_ArrayIndex();

    4614. 

  4614. 					        }

    4615. 

  4615. 					        finally

    4616. 

  4616. 					        {

    4617. 

  4617. 					            Ext.StopCapture();

    4618. 

  4618. 					        }

    4619. 

  4619. 					        return success ? 0 : 1;

    4620. 

  4620. 					    }

    4621. 

  4621. 					

    4622. 

  4622. 					    static bool check_El_ArrayIndex()

    4623. 

  4623. 					    {

    4624. 

  4624. 					        return checkEx_El_ArrayIndex(null, -1) &

    4625. 

  4625. 					            checkEx_El_ArrayIndex(null, 0) &

    4626. 

  4626. 					            checkEx_El_ArrayIndex(null, 1) &

    4627. 

  4627. 					

    4628. 

  4628. 					            check_El_ArrayIndex(genArrEl_ArrayIndex(0)) &

    4629. 

  4629. 					            check_El_ArrayIndex(genArrEl_ArrayIndex(1)) &

    4630. 

  4630. 					            check_El_ArrayIndex(genArrEl_ArrayIndex(5));

    4631. 

  4631. 					    }

    4632. 

  4632. 					

    4633. 

  4633. 					    static El[] genArrEl_ArrayIndex(int size)

    4634. 

  4634. 					    {

    4635. 

  4635. 					        El[] vals = new El[] { (El)0, El.A, El.B, (El)long.MaxValue, (El)long.MinValue };

    4636. 

  4636. 					        El[] result = new El[size];

    4637. 

  4637. 					        for (int i = 0; i < size; i++)

    4638. 

  4638. 					        {

    4639. 

  4639. 					            result[i] = vals[i % vals.Length];

    4640. 

  4640. 					        }

    4641. 

  4641. 					        return result;

    4642. 

  4642. 					    }

    4643. 

  4643. 					

    4644. 

  4644. 					    static bool check_El_ArrayIndex(El[] val)

    4645. 

  4645. 					    {

    4646. 

  4646. 					        bool success = checkEx_El_ArrayIndex(val, -1);

    4647. 

  4647. 					        for (int i = 0; i < val.Length; i++)

    4648. 

  4648. 					        {

    4649. 

  4649. 					            success &= check_El_ArrayIndex(val, 0);

    4650. 

  4650. 					        }

    4651. 

  4651. 					        success &= checkEx_El_ArrayIndex(val, val.Length);

    4652. 

  4652. 					        return success;

    4653. 

  4653. 					    }

    4654. 

  4654. 					

    4655. 

  4655. 					    static bool checkEx_El_ArrayIndex(El[] val, int index)

    4656. 

  4656. 					    {

    4657. 

  4657. 					        try

    4658. 

  4658. 					        {

    4659. 

  4659. 					            check_El_ArrayIndex(val, index);

    4660. 

  4660. 					            Console.WriteLine("El_ArrayIndex[" + index + "] failed");

    4661. 

  4661. 					            return false;

    4662. 

  4662. 					        }

    4663. 

  4663. 					        catch

    4664. 

  4664. 					        {

    4665. 

  4665. 					            return true;

    4666. 

  4666. 					        }

    4667. 

  4667. 					    }

    4668. 

  4668. 					

    4669. 

  4669. 					    static bool check_El_ArrayIndex(El[] val, int index)

    4670. 

  4670. 					    {

    4671. 

  4671. 					        Expression<Func<El>> e =

    4672. 

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

    4673. 

  4673. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(El[])),

    4674. 

  4674. 					                    Expression.Constant(index, typeof(int))),

    4675. 

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

    4676. 

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

    4677. 

  4677. 					        return object.Equals(f(), val[index]);

    4678. 

  4678. 					    }

    4679. 

  4679. 					}

    4680. 

  4680. 				

    4681. 

  4681. 				

    4682. 

  4682. 				public  static class Ext {

    4683. 

  4683. 				    public static void StartCapture() {

    4684. 

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

    4685. 

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

    4686. 

  4686. 				    }

    4687. 

  4687. 				

    4688. 

  4688. 				    public static void StopCapture() {

    4689. 

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

    4690. 

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

    4691. 

  4691. 				    }

    4692. 

  4692. 				

    4693. 

  4693. 				    public static bool IsIntegralOrEnum(Type type) {

    4694. 

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

    4695. 

  4695. 				            case TypeCode.Byte:

    4696. 

  4696. 				            case TypeCode.SByte:

    4697. 

  4697. 				            case TypeCode.Int16:

    4698. 

  4698. 				            case TypeCode.Int32:

    4699. 

  4699. 				            case TypeCode.Int64:

    4700. 

  4700. 				            case TypeCode.UInt16:

    4701. 

  4701. 				            case TypeCode.UInt32:

    4702. 

  4702. 				            case TypeCode.UInt64:

    4703. 

  4703. 				                return true;

    4704. 

  4704. 				            default:

    4705. 

  4705. 				                return false;

    4706. 

  4706. 				        }

    4707. 

  4707. 				    }

    4708. 

  4708. 				

    4709. 

  4709. 				    public static bool IsFloating(Type type) {

    4710. 

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

    4711. 

  4711. 				            case TypeCode.Single:

    4712. 

  4712. 				            case TypeCode.Double:

    4713. 

  4713. 				                return true;

    4714. 

  4714. 				            default:

    4715. 

  4715. 				                return false;

    4716. 

  4716. 				        }

    4717. 

  4717. 				    }

    4718. 

  4718. 				

    4719. 

  4719. 				    public static Type GetNonNullableType(Type type) {

    4720. 

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

    4721. 

  4721. 				                type.GetGenericArguments()[0] :

    4722. 

  4722. 				                type;

    4723. 

  4723. 				    }

    4724. 

  4724. 				}

    4725. 

  4725. 				

    4726. 

  4726. 			

    4727. 

  4727. 			

    4728. 

  4728. 			

    4729. 

  4729. 			public interface I

    4730. 

  4730. 			{

    4731. 

  4731. 			    void M();

    4732. 

  4732. 			}

    4733. 

  4733. 			

    4734. 

  4734. 			public  class C : IEquatable<C>, I

    4735. 

  4735. 			{

    4736. 

  4736. 			    void I.M()

    4737. 

  4737. 			    {

    4738. 

  4738. 			    }

    4739. 

  4739. 			

    4740. 

  4740. 			    public override bool Equals(object o)

    4741. 

  4741. 			    {

    4742. 

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

    4743. 

  4743. 			    }

    4744. 

  4744. 			

    4745. 

  4745. 			    public bool Equals(C c)

    4746. 

  4746. 			    {

    4747. 

  4747. 			        return c != null;

    4748. 

  4748. 			    }

    4749. 

  4749. 			

    4750. 

  4750. 			    public override int GetHashCode()

    4751. 

  4751. 			    {

    4752. 

  4752. 			        return 0;

    4753. 

  4753. 			    }

    4754. 

  4754. 			}

    4755. 

  4755. 			

    4756. 

  4756. 			public  class D : C, IEquatable<D>

    4757. 

  4757. 			{

    4758. 

  4758. 			    public int Val;

    4759. 

  4759. 			    public D()

    4760. 

  4760. 			    {

    4761. 

  4761. 			    }

    4762. 

  4762. 			    public D(int val)

    4763. 

  4763. 			    {

    4764. 

  4764. 			        Val = val;

    4765. 

  4765. 			    }

    4766. 

  4766. 			

    4767. 

  4767. 			    public override bool Equals(object o)

    4768. 

  4768. 			    {

    4769. 

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

    4770. 

  4770. 			    }

    4771. 

  4771. 			

    4772. 

  4772. 			    public bool Equals(D d)

    4773. 

  4773. 			    {

    4774. 

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

    4775. 

  4775. 			    }

    4776. 

  4776. 			

    4777. 

  4777. 			    public override int GetHashCode()

    4778. 

  4778. 			    {

    4779. 

  4779. 			        return Val;

    4780. 

  4780. 			    }

    4781. 

  4781. 			}

    4782. 

  4782. 			

    4783. 

  4783. 			public enum E

    4784. 

  4784. 			{

    4785. 

  4785. 			    A = 1, B = 2

    4786. 

  4786. 			}

    4787. 

  4787. 			

    4788. 

  4788. 			public enum El : long

    4789. 

  4789. 			{

    4790. 

  4790. 			    A, B, C

    4791. 

  4791. 			}

    4792. 

  4792. 			

    4793. 

  4793. 			public struct S : IEquatable<S>

    4794. 

  4794. 			{

    4795. 

  4795. 			    public override bool Equals(object o)

    4796. 

  4796. 			    {

    4797. 

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

    4798. 

  4798. 			    }

    4799. 

  4799. 			    public bool Equals(S other)

    4800. 

  4800. 			    {

    4801. 

  4801. 			        return true;

    4802. 

  4802. 			    }

    4803. 

  4803. 			    public override int GetHashCode()

    4804. 

  4804. 			    {

    4805. 

  4805. 			        return 0;

    4806. 

  4806. 			    }

    4807. 

  4807. 			}

    4808. 

  4808. 			

    4809. 

  4809. 			public struct Sp : IEquatable<Sp>

    4810. 

  4810. 			{

    4811. 

  4811. 			    public Sp(int i, double d)

    4812. 

  4812. 			    {

    4813. 

  4813. 			        I = i;

    4814. 

  4814. 			        D = d;

    4815. 

  4815. 			    }

    4816. 

  4816. 			

    4817. 

  4817. 			    public int I;

    4818. 

  4818. 			    public double D;

    4819. 

  4819. 			

    4820. 

  4820. 			    public override bool Equals(object o)

    4821. 

  4821. 			    {

    4822. 

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

    4823. 

  4823. 			    }

    4824. 

  4824. 			    public bool Equals(Sp other)

    4825. 

  4825. 			    {

    4826. 

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

    4827. 

  4827. 			    }

    4828. 

  4828. 			    public override int GetHashCode()

    4829. 

  4829. 			    {

    4830. 

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

    4831. 

  4831. 			    }

    4832. 

  4832. 			}

    4833. 

  4833. 			

    4834. 

  4834. 			public struct Ss : IEquatable<Ss>

    4835. 

  4835. 			{

    4836. 

  4836. 			    public Ss(S s)

    4837. 

  4837. 			    {

    4838. 

  4838. 			        Val = s;

    4839. 

  4839. 			    }

    4840. 

  4840. 			

    4841. 

  4841. 			    public S Val;

    4842. 

  4842. 			

    4843. 

  4843. 			    public override bool Equals(object o)

    4844. 

  4844. 			    {

    4845. 

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

    4846. 

  4846. 			    }

    4847. 

  4847. 			    public bool Equals(Ss other)

    4848. 

  4848. 			    {

    4849. 

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

    4850. 

  4850. 			    }

    4851. 

  4851. 			    public override int GetHashCode()

    4852. 

  4852. 			    {

    4853. 

  4853. 			        return Val.GetHashCode();

    4854. 

  4854. 			    }

    4855. 

  4855. 			}

    4856. 

  4856. 			

    4857. 

  4857. 			public struct Sc : IEquatable<Sc>

    4858. 

  4858. 			{

    4859. 

  4859. 			    public Sc(string s)

    4860. 

  4860. 			    {

    4861. 

  4861. 			        S = s;

    4862. 

  4862. 			    }

    4863. 

  4863. 			

    4864. 

  4864. 			    public string S;

    4865. 

  4865. 			

    4866. 

  4866. 			    public override bool Equals(object o)

    4867. 

  4867. 			    {

    4868. 

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

    4869. 

  4869. 			    }

    4870. 

  4870. 			    public bool Equals(Sc other)

    4871. 

  4871. 			    {

    4872. 

  4872. 			        return other.S == S;

    4873. 

  4873. 			    }

    4874. 

  4874. 			    public override int GetHashCode()

    4875. 

  4875. 			    {

    4876. 

  4876. 			        return S.GetHashCode();

    4877. 

  4877. 			    }

    4878. 

  4878. 			}

    4879. 

  4879. 			

    4880. 

  4880. 			public struct Scs : IEquatable<Scs>

    4881. 

  4881. 			{

    4882. 

  4882. 			    public Scs(string s, S val)

    4883. 

  4883. 			    {

    4884. 

  4884. 			        S = s;

    4885. 

  4885. 			        Val = val;

    4886. 

  4886. 			    }

    4887. 

  4887. 			

    4888. 

  4888. 			    public string S;

    4889. 

  4889. 			    public S Val;

    4890. 

  4890. 			

    4891. 

  4891. 			    public override bool Equals(object o)

    4892. 

  4892. 			    {

    4893. 

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

    4894. 

  4894. 			    }

    4895. 

  4895. 			    public bool Equals(Scs other)

    4896. 

  4896. 			    {

    4897. 

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

    4898. 

  4898. 			    }

    4899. 

  4899. 			    public override int GetHashCode()

    4900. 

  4900. 			    {

    4901. 

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

    4902. 

  4902. 			    }

    4903. 

  4903. 			}

    4904. 

  4904. 			

    4905. 

  4905. 		

    4906. 

  4906. 	}

    4907. 

  4907. 			

    4908. 

  4908. 			//-------- Scenario 3147

    4909. 

  4909. 			namespace Scenario3147{

    4910. 

  4910. 				

    4911. 

  4911. 				public class Test

    4912. 

  4912. 				{

    4913. 

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

    4914. 

  4914. 			    public static Expression string_ArrayIndex__() {

    4915. 

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

    4916. 

  4916. 			           throw new Exception();

    4917. 

  4917. 			       } else { 

    4918. 

  4918. 			           return Expression.Constant(0);

    4919. 

  4919. 			       }

    4920. 

  4920. 			    }

    4921. 

  4921. 				public     static int Main()

    4922. 

  4922. 				    {

    4923. 

  4923. 				        Ext.StartCapture();

    4924. 

  4924. 				        bool success = false;

    4925. 

  4925. 				        try

    4926. 

  4926. 				        {

    4927. 

  4927. 				            success = check_string_ArrayIndex();

    4928. 

  4928. 				        }

    4929. 

  4929. 				        finally

    4930. 

  4930. 				        {

    4931. 

  4931. 				            Ext.StopCapture();

    4932. 

  4932. 				        }

    4933. 

  4933. 				        return success ? 0 : 1;

    4934. 

  4934. 				    }

    4935. 

  4935. 				

    4936. 

  4936. 				    static bool check_string_ArrayIndex()

    4937. 

  4937. 				    {

    4938. 

  4938. 				        return checkEx_string_ArrayIndex(null, -1) &

    4939. 

  4939. 				            checkEx_string_ArrayIndex(null, 0) &

    4940. 

  4940. 				            checkEx_string_ArrayIndex(null, 1) &

    4941. 

  4941. 				

    4942. 

  4942. 				            check_string_ArrayIndex(genArrstring_ArrayIndex(0)) &

    4943. 

  4943. 				            check_string_ArrayIndex(genArrstring_ArrayIndex(1)) &

    4944. 

  4944. 				            check_string_ArrayIndex(genArrstring_ArrayIndex(5));

    4945. 

  4945. 				    }

    4946. 

  4946. 				

    4947. 

  4947. 				    static string[] genArrstring_ArrayIndex(int size)

    4948. 

  4948. 				    {

    4949. 

  4949. 				        string[] vals = new string[] { null, "", "a", "foo" };

    4950. 

  4950. 				        string[] result = new string[size];

    4951. 

  4951. 				        for (int i = 0; i < size; i++)

    4952. 

  4952. 				        {

    4953. 

  4953. 				            result[i] = vals[i % vals.Length];

    4954. 

  4954. 				        }

    4955. 

  4955. 				        return result;

    4956. 

  4956. 				    }

    4957. 

  4957. 				

    4958. 

  4958. 				    static bool check_string_ArrayIndex(string[] val)

    4959. 

  4959. 				    {

    4960. 

  4960. 				        bool success = checkEx_string_ArrayIndex(val, -1);

    4961. 

  4961. 				        for (int i = 0; i < val.Length; i++)

    4962. 

  4962. 				        {

    4963. 

  4963. 				            success &= check_string_ArrayIndex(val, 0);

    4964. 

  4964. 				        }

    4965. 

  4965. 				        success &= checkEx_string_ArrayIndex(val, val.Length);

    4966. 

  4966. 				        return success;

    4967. 

  4967. 				    }

    4968. 

  4968. 				

    4969. 

  4969. 				    static bool checkEx_string_ArrayIndex(string[] val, int index)

    4970. 

  4970. 				    {

    4971. 

  4971. 				        try

    4972. 

  4972. 				        {

    4973. 

  4973. 				            check_string_ArrayIndex(val, index);

    4974. 

  4974. 				            Console.WriteLine("string_ArrayIndex[" + index + "] failed");

    4975. 

  4975. 				            return false;

    4976. 

  4976. 				        }

    4977. 

  4977. 				        catch

    4978. 

  4978. 				        {

    4979. 

  4979. 				            return true;

    4980. 

  4980. 				        }

    4981. 

  4981. 				    }

    4982. 

  4982. 				

    4983. 

  4983. 				    static bool check_string_ArrayIndex(string[] val, int index)

    4984. 

  4984. 				    {

    4985. 

  4985. 				        Expression<Func<string>> e =

    4986. 

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

    4987. 

  4987. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(string[])),

    4988. 

  4988. 				                    Expression.Constant(index, typeof(int))),

    4989. 

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

    4990. 

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

    4991. 

  4991. 				        return object.Equals(f(), val[index]);

    4992. 

  4992. 				    }

    4993. 

  4993. 				}

    4994. 

  4994. 			

    4995. 

  4995. 			

    4996. 

  4996. 			public  static class Ext {

    4997. 

  4997. 			    public static void StartCapture() {

    4998. 

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

    4999. 

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

    5000. 

  5000. 			    }

    5001. 

  5001. 			

    5002. 

  5002. 			    public static void StopCapture() {

    5003. 

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

    5004. 

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

    5005. 

  5005. 			    }

    5006. 

  5006. 			

    5007. 

  5007. 			    public static bool IsIntegralOrEnum(Type type) {

    5008. 

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

    5009. 

  5009. 			            case TypeCode.Byte:

    5010. 

  5010. 			            case TypeCode.SByte:

    5011. 

  5011. 			            case TypeCode.Int16:

    5012. 

  5012. 			            case TypeCode.Int32:

    5013. 

  5013. 			            case TypeCode.Int64:

    5014. 

  5014. 			            case TypeCode.UInt16:

    5015. 

  5015. 			            case TypeCode.UInt32:

    5016. 

  5016. 			            case TypeCode.UInt64:

    5017. 

  5017. 			                return true;

    5018. 

  5018. 			            default:

    5019. 

  5019. 			                return false;

    5020. 

  5020. 			        }

    5021. 

  5021. 			    }

    5022. 

  5022. 			

    5023. 

  5023. 			    public static bool IsFloating(Type type) {

    5024. 

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

    5025. 

  5025. 			            case TypeCode.Single:

    5026. 

  5026. 			            case TypeCode.Double:

    5027. 

  5027. 			                return true;

    5028. 

  5028. 			            default:

    5029. 

  5029. 			                return false;

    5030. 

  5030. 			        }

    5031. 

  5031. 			    }

    5032. 

  5032. 			

    5033. 

  5033. 			    public static Type GetNonNullableType(Type type) {

    5034. 

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

    5035. 

  5035. 			                type.GetGenericArguments()[0] :

    5036. 

  5036. 			                type;

    5037. 

  5037. 			    }

    5038. 

  5038. 			}

    5039. 

  5039. 			

    5040. 

  5040. 		

    5041. 

  5041. 	}

    5042. 

  5042. 				

    5043. 

  5043. 				//-------- Scenario 3148

    5044. 

  5044. 				namespace Scenario3148{

    5045. 

  5045. 					

    5046. 

  5046. 					public class Test

    5047. 

  5047. 					{

    5048. 

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

    5049. 

  5049. 				    public static Expression object_ArrayIndex__() {

    5050. 

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

    5051. 

  5051. 				           throw new Exception();

    5052. 

  5052. 				       } else { 

    5053. 

  5053. 				           return Expression.Constant(0);

    5054. 

  5054. 				       }

    5055. 

  5055. 				    }

    5056. 

  5056. 					public     static int Main()

    5057. 

  5057. 					    {

    5058. 

  5058. 					        Ext.StartCapture();

    5059. 

  5059. 					        bool success = false;

    5060. 

  5060. 					        try

    5061. 

  5061. 					        {

    5062. 

  5062. 					            success = check_object_ArrayIndex();

    5063. 

  5063. 					        }

    5064. 

  5064. 					        finally

    5065. 

  5065. 					        {

    5066. 

  5066. 					            Ext.StopCapture();

    5067. 

  5067. 					        }

    5068. 

  5068. 					        return success ? 0 : 1;

    5069. 

  5069. 					    }

    5070. 

  5070. 					

    5071. 

  5071. 					    static bool check_object_ArrayIndex()

    5072. 

  5072. 					    {

    5073. 

  5073. 					        return checkEx_object_ArrayIndex(null, -1) &

    5074. 

  5074. 					            checkEx_object_ArrayIndex(null, 0) &

    5075. 

  5075. 					            checkEx_object_ArrayIndex(null, 1) &

    5076. 

  5076. 					

    5077. 

  5077. 					            check_object_ArrayIndex(genArrobject_ArrayIndex(0)) &

    5078. 

  5078. 					            check_object_ArrayIndex(genArrobject_ArrayIndex(1)) &

    5079. 

  5079. 					            check_object_ArrayIndex(genArrobject_ArrayIndex(5));

    5080. 

  5080. 					    }

    5081. 

  5081. 					

    5082. 

  5082. 					    static object[] genArrobject_ArrayIndex(int size)

    5083. 

  5083. 					    {

    5084. 

  5084. 					        object[] vals = new object[] { null, new object(), new C(), new D(3) };

    5085. 

  5085. 					        object[] result = new object[size];

    5086. 

  5086. 					        for (int i = 0; i < size; i++)

    5087. 

  5087. 					        {

    5088. 

  5088. 					            result[i] = vals[i % vals.Length];

    5089. 

  5089. 					        }

    5090. 

  5090. 					        return result;

    5091. 

  5091. 					    }

    5092. 

  5092. 					

    5093. 

  5093. 					    static bool check_object_ArrayIndex(object[] val)

    5094. 

  5094. 					    {

    5095. 

  5095. 					        bool success = checkEx_object_ArrayIndex(val, -1);

    5096. 

  5096. 					        for (int i = 0; i < val.Length; i++)

    5097. 

  5097. 					        {

    5098. 

  5098. 					            success &= check_object_ArrayIndex(val, 0);

    5099. 

  5099. 					        }

    5100. 

  5100. 					        success &= checkEx_object_ArrayIndex(val, val.Length);

    5101. 

  5101. 					        return success;

    5102. 

  5102. 					    }

    5103. 

  5103. 					

    5104. 

  5104. 					    static bool checkEx_object_ArrayIndex(object[] val, int index)

    5105. 

  5105. 					    {

    5106. 

  5106. 					        try

    5107. 

  5107. 					        {

    5108. 

  5108. 					            check_object_ArrayIndex(val, index);

    5109. 

  5109. 					            Console.WriteLine("object_ArrayIndex[" + index + "] failed");

    5110. 

  5110. 					            return false;

    5111. 

  5111. 					        }

    5112. 

  5112. 					        catch

    5113. 

  5113. 					        {

    5114. 

  5114. 					            return true;

    5115. 

  5115. 					        }

    5116. 

  5116. 					    }

    5117. 

  5117. 					

    5118. 

  5118. 					    static bool check_object_ArrayIndex(object[] val, int index)

    5119. 

  5119. 					    {

    5120. 

  5120. 					        Expression<Func<object>> e =

    5121. 

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

    5122. 

  5122. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(object[])),

    5123. 

  5123. 					                    Expression.Constant(index, typeof(int))),

    5124. 

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

    5125. 

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

    5126. 

  5126. 					        return object.Equals(f(), val[index]);

    5127. 

  5127. 					    }

    5128. 

  5128. 					}

    5129. 

  5129. 				

    5130. 

  5130. 				

    5131. 

  5131. 				public  static class Ext {

    5132. 

  5132. 				    public static void StartCapture() {

    5133. 

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

    5134. 

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

    5135. 

  5135. 				    }

    5136. 

  5136. 				

    5137. 

  5137. 				    public static void StopCapture() {

    5138. 

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

    5139. 

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

    5140. 

  5140. 				    }

    5141. 

  5141. 				

    5142. 

  5142. 				    public static bool IsIntegralOrEnum(Type type) {

    5143. 

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

    5144. 

  5144. 				            case TypeCode.Byte:

    5145. 

  5145. 				            case TypeCode.SByte:

    5146. 

  5146. 				            case TypeCode.Int16:

    5147. 

  5147. 				            case TypeCode.Int32:

    5148. 

  5148. 				            case TypeCode.Int64:

    5149. 

  5149. 				            case TypeCode.UInt16:

    5150. 

  5150. 				            case TypeCode.UInt32:

    5151. 

  5151. 				            case TypeCode.UInt64:

    5152. 

  5152. 				                return true;

    5153. 

  5153. 				            default:

    5154. 

  5154. 				                return false;

    5155. 

  5155. 				        }

    5156. 

  5156. 				    }

    5157. 

  5157. 				

    5158. 

  5158. 				    public static bool IsFloating(Type type) {

    5159. 

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

    5160. 

  5160. 				            case TypeCode.Single:

    5161. 

  5161. 				            case TypeCode.Double:

    5162. 

  5162. 				                return true;

    5163. 

  5163. 				            default:

    5164. 

  5164. 				                return false;

    5165. 

  5165. 				        }

    5166. 

  5166. 				    }

    5167. 

  5167. 				

    5168. 

  5168. 				    public static Type GetNonNullableType(Type type) {

    5169. 

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

    5170. 

  5170. 				                type.GetGenericArguments()[0] :

    5171. 

  5171. 				                type;

    5172. 

  5172. 				    }

    5173. 

  5173. 				}

    5174. 

  5174. 				

    5175. 

  5175. 			

    5176. 

  5176. 			

    5177. 

  5177. 			

    5178. 

  5178. 			public interface I

    5179. 

  5179. 			{

    5180. 

  5180. 			    void M();

    5181. 

  5181. 			}

    5182. 

  5182. 			

    5183. 

  5183. 			public  class C : IEquatable<C>, I

    5184. 

  5184. 			{

    5185. 

  5185. 			    void I.M()

    5186. 

  5186. 			    {

    5187. 

  5187. 			    }

    5188. 

  5188. 			

    5189. 

  5189. 			    public override bool Equals(object o)

    5190. 

  5190. 			    {

    5191. 

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

    5192. 

  5192. 			    }

    5193. 

  5193. 			

    5194. 

  5194. 			    public bool Equals(C c)

    5195. 

  5195. 			    {

    5196. 

  5196. 			        return c != null;

    5197. 

  5197. 			    }

    5198. 

  5198. 			

    5199. 

  5199. 			    public override int GetHashCode()

    5200. 

  5200. 			    {

    5201. 

  5201. 			        return 0;

    5202. 

  5202. 			    }

    5203. 

  5203. 			}

    5204. 

  5204. 			

    5205. 

  5205. 			public  class D : C, IEquatable<D>

    5206. 

  5206. 			{

    5207. 

  5207. 			    public int Val;

    5208. 

  5208. 			    public D()

    5209. 

  5209. 			    {

    5210. 

  5210. 			    }

    5211. 

  5211. 			    public D(int val)

    5212. 

  5212. 			    {

    5213. 

  5213. 			        Val = val;

    5214. 

  5214. 			    }

    5215. 

  5215. 			

    5216. 

  5216. 			    public override bool Equals(object o)

    5217. 

  5217. 			    {

    5218. 

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

    5219. 

  5219. 			    }

    5220. 

  5220. 			

    5221. 

  5221. 			    public bool Equals(D d)

    5222. 

  5222. 			    {

    5223. 

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

    5224. 

  5224. 			    }

    5225. 

  5225. 			

    5226. 

  5226. 			    public override int GetHashCode()

    5227. 

  5227. 			    {

    5228. 

  5228. 			        return Val;

    5229. 

  5229. 			    }

    5230. 

  5230. 			}

    5231. 

  5231. 			

    5232. 

  5232. 			public enum E

    5233. 

  5233. 			{

    5234. 

  5234. 			    A = 1, B = 2

    5235. 

  5235. 			}

    5236. 

  5236. 			

    5237. 

  5237. 			public enum El : long

    5238. 

  5238. 			{

    5239. 

  5239. 			    A, B, C

    5240. 

  5240. 			}

    5241. 

  5241. 			

    5242. 

  5242. 			public struct S : IEquatable<S>

    5243. 

  5243. 			{

    5244. 

  5244. 			    public override bool Equals(object o)

    5245. 

  5245. 			    {

    5246. 

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

    5247. 

  5247. 			    }

    5248. 

  5248. 			    public bool Equals(S other)

    5249. 

  5249. 			    {

    5250. 

  5250. 			        return true;

    5251. 

  5251. 			    }

    5252. 

  5252. 			    public override int GetHashCode()

    5253. 

  5253. 			    {

    5254. 

  5254. 			        return 0;

    5255. 

  5255. 			    }

    5256. 

  5256. 			}

    5257. 

  5257. 			

    5258. 

  5258. 			public struct Sp : IEquatable<Sp>

    5259. 

  5259. 			{

    5260. 

  5260. 			    public Sp(int i, double d)

    5261. 

  5261. 			    {

    5262. 

  5262. 			        I = i;

    5263. 

  5263. 			        D = d;

    5264. 

  5264. 			    }

    5265. 

  5265. 			

    5266. 

  5266. 			    public int I;

    5267. 

  5267. 			    public double D;

    5268. 

  5268. 			

    5269. 

  5269. 			    public override bool Equals(object o)

    5270. 

  5270. 			    {

    5271. 

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

    5272. 

  5272. 			    }

    5273. 

  5273. 			    public bool Equals(Sp other)

    5274. 

  5274. 			    {

    5275. 

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

    5276. 

  5276. 			    }

    5277. 

  5277. 			    public override int GetHashCode()

    5278. 

  5278. 			    {

    5279. 

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

    5280. 

  5280. 			    }

    5281. 

  5281. 			}

    5282. 

  5282. 			

    5283. 

  5283. 			public struct Ss : IEquatable<Ss>

    5284. 

  5284. 			{

    5285. 

  5285. 			    public Ss(S s)

    5286. 

  5286. 			    {

    5287. 

  5287. 			        Val = s;

    5288. 

  5288. 			    }

    5289. 

  5289. 			

    5290. 

  5290. 			    public S Val;

    5291. 

  5291. 			

    5292. 

  5292. 			    public override bool Equals(object o)

    5293. 

  5293. 			    {

    5294. 

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

    5295. 

  5295. 			    }

    5296. 

  5296. 			    public bool Equals(Ss other)

    5297. 

  5297. 			    {

    5298. 

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

    5299. 

  5299. 			    }

    5300. 

  5300. 			    public override int GetHashCode()

    5301. 

  5301. 			    {

    5302. 

  5302. 			        return Val.GetHashCode();

    5303. 

  5303. 			    }

    5304. 

  5304. 			}

    5305. 

  5305. 			

    5306. 

  5306. 			public struct Sc : IEquatable<Sc>

    5307. 

  5307. 			{

    5308. 

  5308. 			    public Sc(string s)

    5309. 

  5309. 			    {

    5310. 

  5310. 			        S = s;

    5311. 

  5311. 			    }

    5312. 

  5312. 			

    5313. 

  5313. 			    public string S;

    5314. 

  5314. 			

    5315. 

  5315. 			    public override bool Equals(object o)

    5316. 

  5316. 			    {

    5317. 

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

    5318. 

  5318. 			    }

    5319. 

  5319. 			    public bool Equals(Sc other)

    5320. 

  5320. 			    {

    5321. 

  5321. 			        return other.S == S;

    5322. 

  5322. 			    }

    5323. 

  5323. 			    public override int GetHashCode()

    5324. 

  5324. 			    {

    5325. 

  5325. 			        return S.GetHashCode();

    5326. 

  5326. 			    }

    5327. 

  5327. 			}

    5328. 

  5328. 			

    5329. 

  5329. 			public struct Scs : IEquatable<Scs>

    5330. 

  5330. 			{

    5331. 

  5331. 			    public Scs(string s, S val)

    5332. 

  5332. 			    {

    5333. 

  5333. 			        S = s;

    5334. 

  5334. 			        Val = val;

    5335. 

  5335. 			    }

    5336. 

  5336. 			

    5337. 

  5337. 			    public string S;

    5338. 

  5338. 			    public S Val;

    5339. 

  5339. 			

    5340. 

  5340. 			    public override bool Equals(object o)

    5341. 

  5341. 			    {

    5342. 

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

    5343. 

  5343. 			    }

    5344. 

  5344. 			    public bool Equals(Scs other)

    5345. 

  5345. 			    {

    5346. 

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

    5347. 

  5347. 			    }

    5348. 

  5348. 			    public override int GetHashCode()

    5349. 

  5349. 			    {

    5350. 

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

    5351. 

  5351. 			    }

    5352. 

  5352. 			}

    5353. 

  5353. 			

    5354. 

  5354. 		

    5355. 

  5355. 	}

    5356. 

  5356. 				

    5357. 

  5357. 				//-------- Scenario 3149

    5358. 

  5358. 				namespace Scenario3149{

    5359. 

  5359. 					

    5360. 

  5360. 					public class Test

    5361. 

  5361. 					{

    5362. 

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

    5363. 

  5363. 				    public static Expression C_ArrayIndex__() {

    5364. 

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

    5365. 

  5365. 				           throw new Exception();

    5366. 

  5366. 				       } else { 

    5367. 

  5367. 				           return Expression.Constant(0);

    5368. 

  5368. 				       }

    5369. 

  5369. 				    }

    5370. 

  5370. 					public     static int Main()

    5371. 

  5371. 					    {

    5372. 

  5372. 					        Ext.StartCapture();

    5373. 

  5373. 					        bool success = false;

    5374. 

  5374. 					        try

    5375. 

  5375. 					        {

    5376. 

  5376. 					            success = check_C_ArrayIndex();

    5377. 

  5377. 					        }

    5378. 

  5378. 					        finally

    5379. 

  5379. 					        {

    5380. 

  5380. 					            Ext.StopCapture();

    5381. 

  5381. 					        }

    5382. 

  5382. 					        return success ? 0 : 1;

    5383. 

  5383. 					    }

    5384. 

  5384. 					

    5385. 

  5385. 					    static bool check_C_ArrayIndex()

    5386. 

  5386. 					    {

    5387. 

  5387. 					        return checkEx_C_ArrayIndex(null, -1) &

    5388. 

  5388. 					            checkEx_C_ArrayIndex(null, 0) &

    5389. 

  5389. 					            checkEx_C_ArrayIndex(null, 1) &

    5390. 

  5390. 					

    5391. 

  5391. 					            check_C_ArrayIndex(genArrC_ArrayIndex(0)) &

    5392. 

  5392. 					            check_C_ArrayIndex(genArrC_ArrayIndex(1)) &

    5393. 

  5393. 					            check_C_ArrayIndex(genArrC_ArrayIndex(5));

    5394. 

  5394. 					    }

    5395. 

  5395. 					

    5396. 

  5396. 					    static C[] genArrC_ArrayIndex(int size)

    5397. 

  5397. 					    {

    5398. 

  5398. 					        C[] vals = new C[] { null, new C(), new D(), new D(0), new D(5) };

    5399. 

  5399. 					        C[] result = new C[size];

    5400. 

  5400. 					        for (int i = 0; i < size; i++)

    5401. 

  5401. 					        {

    5402. 

  5402. 					            result[i] = vals[i % vals.Length];

    5403. 

  5403. 					        }

    5404. 

  5404. 					        return result;

    5405. 

  5405. 					    }

    5406. 

  5406. 					

    5407. 

  5407. 					    static bool check_C_ArrayIndex(C[] val)

    5408. 

  5408. 					    {

    5409. 

  5409. 					        bool success = checkEx_C_ArrayIndex(val, -1);

    5410. 

  5410. 					        for (int i = 0; i < val.Length; i++)

    5411. 

  5411. 					        {

    5412. 

  5412. 					            success &= check_C_ArrayIndex(val, 0);

    5413. 

  5413. 					        }

    5414. 

  5414. 					        success &= checkEx_C_ArrayIndex(val, val.Length);

    5415. 

  5415. 					        return success;

    5416. 

  5416. 					    }

    5417. 

  5417. 					

    5418. 

  5418. 					    static bool checkEx_C_ArrayIndex(C[] val, int index)

    5419. 

  5419. 					    {

    5420. 

  5420. 					        try

    5421. 

  5421. 					        {

    5422. 

  5422. 					            check_C_ArrayIndex(val, index);

    5423. 

  5423. 					            Console.WriteLine("C_ArrayIndex[" + index + "] failed");

    5424. 

  5424. 					            return false;

    5425. 

  5425. 					        }

    5426. 

  5426. 					        catch

    5427. 

  5427. 					        {

    5428. 

  5428. 					            return true;

    5429. 

  5429. 					        }

    5430. 

  5430. 					    }

    5431. 

  5431. 					

    5432. 

  5432. 					    static bool check_C_ArrayIndex(C[] val, int index)

    5433. 

  5433. 					    {

    5434. 

  5434. 					        Expression<Func<C>> e =

    5435. 

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

    5436. 

  5436. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(C[])),

    5437. 

  5437. 					                    Expression.Constant(index, typeof(int))),

    5438. 

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

    5439. 

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

    5440. 

  5440. 					        return object.Equals(f(), val[index]);

    5441. 

  5441. 					    }

    5442. 

  5442. 					}

    5443. 

  5443. 				

    5444. 

  5444. 				

    5445. 

  5445. 				public  static class Ext {

    5446. 

  5446. 				    public static void StartCapture() {

    5447. 

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

    5448. 

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

    5449. 

  5449. 				    }

    5450. 

  5450. 				

    5451. 

  5451. 				    public static void StopCapture() {

    5452. 

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

    5453. 

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

    5454. 

  5454. 				    }

    5455. 

  5455. 				

    5456. 

  5456. 				    public static bool IsIntegralOrEnum(Type type) {

    5457. 

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

    5458. 

  5458. 				            case TypeCode.Byte:

    5459. 

  5459. 				            case TypeCode.SByte:

    5460. 

  5460. 				            case TypeCode.Int16:

    5461. 

  5461. 				            case TypeCode.Int32:

    5462. 

  5462. 				            case TypeCode.Int64:

    5463. 

  5463. 				            case TypeCode.UInt16:

    5464. 

  5464. 				            case TypeCode.UInt32:

    5465. 

  5465. 				            case TypeCode.UInt64:

    5466. 

  5466. 				                return true;

    5467. 

  5467. 				            default:

    5468. 

  5468. 				                return false;

    5469. 

  5469. 				        }

    5470. 

  5470. 				    }

    5471. 

  5471. 				

    5472. 

  5472. 				    public static bool IsFloating(Type type) {

    5473. 

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

    5474. 

  5474. 				            case TypeCode.Single:

    5475. 

  5475. 				            case TypeCode.Double:

    5476. 

  5476. 				                return true;

    5477. 

  5477. 				            default:

    5478. 

  5478. 				                return false;

    5479. 

  5479. 				        }

    5480. 

  5480. 				    }

    5481. 

  5481. 				

    5482. 

  5482. 				    public static Type GetNonNullableType(Type type) {

    5483. 

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

    5484. 

  5484. 				                type.GetGenericArguments()[0] :

    5485. 

  5485. 				                type;

    5486. 

  5486. 				    }

    5487. 

  5487. 				}

    5488. 

  5488. 				

    5489. 

  5489. 			

    5490. 

  5490. 			

    5491. 

  5491. 			

    5492. 

  5492. 			public interface I

    5493. 

  5493. 			{

    5494. 

  5494. 			    void M();

    5495. 

  5495. 			}

    5496. 

  5496. 			

    5497. 

  5497. 			public  class C : IEquatable<C>, I

    5498. 

  5498. 			{

    5499. 

  5499. 			    void I.M()

    5500. 

  5500. 			    {

    5501. 

  5501. 			    }

    5502. 

  5502. 			

    5503. 

  5503. 			    public override bool Equals(object o)

    5504. 

  5504. 			    {

    5505. 

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

    5506. 

  5506. 			    }

    5507. 

  5507. 			

    5508. 

  5508. 			    public bool Equals(C c)

    5509. 

  5509. 			    {

    5510. 

  5510. 			        return c != null;

    5511. 

  5511. 			    }

    5512. 

  5512. 			

    5513. 

  5513. 			    public override int GetHashCode()

    5514. 

  5514. 			    {

    5515. 

  5515. 			        return 0;

    5516. 

  5516. 			    }

    5517. 

  5517. 			}

    5518. 

  5518. 			

    5519. 

  5519. 			public  class D : C, IEquatable<D>

    5520. 

  5520. 			{

    5521. 

  5521. 			    public int Val;

    5522. 

  5522. 			    public D()

    5523. 

  5523. 			    {

    5524. 

  5524. 			    }

    5525. 

  5525. 			    public D(int val)

    5526. 

  5526. 			    {

    5527. 

  5527. 			        Val = val;

    5528. 

  5528. 			    }

    5529. 

  5529. 			

    5530. 

  5530. 			    public override bool Equals(object o)

    5531. 

  5531. 			    {

    5532. 

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

    5533. 

  5533. 			    }

    5534. 

  5534. 			

    5535. 

  5535. 			    public bool Equals(D d)

    5536. 

  5536. 			    {

    5537. 

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

    5538. 

  5538. 			    }

    5539. 

  5539. 			

    5540. 

  5540. 			    public override int GetHashCode()

    5541. 

  5541. 			    {

    5542. 

  5542. 			        return Val;

    5543. 

  5543. 			    }

    5544. 

  5544. 			}

    5545. 

  5545. 			

    5546. 

  5546. 			public enum E

    5547. 

  5547. 			{

    5548. 

  5548. 			    A = 1, B = 2

    5549. 

  5549. 			}

    5550. 

  5550. 			

    5551. 

  5551. 			public enum El : long

    5552. 

  5552. 			{

    5553. 

  5553. 			    A, B, C

    5554. 

  5554. 			}

    5555. 

  5555. 			

    5556. 

  5556. 			public struct S : IEquatable<S>

    5557. 

  5557. 			{

    5558. 

  5558. 			    public override bool Equals(object o)

    5559. 

  5559. 			    {

    5560. 

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

    5561. 

  5561. 			    }

    5562. 

  5562. 			    public bool Equals(S other)

    5563. 

  5563. 			    {

    5564. 

  5564. 			        return true;

    5565. 

  5565. 			    }

    5566. 

  5566. 			    public override int GetHashCode()

    5567. 

  5567. 			    {

    5568. 

  5568. 			        return 0;

    5569. 

  5569. 			    }

    5570. 

  5570. 			}

    5571. 

  5571. 			

    5572. 

  5572. 			public struct Sp : IEquatable<Sp>

    5573. 

  5573. 			{

    5574. 

  5574. 			    public Sp(int i, double d)

    5575. 

  5575. 			    {

    5576. 

  5576. 			        I = i;

    5577. 

  5577. 			        D = d;

    5578. 

  5578. 			    }

    5579. 

  5579. 			

    5580. 

  5580. 			    public int I;

    5581. 

  5581. 			    public double D;

    5582. 

  5582. 			

    5583. 

  5583. 			    public override bool Equals(object o)

    5584. 

  5584. 			    {

    5585. 

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

    5586. 

  5586. 			    }

    5587. 

  5587. 			    public bool Equals(Sp other)

    5588. 

  5588. 			    {

    5589. 

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

    5590. 

  5590. 			    }

    5591. 

  5591. 			    public override int GetHashCode()

    5592. 

  5592. 			    {

    5593. 

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

    5594. 

  5594. 			    }

    5595. 

  5595. 			}

    5596. 

  5596. 			

    5597. 

  5597. 			public struct Ss : IEquatable<Ss>

    5598. 

  5598. 			{

    5599. 

  5599. 			    public Ss(S s)

    5600. 

  5600. 			    {

    5601. 

  5601. 			        Val = s;

    5602. 

  5602. 			    }

    5603. 

  5603. 			

    5604. 

  5604. 			    public S Val;

    5605. 

  5605. 			

    5606. 

  5606. 			    public override bool Equals(object o)

    5607. 

  5607. 			    {

    5608. 

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

    5609. 

  5609. 			    }

    5610. 

  5610. 			    public bool Equals(Ss other)

    5611. 

  5611. 			    {

    5612. 

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

    5613. 

  5613. 			    }

    5614. 

  5614. 			    public override int GetHashCode()

    5615. 

  5615. 			    {

    5616. 

  5616. 			        return Val.GetHashCode();

    5617. 

  5617. 			    }

    5618. 

  5618. 			}

    5619. 

  5619. 			

    5620. 

  5620. 			public struct Sc : IEquatable<Sc>

    5621. 

  5621. 			{

    5622. 

  5622. 			    public Sc(string s)

    5623. 

  5623. 			    {

    5624. 

  5624. 			        S = s;

    5625. 

  5625. 			    }

    5626. 

  5626. 			

    5627. 

  5627. 			    public string S;

    5628. 

  5628. 			

    5629. 

  5629. 			    public override bool Equals(object o)

    5630. 

  5630. 			    {

    5631. 

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

    5632. 

  5632. 			    }

    5633. 

  5633. 			    public bool Equals(Sc other)

    5634. 

  5634. 			    {

    5635. 

  5635. 			        return other.S == S;

    5636. 

  5636. 			    }

    5637. 

  5637. 			    public override int GetHashCode()

    5638. 

  5638. 			    {

    5639. 

  5639. 			        return S.GetHashCode();

    5640. 

  5640. 			    }

    5641. 

  5641. 			}

    5642. 

  5642. 			

    5643. 

  5643. 			public struct Scs : IEquatable<Scs>

    5644. 

  5644. 			{

    5645. 

  5645. 			    public Scs(string s, S val)

    5646. 

  5646. 			    {

    5647. 

  5647. 			        S = s;

    5648. 

  5648. 			        Val = val;

    5649. 

  5649. 			    }

    5650. 

  5650. 			

    5651. 

  5651. 			    public string S;

    5652. 

  5652. 			    public S Val;

    5653. 

  5653. 			

    5654. 

  5654. 			    public override bool Equals(object o)

    5655. 

  5655. 			    {

    5656. 

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

    5657. 

  5657. 			    }

    5658. 

  5658. 			    public bool Equals(Scs other)

    5659. 

  5659. 			    {

    5660. 

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

    5661. 

  5661. 			    }

    5662. 

  5662. 			    public override int GetHashCode()

    5663. 

  5663. 			    {

    5664. 

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

    5665. 

  5665. 			    }

    5666. 

  5666. 			}

    5667. 

  5667. 			

    5668. 

  5668. 		

    5669. 

  5669. 	}

    5670. 

  5670. 				

    5671. 

  5671. 				//-------- Scenario 3150

    5672. 

  5672. 				namespace Scenario3150{

    5673. 

  5673. 					

    5674. 

  5674. 					public class Test

    5675. 

  5675. 					{

    5676. 

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

    5677. 

  5677. 				    public static Expression D_ArrayIndex__() {

    5678. 

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

    5679. 

  5679. 				           throw new Exception();

    5680. 

  5680. 				       } else { 

    5681. 

  5681. 				           return Expression.Constant(0);

    5682. 

  5682. 				       }

    5683. 

  5683. 				    }

    5684. 

  5684. 					public     static int Main()

    5685. 

  5685. 					    {

    5686. 

  5686. 					        Ext.StartCapture();

    5687. 

  5687. 					        bool success = false;

    5688. 

  5688. 					        try

    5689. 

  5689. 					        {

    5690. 

  5690. 					            success = check_D_ArrayIndex();

    5691. 

  5691. 					        }

    5692. 

  5692. 					        finally

    5693. 

  5693. 					        {

    5694. 

  5694. 					            Ext.StopCapture();

    5695. 

  5695. 					        }

    5696. 

  5696. 					        return success ? 0 : 1;

    5697. 

  5697. 					    }

    5698. 

  5698. 					

    5699. 

  5699. 					    static bool check_D_ArrayIndex()

    5700. 

  5700. 					    {

    5701. 

  5701. 					        return checkEx_D_ArrayIndex(null, -1) &

    5702. 

  5702. 					            checkEx_D_ArrayIndex(null, 0) &

    5703. 

  5703. 					            checkEx_D_ArrayIndex(null, 1) &

    5704. 

  5704. 					

    5705. 

  5705. 					            check_D_ArrayIndex(genArrD_ArrayIndex(0)) &

    5706. 

  5706. 					            check_D_ArrayIndex(genArrD_ArrayIndex(1)) &

    5707. 

  5707. 					            check_D_ArrayIndex(genArrD_ArrayIndex(5));

    5708. 

  5708. 					    }

    5709. 

  5709. 					

    5710. 

  5710. 					    static D[] genArrD_ArrayIndex(int size)

    5711. 

  5711. 					    {

    5712. 

  5712. 					        D[] vals = new D[] { null, new D(), new D(0), new D(5) };

    5713. 

  5713. 					        D[] result = new D[size];

    5714. 

  5714. 					        for (int i = 0; i < size; i++)

    5715. 

  5715. 					        {

    5716. 

  5716. 					            result[i] = vals[i % vals.Length];

    5717. 

  5717. 					        }

    5718. 

  5718. 					        return result;

    5719. 

  5719. 					    }

    5720. 

  5720. 					

    5721. 

  5721. 					    static bool check_D_ArrayIndex(D[] val)

    5722. 

  5722. 					    {

    5723. 

  5723. 					        bool success = checkEx_D_ArrayIndex(val, -1);

    5724. 

  5724. 					        for (int i = 0; i < val.Length; i++)

    5725. 

  5725. 					        {

    5726. 

  5726. 					            success &= check_D_ArrayIndex(val, 0);

    5727. 

  5727. 					        }

    5728. 

  5728. 					        success &= checkEx_D_ArrayIndex(val, val.Length);

    5729. 

  5729. 					        return success;

    5730. 

  5730. 					    }

    5731. 

  5731. 					

    5732. 

  5732. 					    static bool checkEx_D_ArrayIndex(D[] val, int index)

    5733. 

  5733. 					    {

    5734. 

  5734. 					        try

    5735. 

  5735. 					        {

    5736. 

  5736. 					            check_D_ArrayIndex(val, index);

    5737. 

  5737. 					            Console.WriteLine("D_ArrayIndex[" + index + "] failed");

    5738. 

  5738. 					            return false;

    5739. 

  5739. 					        }

    5740. 

  5740. 					        catch

    5741. 

  5741. 					        {

    5742. 

  5742. 					            return true;

    5743. 

  5743. 					        }

    5744. 

  5744. 					    }

    5745. 

  5745. 					

    5746. 

  5746. 					    static bool check_D_ArrayIndex(D[] val, int index)

    5747. 

  5747. 					    {

    5748. 

  5748. 					        Expression<Func<D>> e =

    5749. 

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

    5750. 

  5750. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(D[])),

    5751. 

  5751. 					                    Expression.Constant(index, typeof(int))),

    5752. 

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

    5753. 

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

    5754. 

  5754. 					        return object.Equals(f(), val[index]);

    5755. 

  5755. 					    }

    5756. 

  5756. 					}

    5757. 

  5757. 				

    5758. 

  5758. 				

    5759. 

  5759. 				public  static class Ext {

    5760. 

  5760. 				    public static void StartCapture() {

    5761. 

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

    5762. 

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

    5763. 

  5763. 				    }

    5764. 

  5764. 				

    5765. 

  5765. 				    public static void StopCapture() {

    5766. 

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

    5767. 

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

    5768. 

  5768. 				    }

    5769. 

  5769. 				

    5770. 

  5770. 				    public static bool IsIntegralOrEnum(Type type) {

    5771. 

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

    5772. 

  5772. 				            case TypeCode.Byte:

    5773. 

  5773. 				            case TypeCode.SByte:

    5774. 

  5774. 				            case TypeCode.Int16:

    5775. 

  5775. 				            case TypeCode.Int32:

    5776. 

  5776. 				            case TypeCode.Int64:

    5777. 

  5777. 				            case TypeCode.UInt16:

    5778. 

  5778. 				            case TypeCode.UInt32:

    5779. 

  5779. 				            case TypeCode.UInt64:

    5780. 

  5780. 				                return true;

    5781. 

  5781. 				            default:

    5782. 

  5782. 				                return false;

    5783. 

  5783. 				        }

    5784. 

  5784. 				    }

    5785. 

  5785. 				

    5786. 

  5786. 				    public static bool IsFloating(Type type) {

    5787. 

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

    5788. 

  5788. 				            case TypeCode.Single:

    5789. 

  5789. 				            case TypeCode.Double:

    5790. 

  5790. 				                return true;

    5791. 

  5791. 				            default:

    5792. 

  5792. 				                return false;

    5793. 

  5793. 				        }

    5794. 

  5794. 				    }

    5795. 

  5795. 				

    5796. 

  5796. 				    public static Type GetNonNullableType(Type type) {

    5797. 

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

    5798. 

  5798. 				                type.GetGenericArguments()[0] :

    5799. 

  5799. 				                type;

    5800. 

  5800. 				    }

    5801. 

  5801. 				}

    5802. 

  5802. 				

    5803. 

  5803. 			

    5804. 

  5804. 			

    5805. 

  5805. 			

    5806. 

  5806. 			public interface I

    5807. 

  5807. 			{

    5808. 

  5808. 			    void M();

    5809. 

  5809. 			}

    5810. 

  5810. 			

    5811. 

  5811. 			public  class C : IEquatable<C>, I

    5812. 

  5812. 			{

    5813. 

  5813. 			    void I.M()

    5814. 

  5814. 			    {

    5815. 

  5815. 			    }

    5816. 

  5816. 			

    5817. 

  5817. 			    public override bool Equals(object o)

    5818. 

  5818. 			    {

    5819. 

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

    5820. 

  5820. 			    }

    5821. 

  5821. 			

    5822. 

  5822. 			    public bool Equals(C c)

    5823. 

  5823. 			    {

    5824. 

  5824. 			        return c != null;

    5825. 

  5825. 			    }

    5826. 

  5826. 			

    5827. 

  5827. 			    public override int GetHashCode()

    5828. 

  5828. 			    {

    5829. 

  5829. 			        return 0;

    5830. 

  5830. 			    }

    5831. 

  5831. 			}

    5832. 

  5832. 			

    5833. 

  5833. 			public  class D : C, IEquatable<D>

    5834. 

  5834. 			{

    5835. 

  5835. 			    public int Val;

    5836. 

  5836. 			    public D()

    5837. 

  5837. 			    {

    5838. 

  5838. 			    }

    5839. 

  5839. 			    public D(int val)

    5840. 

  5840. 			    {

    5841. 

  5841. 			        Val = val;

    5842. 

  5842. 			    }

    5843. 

  5843. 			

    5844. 

  5844. 			    public override bool Equals(object o)

    5845. 

  5845. 			    {

    5846. 

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

    5847. 

  5847. 			    }

    5848. 

  5848. 			

    5849. 

  5849. 			    public bool Equals(D d)

    5850. 

  5850. 			    {

    5851. 

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

    5852. 

  5852. 			    }

    5853. 

  5853. 			

    5854. 

  5854. 			    public override int GetHashCode()

    5855. 

  5855. 			    {

    5856. 

  5856. 			        return Val;

    5857. 

  5857. 			    }

    5858. 

  5858. 			}

    5859. 

  5859. 			

    5860. 

  5860. 			public enum E

    5861. 

  5861. 			{

    5862. 

  5862. 			    A = 1, B = 2

    5863. 

  5863. 			}

    5864. 

  5864. 			

    5865. 

  5865. 			public enum El : long

    5866. 

  5866. 			{

    5867. 

  5867. 			    A, B, C

    5868. 

  5868. 			}

    5869. 

  5869. 			

    5870. 

  5870. 			public struct S : IEquatable<S>

    5871. 

  5871. 			{

    5872. 

  5872. 			    public override bool Equals(object o)

    5873. 

  5873. 			    {

    5874. 

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

    5875. 

  5875. 			    }

    5876. 

  5876. 			    public bool Equals(S other)

    5877. 

  5877. 			    {

    5878. 

  5878. 			        return true;

    5879. 

  5879. 			    }

    5880. 

  5880. 			    public override int GetHashCode()

    5881. 

  5881. 			    {

    5882. 

  5882. 			        return 0;

    5883. 

  5883. 			    }

    5884. 

  5884. 			}

    5885. 

  5885. 			

    5886. 

  5886. 			public struct Sp : IEquatable<Sp>

    5887. 

  5887. 			{

    5888. 

  5888. 			    public Sp(int i, double d)

    5889. 

  5889. 			    {

    5890. 

  5890. 			        I = i;

    5891. 

  5891. 			        D = d;

    5892. 

  5892. 			    }

    5893. 

  5893. 			

    5894. 

  5894. 			    public int I;

    5895. 

  5895. 			    public double D;

    5896. 

  5896. 			

    5897. 

  5897. 			    public override bool Equals(object o)

    5898. 

  5898. 			    {

    5899. 

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

    5900. 

  5900. 			    }

    5901. 

  5901. 			    public bool Equals(Sp other)

    5902. 

  5902. 			    {

    5903. 

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

    5904. 

  5904. 			    }

    5905. 

  5905. 			    public override int GetHashCode()

    5906. 

  5906. 			    {

    5907. 

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

    5908. 

  5908. 			    }

    5909. 

  5909. 			}

    5910. 

  5910. 			

    5911. 

  5911. 			public struct Ss : IEquatable<Ss>

    5912. 

  5912. 			{

    5913. 

  5913. 			    public Ss(S s)

    5914. 

  5914. 			    {

    5915. 

  5915. 			        Val = s;

    5916. 

  5916. 			    }

    5917. 

  5917. 			

    5918. 

  5918. 			    public S Val;

    5919. 

  5919. 			

    5920. 

  5920. 			    public override bool Equals(object o)

    5921. 

  5921. 			    {

    5922. 

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

    5923. 

  5923. 			    }

    5924. 

  5924. 			    public bool Equals(Ss other)

    5925. 

  5925. 			    {

    5926. 

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

    5927. 

  5927. 			    }

    5928. 

  5928. 			    public override int GetHashCode()

    5929. 

  5929. 			    {

    5930. 

  5930. 			        return Val.GetHashCode();

    5931. 

  5931. 			    }

    5932. 

  5932. 			}

    5933. 

  5933. 			

    5934. 

  5934. 			public struct Sc : IEquatable<Sc>

    5935. 

  5935. 			{

    5936. 

  5936. 			    public Sc(string s)

    5937. 

  5937. 			    {

    5938. 

  5938. 			        S = s;

    5939. 

  5939. 			    }

    5940. 

  5940. 			

    5941. 

  5941. 			    public string S;

    5942. 

  5942. 			

    5943. 

  5943. 			    public override bool Equals(object o)

    5944. 

  5944. 			    {

    5945. 

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

    5946. 

  5946. 			    }

    5947. 

  5947. 			    public bool Equals(Sc other)

    5948. 

  5948. 			    {

    5949. 

  5949. 			        return other.S == S;

    5950. 

  5950. 			    }

    5951. 

  5951. 			    public override int GetHashCode()

    5952. 

  5952. 			    {

    5953. 

  5953. 			        return S.GetHashCode();

    5954. 

  5954. 			    }

    5955. 

  5955. 			}

    5956. 

  5956. 			

    5957. 

  5957. 			public struct Scs : IEquatable<Scs>

    5958. 

  5958. 			{

    5959. 

  5959. 			    public Scs(string s, S val)

    5960. 

  5960. 			    {

    5961. 

  5961. 			        S = s;

    5962. 

  5962. 			        Val = val;

    5963. 

  5963. 			    }

    5964. 

  5964. 			

    5965. 

  5965. 			    public string S;

    5966. 

  5966. 			    public S Val;

    5967. 

  5967. 			

    5968. 

  5968. 			    public override bool Equals(object o)

    5969. 

  5969. 			    {

    5970. 

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

    5971. 

  5971. 			    }

    5972. 

  5972. 			    public bool Equals(Scs other)

    5973. 

  5973. 			    {

    5974. 

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

    5975. 

  5975. 			    }

    5976. 

  5976. 			    public override int GetHashCode()

    5977. 

  5977. 			    {

    5978. 

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

    5979. 

  5979. 			    }

    5980. 

  5980. 			}

    5981. 

  5981. 			

    5982. 

  5982. 		

    5983. 

  5983. 	}

    5984. 

  5984. 				

    5985. 

  5985. 				//-------- Scenario 3151

    5986. 

  5986. 				namespace Scenario3151{

    5987. 

  5987. 					

    5988. 

  5988. 					public class Test

    5989. 

  5989. 					{

    5990. 

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

    5991. 

  5991. 				    public static Expression T_ArrayIndex_object___() {

    5992. 

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

    5993. 

  5993. 				           throw new Exception();

    5994. 

  5994. 				       } else { 

    5995. 

  5995. 				           return Expression.Constant(0);

    5996. 

  5996. 				       }

    5997. 

  5997. 				    }

    5998. 

  5998. 					public     static int Main()

    5999. 

  5999. 					    {

    6000. 

  6000. 					        Ext.StartCapture();

    6001. 

  6001. 					        bool success = false;

    6002. 

  6002. 					        try

    6003. 

  6003. 					        {

    6004. 

  6004. 					            success = check_T_ArrayIndex<object>();

    6005. 

  6005. 					        }

    6006. 

  6006. 					        finally

    6007. 

  6007. 					        {

    6008. 

  6008. 					            Ext.StopCapture();

    6009. 

  6009. 					        }

    6010. 

  6010. 					        return success ? 0 : 1;

    6011. 

  6011. 					    }

    6012. 

  6012. 					

    6013. 

  6013. 					    static bool check_T_ArrayIndex<T>()

    6014. 

  6014. 					    {

    6015. 

  6015. 					        return checkEx_T_ArrayIndex<T>(null, -1) &

    6016. 

  6016. 					            checkEx_T_ArrayIndex<T>(null, 0) &

    6017. 

  6017. 					            checkEx_T_ArrayIndex<T>(null, 1) &

    6018. 

  6018. 					

    6019. 

  6019. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(0)) &

    6020. 

  6020. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(1)) &

    6021. 

  6021. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(5));

    6022. 

  6022. 					    }

    6023. 

  6023. 					

    6024. 

  6024. 					    static T[] genArrT_ArrayIndex<T>(int size)

    6025. 

  6025. 					    {

    6026. 

  6026. 					        T[] vals = new T[] { default(T) };

    6027. 

  6027. 					        T[] result = new T[size];

    6028. 

  6028. 					        for (int i = 0; i < size; i++)

    6029. 

  6029. 					        {

    6030. 

  6030. 					            result[i] = vals[i % vals.Length];

    6031. 

  6031. 					        }

    6032. 

  6032. 					        return result;

    6033. 

  6033. 					    }

    6034. 

  6034. 					

    6035. 

  6035. 					    static bool check_T_ArrayIndex<T>(T[] val)

    6036. 

  6036. 					    {

    6037. 

  6037. 					        bool success = checkEx_T_ArrayIndex<T>(val, -1);

    6038. 

  6038. 					        for (int i = 0; i < val.Length; i++)

    6039. 

  6039. 					        {

    6040. 

  6040. 					            success &= check_T_ArrayIndex<T>(val, 0);

    6041. 

  6041. 					        }

    6042. 

  6042. 					        success &= checkEx_T_ArrayIndex<T>(val, val.Length);

    6043. 

  6043. 					        return success;

    6044. 

  6044. 					    }

    6045. 

  6045. 					

    6046. 

  6046. 					    static bool checkEx_T_ArrayIndex<T>(T[] val, int index)

    6047. 

  6047. 					    {

    6048. 

  6048. 					        try

    6049. 

  6049. 					        {

    6050. 

  6050. 					            check_T_ArrayIndex<T>(val, index);

    6051. 

  6051. 					            Console.WriteLine("T_ArrayIndex[" + index + "] failed");

    6052. 

  6052. 					            return false;

    6053. 

  6053. 					        }

    6054. 

  6054. 					        catch

    6055. 

  6055. 					        {

    6056. 

  6056. 					            return true;

    6057. 

  6057. 					        }

    6058. 

  6058. 					    }

    6059. 

  6059. 					

    6060. 

  6060. 					    static bool check_T_ArrayIndex<T>(T[] val, int index)

    6061. 

  6061. 					    {

    6062. 

  6062. 					        Expression<Func<T>> e =

    6063. 

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

    6064. 

  6064. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(T[])),

    6065. 

  6065. 					                    Expression.Constant(index, typeof(int))),

    6066. 

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

    6067. 

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

    6068. 

  6068. 					        return object.Equals(f(), val[index]);

    6069. 

  6069. 					    }

    6070. 

  6070. 					}

    6071. 

  6071. 				

    6072. 

  6072. 				

    6073. 

  6073. 				public  static class Ext {

    6074. 

  6074. 				    public static void StartCapture() {

    6075. 

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

    6076. 

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

    6077. 

  6077. 				    }

    6078. 

  6078. 				

    6079. 

  6079. 				    public static void StopCapture() {

    6080. 

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

    6081. 

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

    6082. 

  6082. 				    }

    6083. 

  6083. 				

    6084. 

  6084. 				    public static bool IsIntegralOrEnum(Type type) {

    6085. 

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

    6086. 

  6086. 				            case TypeCode.Byte:

    6087. 

  6087. 				            case TypeCode.SByte:

    6088. 

  6088. 				            case TypeCode.Int16:

    6089. 

  6089. 				            case TypeCode.Int32:

    6090. 

  6090. 				            case TypeCode.Int64:

    6091. 

  6091. 				            case TypeCode.UInt16:

    6092. 

  6092. 				            case TypeCode.UInt32:

    6093. 

  6093. 				            case TypeCode.UInt64:

    6094. 

  6094. 				                return true;

    6095. 

  6095. 				            default:

    6096. 

  6096. 				                return false;

    6097. 

  6097. 				        }

    6098. 

  6098. 				    }

    6099. 

  6099. 				

    6100. 

  6100. 				    public static bool IsFloating(Type type) {

    6101. 

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

    6102. 

  6102. 				            case TypeCode.Single:

    6103. 

  6103. 				            case TypeCode.Double:

    6104. 

  6104. 				                return true;

    6105. 

  6105. 				            default:

    6106. 

  6106. 				                return false;

    6107. 

  6107. 				        }

    6108. 

  6108. 				    }

    6109. 

  6109. 				

    6110. 

  6110. 				    public static Type GetNonNullableType(Type type) {

    6111. 

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

    6112. 

  6112. 				                type.GetGenericArguments()[0] :

    6113. 

  6113. 				                type;

    6114. 

  6114. 				    }

    6115. 

  6115. 				}

    6116. 

  6116. 				

    6117. 

  6117. 			

    6118. 

  6118. 			

    6119. 

  6119. 			

    6120. 

  6120. 			public interface I

    6121. 

  6121. 			{

    6122. 

  6122. 			    void M();

    6123. 

  6123. 			}

    6124. 

  6124. 			

    6125. 

  6125. 			public  class C : IEquatable<C>, I

    6126. 

  6126. 			{

    6127. 

  6127. 			    void I.M()

    6128. 

  6128. 			    {

    6129. 

  6129. 			    }

    6130. 

  6130. 			

    6131. 

  6131. 			    public override bool Equals(object o)

    6132. 

  6132. 			    {

    6133. 

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

    6134. 

  6134. 			    }

    6135. 

  6135. 			

    6136. 

  6136. 			    public bool Equals(C c)

    6137. 

  6137. 			    {

    6138. 

  6138. 			        return c != null;

    6139. 

  6139. 			    }

    6140. 

  6140. 			

    6141. 

  6141. 			    public override int GetHashCode()

    6142. 

  6142. 			    {

    6143. 

  6143. 			        return 0;

    6144. 

  6144. 			    }

    6145. 

  6145. 			}

    6146. 

  6146. 			

    6147. 

  6147. 			public  class D : C, IEquatable<D>

    6148. 

  6148. 			{

    6149. 

  6149. 			    public int Val;

    6150. 

  6150. 			    public D()

    6151. 

  6151. 			    {

    6152. 

  6152. 			    }

    6153. 

  6153. 			    public D(int val)

    6154. 

  6154. 			    {

    6155. 

  6155. 			        Val = val;

    6156. 

  6156. 			    }

    6157. 

  6157. 			

    6158. 

  6158. 			    public override bool Equals(object o)

    6159. 

  6159. 			    {

    6160. 

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

    6161. 

  6161. 			    }

    6162. 

  6162. 			

    6163. 

  6163. 			    public bool Equals(D d)

    6164. 

  6164. 			    {

    6165. 

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

    6166. 

  6166. 			    }

    6167. 

  6167. 			

    6168. 

  6168. 			    public override int GetHashCode()

    6169. 

  6169. 			    {

    6170. 

  6170. 			        return Val;

    6171. 

  6171. 			    }

    6172. 

  6172. 			}

    6173. 

  6173. 			

    6174. 

  6174. 			public enum E

    6175. 

  6175. 			{

    6176. 

  6176. 			    A = 1, B = 2

    6177. 

  6177. 			}

    6178. 

  6178. 			

    6179. 

  6179. 			public enum El : long

    6180. 

  6180. 			{

    6181. 

  6181. 			    A, B, C

    6182. 

  6182. 			}

    6183. 

  6183. 			

    6184. 

  6184. 			public struct S : IEquatable<S>

    6185. 

  6185. 			{

    6186. 

  6186. 			    public override bool Equals(object o)

    6187. 

  6187. 			    {

    6188. 

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

    6189. 

  6189. 			    }

    6190. 

  6190. 			    public bool Equals(S other)

    6191. 

  6191. 			    {

    6192. 

  6192. 			        return true;

    6193. 

  6193. 			    }

    6194. 

  6194. 			    public override int GetHashCode()

    6195. 

  6195. 			    {

    6196. 

  6196. 			        return 0;

    6197. 

  6197. 			    }

    6198. 

  6198. 			}

    6199. 

  6199. 			

    6200. 

  6200. 			public struct Sp : IEquatable<Sp>

    6201. 

  6201. 			{

    6202. 

  6202. 			    public Sp(int i, double d)

    6203. 

  6203. 			    {

    6204. 

  6204. 			        I = i;

    6205. 

  6205. 			        D = d;

    6206. 

  6206. 			    }

    6207. 

  6207. 			

    6208. 

  6208. 			    public int I;

    6209. 

  6209. 			    public double D;

    6210. 

  6210. 			

    6211. 

  6211. 			    public override bool Equals(object o)

    6212. 

  6212. 			    {

    6213. 

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

    6214. 

  6214. 			    }

    6215. 

  6215. 			    public bool Equals(Sp other)

    6216. 

  6216. 			    {

    6217. 

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

    6218. 

  6218. 			    }

    6219. 

  6219. 			    public override int GetHashCode()

    6220. 

  6220. 			    {

    6221. 

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

    6222. 

  6222. 			    }

    6223. 

  6223. 			}

    6224. 

  6224. 			

    6225. 

  6225. 			public struct Ss : IEquatable<Ss>

    6226. 

  6226. 			{

    6227. 

  6227. 			    public Ss(S s)

    6228. 

  6228. 			    {

    6229. 

  6229. 			        Val = s;

    6230. 

  6230. 			    }

    6231. 

  6231. 			

    6232. 

  6232. 			    public S Val;

    6233. 

  6233. 			

    6234. 

  6234. 			    public override bool Equals(object o)

    6235. 

  6235. 			    {

    6236. 

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

    6237. 

  6237. 			    }

    6238. 

  6238. 			    public bool Equals(Ss other)

    6239. 

  6239. 			    {

    6240. 

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

    6241. 

  6241. 			    }

    6242. 

  6242. 			    public override int GetHashCode()

    6243. 

  6243. 			    {

    6244. 

  6244. 			        return Val.GetHashCode();

    6245. 

  6245. 			    }

    6246. 

  6246. 			}

    6247. 

  6247. 			

    6248. 

  6248. 			public struct Sc : IEquatable<Sc>

    6249. 

  6249. 			{

    6250. 

  6250. 			    public Sc(string s)

    6251. 

  6251. 			    {

    6252. 

  6252. 			        S = s;

    6253. 

  6253. 			    }

    6254. 

  6254. 			

    6255. 

  6255. 			    public string S;

    6256. 

  6256. 			

    6257. 

  6257. 			    public override bool Equals(object o)

    6258. 

  6258. 			    {

    6259. 

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

    6260. 

  6260. 			    }

    6261. 

  6261. 			    public bool Equals(Sc other)

    6262. 

  6262. 			    {

    6263. 

  6263. 			        return other.S == S;

    6264. 

  6264. 			    }

    6265. 

  6265. 			    public override int GetHashCode()

    6266. 

  6266. 			    {

    6267. 

  6267. 			        return S.GetHashCode();

    6268. 

  6268. 			    }

    6269. 

  6269. 			}

    6270. 

  6270. 			

    6271. 

  6271. 			public struct Scs : IEquatable<Scs>

    6272. 

  6272. 			{

    6273. 

  6273. 			    public Scs(string s, S val)

    6274. 

  6274. 			    {

    6275. 

  6275. 			        S = s;

    6276. 

  6276. 			        Val = val;

    6277. 

  6277. 			    }

    6278. 

  6278. 			

    6279. 

  6279. 			    public string S;

    6280. 

  6280. 			    public S Val;

    6281. 

  6281. 			

    6282. 

  6282. 			    public override bool Equals(object o)

    6283. 

  6283. 			    {

    6284. 

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

    6285. 

  6285. 			    }

    6286. 

  6286. 			    public bool Equals(Scs other)

    6287. 

  6287. 			    {

    6288. 

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

    6289. 

  6289. 			    }

    6290. 

  6290. 			    public override int GetHashCode()

    6291. 

  6291. 			    {

    6292. 

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

    6293. 

  6293. 			    }

    6294. 

  6294. 			}

    6295. 

  6295. 			

    6296. 

  6296. 		

    6297. 

  6297. 	}

    6298. 

  6298. 				

    6299. 

  6299. 				//-------- Scenario 3152

    6300. 

  6300. 				namespace Scenario3152{

    6301. 

  6301. 					

    6302. 

  6302. 					public class Test

    6303. 

  6303. 					{

    6304. 

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

    6305. 

  6305. 				    public static Expression T_ArrayIndex_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 = check_T_ArrayIndex<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 check_T_ArrayIndex<T>()

    6328. 

  6328. 					    {

    6329. 

  6329. 					        return checkEx_T_ArrayIndex<T>(null, -1) &

    6330. 

  6330. 					            checkEx_T_ArrayIndex<T>(null, 0) &

    6331. 

  6331. 					            checkEx_T_ArrayIndex<T>(null, 1) &

    6332. 

  6332. 					

    6333. 

  6333. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(0)) &

    6334. 

  6334. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(1)) &

    6335. 

  6335. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(5));

    6336. 

  6336. 					    }

    6337. 

  6337. 					

    6338. 

  6338. 					    static T[] genArrT_ArrayIndex<T>(int size)

    6339. 

  6339. 					    {

    6340. 

  6340. 					        T[] vals = new T[] { default(T) };

    6341. 

  6341. 					        T[] result = new T[size];

    6342. 

  6342. 					        for (int i = 0; i < size; i++)

    6343. 

  6343. 					        {

    6344. 

  6344. 					            result[i] = vals[i % vals.Length];

    6345. 

  6345. 					        }

    6346. 

  6346. 					        return result;

    6347. 

  6347. 					    }

    6348. 

  6348. 					

    6349. 

  6349. 					    static bool check_T_ArrayIndex<T>(T[] val)

    6350. 

  6350. 					    {

    6351. 

  6351. 					        bool success = checkEx_T_ArrayIndex<T>(val, -1);

    6352. 

  6352. 					        for (int i = 0; i < val.Length; i++)

    6353. 

  6353. 					        {

    6354. 

  6354. 					            success &= check_T_ArrayIndex<T>(val, 0);

    6355. 

  6355. 					        }

    6356. 

  6356. 					        success &= checkEx_T_ArrayIndex<T>(val, val.Length);

    6357. 

  6357. 					        return success;

    6358. 

  6358. 					    }

    6359. 

  6359. 					

    6360. 

  6360. 					    static bool checkEx_T_ArrayIndex<T>(T[] val, int index)

    6361. 

  6361. 					    {

    6362. 

  6362. 					        try

    6363. 

  6363. 					        {

    6364. 

  6364. 					            check_T_ArrayIndex<T>(val, index);

    6365. 

  6365. 					            Console.WriteLine("T_ArrayIndex[" + index + "] failed");

    6366. 

  6366. 					            return false;

    6367. 

  6367. 					        }

    6368. 

  6368. 					        catch

    6369. 

  6369. 					        {

    6370. 

  6370. 					            return true;

    6371. 

  6371. 					        }

    6372. 

  6372. 					    }

    6373. 

  6373. 					

    6374. 

  6374. 					    static bool check_T_ArrayIndex<T>(T[] val, int index)

    6375. 

  6375. 					    {

    6376. 

  6376. 					        Expression<Func<T>> e =

    6377. 

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

    6378. 

  6378. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(T[])),

    6379. 

  6379. 					                    Expression.Constant(index, typeof(int))),

    6380. 

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

    6381. 

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

    6382. 

  6382. 					        return object.Equals(f(), val[index]);

    6383. 

  6383. 					    }

    6384. 

  6384. 					}

    6385. 

  6385. 				

    6386. 

  6386. 				

    6387. 

  6387. 				public  static class Ext {

    6388. 

  6388. 				    public static void StartCapture() {

    6389. 

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

    6390. 

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

    6391. 

  6391. 				    }

    6392. 

  6392. 				

    6393. 

  6393. 				    public static void StopCapture() {

    6394. 

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

    6395. 

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

    6396. 

  6396. 				    }

    6397. 

  6397. 				

    6398. 

  6398. 				    public static bool IsIntegralOrEnum(Type type) {

    6399. 

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

    6400. 

  6400. 				            case TypeCode.Byte:

    6401. 

  6401. 				            case TypeCode.SByte:

    6402. 

  6402. 				            case TypeCode.Int16:

    6403. 

  6403. 				            case TypeCode.Int32:

    6404. 

  6404. 				            case TypeCode.Int64:

    6405. 

  6405. 				            case TypeCode.UInt16:

    6406. 

  6406. 				            case TypeCode.UInt32:

    6407. 

  6407. 				            case TypeCode.UInt64:

    6408. 

  6408. 				                return true;

    6409. 

  6409. 				            default:

    6410. 

  6410. 				                return false;

    6411. 

  6411. 				        }

    6412. 

  6412. 				    }

    6413. 

  6413. 				

    6414. 

  6414. 				    public static bool IsFloating(Type type) {

    6415. 

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

    6416. 

  6416. 				            case TypeCode.Single:

    6417. 

  6417. 				            case TypeCode.Double:

    6418. 

  6418. 				                return true;

    6419. 

  6419. 				            default:

    6420. 

  6420. 				                return false;

    6421. 

  6421. 				        }

    6422. 

  6422. 				    }

    6423. 

  6423. 				

    6424. 

  6424. 				    public static Type GetNonNullableType(Type type) {

    6425. 

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

    6426. 

  6426. 				                type.GetGenericArguments()[0] :

    6427. 

  6427. 				                type;

    6428. 

  6428. 				    }

    6429. 

  6429. 				}

    6430. 

  6430. 				

    6431. 

  6431. 			

    6432. 

  6432. 			

    6433. 

  6433. 			

    6434. 

  6434. 			public interface I

    6435. 

  6435. 			{

    6436. 

  6436. 			    void M();

    6437. 

  6437. 			}

    6438. 

  6438. 			

    6439. 

  6439. 			public  class C : IEquatable<C>, I

    6440. 

  6440. 			{

    6441. 

  6441. 			    void I.M()

    6442. 

  6442. 			    {

    6443. 

  6443. 			    }

    6444. 

  6444. 			

    6445. 

  6445. 			    public override bool Equals(object o)

    6446. 

  6446. 			    {

    6447. 

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

    6448. 

  6448. 			    }

    6449. 

  6449. 			

    6450. 

  6450. 			    public bool Equals(C c)

    6451. 

  6451. 			    {

    6452. 

  6452. 			        return c != null;

    6453. 

  6453. 			    }

    6454. 

  6454. 			

    6455. 

  6455. 			    public override int GetHashCode()

    6456. 

  6456. 			    {

    6457. 

  6457. 			        return 0;

    6458. 

  6458. 			    }

    6459. 

  6459. 			}

    6460. 

  6460. 			

    6461. 

  6461. 			public  class D : C, IEquatable<D>

    6462. 

  6462. 			{

    6463. 

  6463. 			    public int Val;

    6464. 

  6464. 			    public D()

    6465. 

  6465. 			    {

    6466. 

  6466. 			    }

    6467. 

  6467. 			    public D(int val)

    6468. 

  6468. 			    {

    6469. 

  6469. 			        Val = val;

    6470. 

  6470. 			    }

    6471. 

  6471. 			

    6472. 

  6472. 			    public override bool Equals(object o)

    6473. 

  6473. 			    {

    6474. 

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

    6475. 

  6475. 			    }

    6476. 

  6476. 			

    6477. 

  6477. 			    public bool Equals(D d)

    6478. 

  6478. 			    {

    6479. 

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

    6480. 

  6480. 			    }

    6481. 

  6481. 			

    6482. 

  6482. 			    public override int GetHashCode()

    6483. 

  6483. 			    {

    6484. 

  6484. 			        return Val;

    6485. 

  6485. 			    }

    6486. 

  6486. 			}

    6487. 

  6487. 			

    6488. 

  6488. 			public enum E

    6489. 

  6489. 			{

    6490. 

  6490. 			    A = 1, B = 2

    6491. 

  6491. 			}

    6492. 

  6492. 			

    6493. 

  6493. 			public enum El : long

    6494. 

  6494. 			{

    6495. 

  6495. 			    A, B, C

    6496. 

  6496. 			}

    6497. 

  6497. 			

    6498. 

  6498. 			public struct S : IEquatable<S>

    6499. 

  6499. 			{

    6500. 

  6500. 			    public override bool Equals(object o)

    6501. 

  6501. 			    {

    6502. 

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

    6503. 

  6503. 			    }

    6504. 

  6504. 			    public bool Equals(S other)

    6505. 

  6505. 			    {

    6506. 

  6506. 			        return true;

    6507. 

  6507. 			    }

    6508. 

  6508. 			    public override int GetHashCode()

    6509. 

  6509. 			    {

    6510. 

  6510. 			        return 0;

    6511. 

  6511. 			    }

    6512. 

  6512. 			}

    6513. 

  6513. 			

    6514. 

  6514. 			public struct Sp : IEquatable<Sp>

    6515. 

  6515. 			{

    6516. 

  6516. 			    public Sp(int i, double d)

    6517. 

  6517. 			    {

    6518. 

  6518. 			        I = i;

    6519. 

  6519. 			        D = d;

    6520. 

  6520. 			    }

    6521. 

  6521. 			

    6522. 

  6522. 			    public int I;

    6523. 

  6523. 			    public double D;

    6524. 

  6524. 			

    6525. 

  6525. 			    public override bool Equals(object o)

    6526. 

  6526. 			    {

    6527. 

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

    6528. 

  6528. 			    }

    6529. 

  6529. 			    public bool Equals(Sp other)

    6530. 

  6530. 			    {

    6531. 

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

    6532. 

  6532. 			    }

    6533. 

  6533. 			    public override int GetHashCode()

    6534. 

  6534. 			    {

    6535. 

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

    6536. 

  6536. 			    }

    6537. 

  6537. 			}

    6538. 

  6538. 			

    6539. 

  6539. 			public struct Ss : IEquatable<Ss>

    6540. 

  6540. 			{

    6541. 

  6541. 			    public Ss(S s)

    6542. 

  6542. 			    {

    6543. 

  6543. 			        Val = s;

    6544. 

  6544. 			    }

    6545. 

  6545. 			

    6546. 

  6546. 			    public S Val;

    6547. 

  6547. 			

    6548. 

  6548. 			    public override bool Equals(object o)

    6549. 

  6549. 			    {

    6550. 

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

    6551. 

  6551. 			    }

    6552. 

  6552. 			    public bool Equals(Ss other)

    6553. 

  6553. 			    {

    6554. 

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

    6555. 

  6555. 			    }

    6556. 

  6556. 			    public override int GetHashCode()

    6557. 

  6557. 			    {

    6558. 

  6558. 			        return Val.GetHashCode();

    6559. 

  6559. 			    }

    6560. 

  6560. 			}

    6561. 

  6561. 			

    6562. 

  6562. 			public struct Sc : IEquatable<Sc>

    6563. 

  6563. 			{

    6564. 

  6564. 			    public Sc(string s)

    6565. 

  6565. 			    {

    6566. 

  6566. 			        S = s;

    6567. 

  6567. 			    }

    6568. 

  6568. 			

    6569. 

  6569. 			    public string S;

    6570. 

  6570. 			

    6571. 

  6571. 			    public override bool Equals(object o)

    6572. 

  6572. 			    {

    6573. 

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

    6574. 

  6574. 			    }

    6575. 

  6575. 			    public bool Equals(Sc other)

    6576. 

  6576. 			    {

    6577. 

  6577. 			        return other.S == S;

    6578. 

  6578. 			    }

    6579. 

  6579. 			    public override int GetHashCode()

    6580. 

  6580. 			    {

    6581. 

  6581. 			        return S.GetHashCode();

    6582. 

  6582. 			    }

    6583. 

  6583. 			}

    6584. 

  6584. 			

    6585. 

  6585. 			public struct Scs : IEquatable<Scs>

    6586. 

  6586. 			{

    6587. 

  6587. 			    public Scs(string s, S val)

    6588. 

  6588. 			    {

    6589. 

  6589. 			        S = s;

    6590. 

  6590. 			        Val = val;

    6591. 

  6591. 			    }

    6592. 

  6592. 			

    6593. 

  6593. 			    public string S;

    6594. 

  6594. 			    public S Val;

    6595. 

  6595. 			

    6596. 

  6596. 			    public override bool Equals(object o)

    6597. 

  6597. 			    {

    6598. 

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

    6599. 

  6599. 			    }

    6600. 

  6600. 			    public bool Equals(Scs other)

    6601. 

  6601. 			    {

    6602. 

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

    6603. 

  6603. 			    }

    6604. 

  6604. 			    public override int GetHashCode()

    6605. 

  6605. 			    {

    6606. 

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

    6607. 

  6607. 			    }

    6608. 

  6608. 			}

    6609. 

  6609. 			

    6610. 

  6610. 		

    6611. 

  6611. 	}

    6612. 

  6612. 				

    6613. 

  6613. 				//-------- Scenario 3153

    6614. 

  6614. 				namespace Scenario3153{

    6615. 

  6615. 					

    6616. 

  6616. 					public class Test

    6617. 

  6617. 					{

    6618. 

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

    6619. 

  6619. 				    public static Expression T_ArrayIndex_S___() {

    6620. 

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

    6621. 

  6621. 				           throw new Exception();

    6622. 

  6622. 				       } else { 

    6623. 

  6623. 				           return Expression.Constant(0);

    6624. 

  6624. 				       }

    6625. 

  6625. 				    }

    6626. 

  6626. 					public     static int Main()

    6627. 

  6627. 					    {

    6628. 

  6628. 					        Ext.StartCapture();

    6629. 

  6629. 					        bool success = false;

    6630. 

  6630. 					        try

    6631. 

  6631. 					        {

    6632. 

  6632. 					            success = check_T_ArrayIndex<S>();

    6633. 

  6633. 					        }

    6634. 

  6634. 					        finally

    6635. 

  6635. 					        {

    6636. 

  6636. 					            Ext.StopCapture();

    6637. 

  6637. 					        }

    6638. 

  6638. 					        return success ? 0 : 1;

    6639. 

  6639. 					    }

    6640. 

  6640. 					

    6641. 

  6641. 					    static bool check_T_ArrayIndex<T>()

    6642. 

  6642. 					    {

    6643. 

  6643. 					        return checkEx_T_ArrayIndex<T>(null, -1) &

    6644. 

  6644. 					            checkEx_T_ArrayIndex<T>(null, 0) &

    6645. 

  6645. 					            checkEx_T_ArrayIndex<T>(null, 1) &

    6646. 

  6646. 					

    6647. 

  6647. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(0)) &

    6648. 

  6648. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(1)) &

    6649. 

  6649. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(5));

    6650. 

  6650. 					    }

    6651. 

  6651. 					

    6652. 

  6652. 					    static T[] genArrT_ArrayIndex<T>(int size)

    6653. 

  6653. 					    {

    6654. 

  6654. 					        T[] vals = new T[] { default(T) };

    6655. 

  6655. 					        T[] result = new T[size];

    6656. 

  6656. 					        for (int i = 0; i < size; i++)

    6657. 

  6657. 					        {

    6658. 

  6658. 					            result[i] = vals[i % vals.Length];

    6659. 

  6659. 					        }

    6660. 

  6660. 					        return result;

    6661. 

  6661. 					    }

    6662. 

  6662. 					

    6663. 

  6663. 					    static bool check_T_ArrayIndex<T>(T[] val)

    6664. 

  6664. 					    {

    6665. 

  6665. 					        bool success = checkEx_T_ArrayIndex<T>(val, -1);

    6666. 

  6666. 					        for (int i = 0; i < val.Length; i++)

    6667. 

  6667. 					        {

    6668. 

  6668. 					            success &= check_T_ArrayIndex<T>(val, 0);

    6669. 

  6669. 					        }

    6670. 

  6670. 					        success &= checkEx_T_ArrayIndex<T>(val, val.Length);

    6671. 

  6671. 					        return success;

    6672. 

  6672. 					    }

    6673. 

  6673. 					

    6674. 

  6674. 					    static bool checkEx_T_ArrayIndex<T>(T[] val, int index)

    6675. 

  6675. 					    {

    6676. 

  6676. 					        try

    6677. 

  6677. 					        {

    6678. 

  6678. 					            check_T_ArrayIndex<T>(val, index);

    6679. 

  6679. 					            Console.WriteLine("T_ArrayIndex[" + index + "] failed");

    6680. 

  6680. 					            return false;

    6681. 

  6681. 					        }

    6682. 

  6682. 					        catch

    6683. 

  6683. 					        {

    6684. 

  6684. 					            return true;

    6685. 

  6685. 					        }

    6686. 

  6686. 					    }

    6687. 

  6687. 					

    6688. 

  6688. 					    static bool check_T_ArrayIndex<T>(T[] val, int index)

    6689. 

  6689. 					    {

    6690. 

  6690. 					        Expression<Func<T>> e =

    6691. 

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

    6692. 

  6692. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(T[])),

    6693. 

  6693. 					                    Expression.Constant(index, typeof(int))),

    6694. 

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

    6695. 

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

    6696. 

  6696. 					        return object.Equals(f(), val[index]);

    6697. 

  6697. 					    }

    6698. 

  6698. 					}

    6699. 

  6699. 				

    6700. 

  6700. 				

    6701. 

  6701. 				public  static class Ext {

    6702. 

  6702. 				    public static void StartCapture() {

    6703. 

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

    6704. 

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

    6705. 

  6705. 				    }

    6706. 

  6706. 				

    6707. 

  6707. 				    public static void StopCapture() {

    6708. 

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

    6709. 

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

    6710. 

  6710. 				    }

    6711. 

  6711. 				

    6712. 

  6712. 				    public static bool IsIntegralOrEnum(Type type) {

    6713. 

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

    6714. 

  6714. 				            case TypeCode.Byte:

    6715. 

  6715. 				            case TypeCode.SByte:

    6716. 

  6716. 				            case TypeCode.Int16:

    6717. 

  6717. 				            case TypeCode.Int32:

    6718. 

  6718. 				            case TypeCode.Int64:

    6719. 

  6719. 				            case TypeCode.UInt16:

    6720. 

  6720. 				            case TypeCode.UInt32:

    6721. 

  6721. 				            case TypeCode.UInt64:

    6722. 

  6722. 				                return true;

    6723. 

  6723. 				            default:

    6724. 

  6724. 				                return false;

    6725. 

  6725. 				        }

    6726. 

  6726. 				    }

    6727. 

  6727. 				

    6728. 

  6728. 				    public static bool IsFloating(Type type) {

    6729. 

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

    6730. 

  6730. 				            case TypeCode.Single:

    6731. 

  6731. 				            case TypeCode.Double:

    6732. 

  6732. 				                return true;

    6733. 

  6733. 				            default:

    6734. 

  6734. 				                return false;

    6735. 

  6735. 				        }

    6736. 

  6736. 				    }

    6737. 

  6737. 				

    6738. 

  6738. 				    public static Type GetNonNullableType(Type type) {

    6739. 

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

    6740. 

  6740. 				                type.GetGenericArguments()[0] :

    6741. 

  6741. 				                type;

    6742. 

  6742. 				    }

    6743. 

  6743. 				}

    6744. 

  6744. 				

    6745. 

  6745. 			

    6746. 

  6746. 			

    6747. 

  6747. 			

    6748. 

  6748. 			public interface I

    6749. 

  6749. 			{

    6750. 

  6750. 			    void M();

    6751. 

  6751. 			}

    6752. 

  6752. 			

    6753. 

  6753. 			public  class C : IEquatable<C>, I

    6754. 

  6754. 			{

    6755. 

  6755. 			    void I.M()

    6756. 

  6756. 			    {

    6757. 

  6757. 			    }

    6758. 

  6758. 			

    6759. 

  6759. 			    public override bool Equals(object o)

    6760. 

  6760. 			    {

    6761. 

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

    6762. 

  6762. 			    }

    6763. 

  6763. 			

    6764. 

  6764. 			    public bool Equals(C c)

    6765. 

  6765. 			    {

    6766. 

  6766. 			        return c != null;

    6767. 

  6767. 			    }

    6768. 

  6768. 			

    6769. 

  6769. 			    public override int GetHashCode()

    6770. 

  6770. 			    {

    6771. 

  6771. 			        return 0;

    6772. 

  6772. 			    }

    6773. 

  6773. 			}

    6774. 

  6774. 			

    6775. 

  6775. 			public  class D : C, IEquatable<D>

    6776. 

  6776. 			{

    6777. 

  6777. 			    public int Val;

    6778. 

  6778. 			    public D()

    6779. 

  6779. 			    {

    6780. 

  6780. 			    }

    6781. 

  6781. 			    public D(int val)

    6782. 

  6782. 			    {

    6783. 

  6783. 			        Val = val;

    6784. 

  6784. 			    }

    6785. 

  6785. 			

    6786. 

  6786. 			    public override bool Equals(object o)

    6787. 

  6787. 			    {

    6788. 

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

    6789. 

  6789. 			    }

    6790. 

  6790. 			

    6791. 

  6791. 			    public bool Equals(D d)

    6792. 

  6792. 			    {

    6793. 

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

    6794. 

  6794. 			    }

    6795. 

  6795. 			

    6796. 

  6796. 			    public override int GetHashCode()

    6797. 

  6797. 			    {

    6798. 

  6798. 			        return Val;

    6799. 

  6799. 			    }

    6800. 

  6800. 			}

    6801. 

  6801. 			

    6802. 

  6802. 			public enum E

    6803. 

  6803. 			{

    6804. 

  6804. 			    A = 1, B = 2

    6805. 

  6805. 			}

    6806. 

  6806. 			

    6807. 

  6807. 			public enum El : long

    6808. 

  6808. 			{

    6809. 

  6809. 			    A, B, C

    6810. 

  6810. 			}

    6811. 

  6811. 			

    6812. 

  6812. 			public struct S : IEquatable<S>

    6813. 

  6813. 			{

    6814. 

  6814. 			    public override bool Equals(object o)

    6815. 

  6815. 			    {

    6816. 

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

    6817. 

  6817. 			    }

    6818. 

  6818. 			    public bool Equals(S other)

    6819. 

  6819. 			    {

    6820. 

  6820. 			        return true;

    6821. 

  6821. 			    }

    6822. 

  6822. 			    public override int GetHashCode()

    6823. 

  6823. 			    {

    6824. 

  6824. 			        return 0;

    6825. 

  6825. 			    }

    6826. 

  6826. 			}

    6827. 

  6827. 			

    6828. 

  6828. 			public struct Sp : IEquatable<Sp>

    6829. 

  6829. 			{

    6830. 

  6830. 			    public Sp(int i, double d)

    6831. 

  6831. 			    {

    6832. 

  6832. 			        I = i;

    6833. 

  6833. 			        D = d;

    6834. 

  6834. 			    }

    6835. 

  6835. 			

    6836. 

  6836. 			    public int I;

    6837. 

  6837. 			    public double D;

    6838. 

  6838. 			

    6839. 

  6839. 			    public override bool Equals(object o)

    6840. 

  6840. 			    {

    6841. 

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

    6842. 

  6842. 			    }

    6843. 

  6843. 			    public bool Equals(Sp other)

    6844. 

  6844. 			    {

    6845. 

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

    6846. 

  6846. 			    }

    6847. 

  6847. 			    public override int GetHashCode()

    6848. 

  6848. 			    {

    6849. 

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

    6850. 

  6850. 			    }

    6851. 

  6851. 			}

    6852. 

  6852. 			

    6853. 

  6853. 			public struct Ss : IEquatable<Ss>

    6854. 

  6854. 			{

    6855. 

  6855. 			    public Ss(S s)

    6856. 

  6856. 			    {

    6857. 

  6857. 			        Val = s;

    6858. 

  6858. 			    }

    6859. 

  6859. 			

    6860. 

  6860. 			    public S Val;

    6861. 

  6861. 			

    6862. 

  6862. 			    public override bool Equals(object o)

    6863. 

  6863. 			    {

    6864. 

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

    6865. 

  6865. 			    }

    6866. 

  6866. 			    public bool Equals(Ss other)

    6867. 

  6867. 			    {

    6868. 

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

    6869. 

  6869. 			    }

    6870. 

  6870. 			    public override int GetHashCode()

    6871. 

  6871. 			    {

    6872. 

  6872. 			        return Val.GetHashCode();

    6873. 

  6873. 			    }

    6874. 

  6874. 			}

    6875. 

  6875. 			

    6876. 

  6876. 			public struct Sc : IEquatable<Sc>

    6877. 

  6877. 			{

    6878. 

  6878. 			    public Sc(string s)

    6879. 

  6879. 			    {

    6880. 

  6880. 			        S = s;

    6881. 

  6881. 			    }

    6882. 

  6882. 			

    6883. 

  6883. 			    public string S;

    6884. 

  6884. 			

    6885. 

  6885. 			    public override bool Equals(object o)

    6886. 

  6886. 			    {

    6887. 

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

    6888. 

  6888. 			    }

    6889. 

  6889. 			    public bool Equals(Sc other)

    6890. 

  6890. 			    {

    6891. 

  6891. 			        return other.S == S;

    6892. 

  6892. 			    }

    6893. 

  6893. 			    public override int GetHashCode()

    6894. 

  6894. 			    {

    6895. 

  6895. 			        return S.GetHashCode();

    6896. 

  6896. 			    }

    6897. 

  6897. 			}

    6898. 

  6898. 			

    6899. 

  6899. 			public struct Scs : IEquatable<Scs>

    6900. 

  6900. 			{

    6901. 

  6901. 			    public Scs(string s, S val)

    6902. 

  6902. 			    {

    6903. 

  6903. 			        S = s;

    6904. 

  6904. 			        Val = val;

    6905. 

  6905. 			    }

    6906. 

  6906. 			

    6907. 

  6907. 			    public string S;

    6908. 

  6908. 			    public S Val;

    6909. 

  6909. 			

    6910. 

  6910. 			    public override bool Equals(object o)

    6911. 

  6911. 			    {

    6912. 

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

    6913. 

  6913. 			    }

    6914. 

  6914. 			    public bool Equals(Scs other)

    6915. 

  6915. 			    {

    6916. 

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

    6917. 

  6917. 			    }

    6918. 

  6918. 			    public override int GetHashCode()

    6919. 

  6919. 			    {

    6920. 

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

    6921. 

  6921. 			    }

    6922. 

  6922. 			}

    6923. 

  6923. 			

    6924. 

  6924. 		

    6925. 

  6925. 	}

    6926. 

  6926. 				

    6927. 

  6927. 				//-------- Scenario 3154

    6928. 

  6928. 				namespace Scenario3154{

    6929. 

  6929. 					

    6930. 

  6930. 					public class Test

    6931. 

  6931. 					{

    6932. 

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

    6933. 

  6933. 				    public static Expression T_ArrayIndex_Scs___() {

    6934. 

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

    6935. 

  6935. 				           throw new Exception();

    6936. 

  6936. 				       } else { 

    6937. 

  6937. 				           return Expression.Constant(0);

    6938. 

  6938. 				       }

    6939. 

  6939. 				    }

    6940. 

  6940. 					public     static int Main()

    6941. 

  6941. 					    {

    6942. 

  6942. 					        Ext.StartCapture();

    6943. 

  6943. 					        bool success = false;

    6944. 

  6944. 					        try

    6945. 

  6945. 					        {

    6946. 

  6946. 					            success = check_T_ArrayIndex<Scs>();

    6947. 

  6947. 					        }

    6948. 

  6948. 					        finally

    6949. 

  6949. 					        {

    6950. 

  6950. 					            Ext.StopCapture();

    6951. 

  6951. 					        }

    6952. 

  6952. 					        return success ? 0 : 1;

    6953. 

  6953. 					    }

    6954. 

  6954. 					

    6955. 

  6955. 					    static bool check_T_ArrayIndex<T>()

    6956. 

  6956. 					    {

    6957. 

  6957. 					        return checkEx_T_ArrayIndex<T>(null, -1) &

    6958. 

  6958. 					            checkEx_T_ArrayIndex<T>(null, 0) &

    6959. 

  6959. 					            checkEx_T_ArrayIndex<T>(null, 1) &

    6960. 

  6960. 					

    6961. 

  6961. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(0)) &

    6962. 

  6962. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(1)) &

    6963. 

  6963. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(5));

    6964. 

  6964. 					    }

    6965. 

  6965. 					

    6966. 

  6966. 					    static T[] genArrT_ArrayIndex<T>(int size)

    6967. 

  6967. 					    {

    6968. 

  6968. 					        T[] vals = new T[] { default(T) };

    6969. 

  6969. 					        T[] result = new T[size];

    6970. 

  6970. 					        for (int i = 0; i < size; i++)

    6971. 

  6971. 					        {

    6972. 

  6972. 					            result[i] = vals[i % vals.Length];

    6973. 

  6973. 					        }

    6974. 

  6974. 					        return result;

    6975. 

  6975. 					    }

    6976. 

  6976. 					

    6977. 

  6977. 					    static bool check_T_ArrayIndex<T>(T[] val)

    6978. 

  6978. 					    {

    6979. 

  6979. 					        bool success = checkEx_T_ArrayIndex<T>(val, -1);

    6980. 

  6980. 					        for (int i = 0; i < val.Length; i++)

    6981. 

  6981. 					        {

    6982. 

  6982. 					            success &= check_T_ArrayIndex<T>(val, 0);

    6983. 

  6983. 					        }

    6984. 

  6984. 					        success &= checkEx_T_ArrayIndex<T>(val, val.Length);

    6985. 

  6985. 					        return success;

    6986. 

  6986. 					    }

    6987. 

  6987. 					

    6988. 

  6988. 					    static bool checkEx_T_ArrayIndex<T>(T[] val, int index)

    6989. 

  6989. 					    {

    6990. 

  6990. 					        try

    6991. 

  6991. 					        {

    6992. 

  6992. 					            check_T_ArrayIndex<T>(val, index);

    6993. 

  6993. 					            Console.WriteLine("T_ArrayIndex[" + index + "] failed");

    6994. 

  6994. 					            return false;

    6995. 

  6995. 					        }

    6996. 

  6996. 					        catch

    6997. 

  6997. 					        {

    6998. 

  6998. 					            return true;

    6999. 

  6999. 					        }

    7000. 

  7000. 					    }

    7001. 

  7001. 					

    7002. 

  7002. 					    static bool check_T_ArrayIndex<T>(T[] val, int index)

    7003. 

  7003. 					    {

    7004. 

  7004. 					        Expression<Func<T>> e =

    7005. 

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

    7006. 

  7006. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(T[])),

    7007. 

  7007. 					                    Expression.Constant(index, typeof(int))),

    7008. 

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

    7009. 

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

    7010. 

  7010. 					        return object.Equals(f(), val[index]);

    7011. 

  7011. 					    }

    7012. 

  7012. 					}

    7013. 

  7013. 				

    7014. 

  7014. 				

    7015. 

  7015. 				public  static class Ext {

    7016. 

  7016. 				    public static void StartCapture() {

    7017. 

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

    7018. 

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

    7019. 

  7019. 				    }

    7020. 

  7020. 				

    7021. 

  7021. 				    public static void StopCapture() {

    7022. 

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

    7023. 

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

    7024. 

  7024. 				    }

    7025. 

  7025. 				

    7026. 

  7026. 				    public static bool IsIntegralOrEnum(Type type) {

    7027. 

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

    7028. 

  7028. 				            case TypeCode.Byte:

    7029. 

  7029. 				            case TypeCode.SByte:

    7030. 

  7030. 				            case TypeCode.Int16:

    7031. 

  7031. 				            case TypeCode.Int32:

    7032. 

  7032. 				            case TypeCode.Int64:

    7033. 

  7033. 				            case TypeCode.UInt16:

    7034. 

  7034. 				            case TypeCode.UInt32:

    7035. 

  7035. 				            case TypeCode.UInt64:

    7036. 

  7036. 				                return true;

    7037. 

  7037. 				            default:

    7038. 

  7038. 				                return false;

    7039. 

  7039. 				        }

    7040. 

  7040. 				    }

    7041. 

  7041. 				

    7042. 

  7042. 				    public static bool IsFloating(Type type) {

    7043. 

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

    7044. 

  7044. 				            case TypeCode.Single:

    7045. 

  7045. 				            case TypeCode.Double:

    7046. 

  7046. 				                return true;

    7047. 

  7047. 				            default:

    7048. 

  7048. 				                return false;

    7049. 

  7049. 				        }

    7050. 

  7050. 				    }

    7051. 

  7051. 				

    7052. 

  7052. 				    public static Type GetNonNullableType(Type type) {

    7053. 

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

    7054. 

  7054. 				                type.GetGenericArguments()[0] :

    7055. 

  7055. 				                type;

    7056. 

  7056. 				    }

    7057. 

  7057. 				}

    7058. 

  7058. 				

    7059. 

  7059. 			

    7060. 

  7060. 			

    7061. 

  7061. 			

    7062. 

  7062. 			public interface I

    7063. 

  7063. 			{

    7064. 

  7064. 			    void M();

    7065. 

  7065. 			}

    7066. 

  7066. 			

    7067. 

  7067. 			public  class C : IEquatable<C>, I

    7068. 

  7068. 			{

    7069. 

  7069. 			    void I.M()

    7070. 

  7070. 			    {

    7071. 

  7071. 			    }

    7072. 

  7072. 			

    7073. 

  7073. 			    public override bool Equals(object o)

    7074. 

  7074. 			    {

    7075. 

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

    7076. 

  7076. 			    }

    7077. 

  7077. 			

    7078. 

  7078. 			    public bool Equals(C c)

    7079. 

  7079. 			    {

    7080. 

  7080. 			        return c != null;

    7081. 

  7081. 			    }

    7082. 

  7082. 			

    7083. 

  7083. 			    public override int GetHashCode()

    7084. 

  7084. 			    {

    7085. 

  7085. 			        return 0;

    7086. 

  7086. 			    }

    7087. 

  7087. 			}

    7088. 

  7088. 			

    7089. 

  7089. 			public  class D : C, IEquatable<D>

    7090. 

  7090. 			{

    7091. 

  7091. 			    public int Val;

    7092. 

  7092. 			    public D()

    7093. 

  7093. 			    {

    7094. 

  7094. 			    }

    7095. 

  7095. 			    public D(int val)

    7096. 

  7096. 			    {

    7097. 

  7097. 			        Val = val;

    7098. 

  7098. 			    }

    7099. 

  7099. 			

    7100. 

  7100. 			    public override bool Equals(object o)

    7101. 

  7101. 			    {

    7102. 

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

    7103. 

  7103. 			    }

    7104. 

  7104. 			

    7105. 

  7105. 			    public bool Equals(D d)

    7106. 

  7106. 			    {

    7107. 

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

    7108. 

  7108. 			    }

    7109. 

  7109. 			

    7110. 

  7110. 			    public override int GetHashCode()

    7111. 

  7111. 			    {

    7112. 

  7112. 			        return Val;

    7113. 

  7113. 			    }

    7114. 

  7114. 			}

    7115. 

  7115. 			

    7116. 

  7116. 			public enum E

    7117. 

  7117. 			{

    7118. 

  7118. 			    A = 1, B = 2

    7119. 

  7119. 			}

    7120. 

  7120. 			

    7121. 

  7121. 			public enum El : long

    7122. 

  7122. 			{

    7123. 

  7123. 			    A, B, C

    7124. 

  7124. 			}

    7125. 

  7125. 			

    7126. 

  7126. 			public struct S : IEquatable<S>

    7127. 

  7127. 			{

    7128. 

  7128. 			    public override bool Equals(object o)

    7129. 

  7129. 			    {

    7130. 

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

    7131. 

  7131. 			    }

    7132. 

  7132. 			    public bool Equals(S other)

    7133. 

  7133. 			    {

    7134. 

  7134. 			        return true;

    7135. 

  7135. 			    }

    7136. 

  7136. 			    public override int GetHashCode()

    7137. 

  7137. 			    {

    7138. 

  7138. 			        return 0;

    7139. 

  7139. 			    }

    7140. 

  7140. 			}

    7141. 

  7141. 			

    7142. 

  7142. 			public struct Sp : IEquatable<Sp>

    7143. 

  7143. 			{

    7144. 

  7144. 			    public Sp(int i, double d)

    7145. 

  7145. 			    {

    7146. 

  7146. 			        I = i;

    7147. 

  7147. 			        D = d;

    7148. 

  7148. 			    }

    7149. 

  7149. 			

    7150. 

  7150. 			    public int I;

    7151. 

  7151. 			    public double D;

    7152. 

  7152. 			

    7153. 

  7153. 			    public override bool Equals(object o)

    7154. 

  7154. 			    {

    7155. 

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

    7156. 

  7156. 			    }

    7157. 

  7157. 			    public bool Equals(Sp other)

    7158. 

  7158. 			    {

    7159. 

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

    7160. 

  7160. 			    }

    7161. 

  7161. 			    public override int GetHashCode()

    7162. 

  7162. 			    {

    7163. 

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

    7164. 

  7164. 			    }

    7165. 

  7165. 			}

    7166. 

  7166. 			

    7167. 

  7167. 			public struct Ss : IEquatable<Ss>

    7168. 

  7168. 			{

    7169. 

  7169. 			    public Ss(S s)

    7170. 

  7170. 			    {

    7171. 

  7171. 			        Val = s;

    7172. 

  7172. 			    }

    7173. 

  7173. 			

    7174. 

  7174. 			    public S Val;

    7175. 

  7175. 			

    7176. 

  7176. 			    public override bool Equals(object o)

    7177. 

  7177. 			    {

    7178. 

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

    7179. 

  7179. 			    }

    7180. 

  7180. 			    public bool Equals(Ss other)

    7181. 

  7181. 			    {

    7182. 

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

    7183. 

  7183. 			    }

    7184. 

  7184. 			    public override int GetHashCode()

    7185. 

  7185. 			    {

    7186. 

  7186. 			        return Val.GetHashCode();

    7187. 

  7187. 			    }

    7188. 

  7188. 			}

    7189. 

  7189. 			

    7190. 

  7190. 			public struct Sc : IEquatable<Sc>

    7191. 

  7191. 			{

    7192. 

  7192. 			    public Sc(string s)

    7193. 

  7193. 			    {

    7194. 

  7194. 			        S = s;

    7195. 

  7195. 			    }

    7196. 

  7196. 			

    7197. 

  7197. 			    public string S;

    7198. 

  7198. 			

    7199. 

  7199. 			    public override bool Equals(object o)

    7200. 

  7200. 			    {

    7201. 

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

    7202. 

  7202. 			    }

    7203. 

  7203. 			    public bool Equals(Sc other)

    7204. 

  7204. 			    {

    7205. 

  7205. 			        return other.S == S;

    7206. 

  7206. 			    }

    7207. 

  7207. 			    public override int GetHashCode()

    7208. 

  7208. 			    {

    7209. 

  7209. 			        return S.GetHashCode();

    7210. 

  7210. 			    }

    7211. 

  7211. 			}

    7212. 

  7212. 			

    7213. 

  7213. 			public struct Scs : IEquatable<Scs>

    7214. 

  7214. 			{

    7215. 

  7215. 			    public Scs(string s, S val)

    7216. 

  7216. 			    {

    7217. 

  7217. 			        S = s;

    7218. 

  7218. 			        Val = val;

    7219. 

  7219. 			    }

    7220. 

  7220. 			

    7221. 

  7221. 			    public string S;

    7222. 

  7222. 			    public S Val;

    7223. 

  7223. 			

    7224. 

  7224. 			    public override bool Equals(object o)

    7225. 

  7225. 			    {

    7226. 

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

    7227. 

  7227. 			    }

    7228. 

  7228. 			    public bool Equals(Scs other)

    7229. 

  7229. 			    {

    7230. 

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

    7231. 

  7231. 			    }

    7232. 

  7232. 			    public override int GetHashCode()

    7233. 

  7233. 			    {

    7234. 

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

    7235. 

  7235. 			    }

    7236. 

  7236. 			}

    7237. 

  7237. 			

    7238. 

  7238. 		

    7239. 

  7239. 	}

    7240. 

  7240. 				

    7241. 

  7241. 				//-------- Scenario 3155

    7242. 

  7242. 				namespace Scenario3155{

    7243. 

  7243. 					

    7244. 

  7244. 					public class Test

    7245. 

  7245. 					{

    7246. 

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

    7247. 

  7247. 				    public static Expression T_ArrayIndex_E___() {

    7248. 

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

    7249. 

  7249. 				           throw new Exception();

    7250. 

  7250. 				       } else { 

    7251. 

  7251. 				           return Expression.Constant(0);

    7252. 

  7252. 				       }

    7253. 

  7253. 				    }

    7254. 

  7254. 					public     static int Main()

    7255. 

  7255. 					    {

    7256. 

  7256. 					        Ext.StartCapture();

    7257. 

  7257. 					        bool success = false;

    7258. 

  7258. 					        try

    7259. 

  7259. 					        {

    7260. 

  7260. 					            success = check_T_ArrayIndex<E>();

    7261. 

  7261. 					        }

    7262. 

  7262. 					        finally

    7263. 

  7263. 					        {

    7264. 

  7264. 					            Ext.StopCapture();

    7265. 

  7265. 					        }

    7266. 

  7266. 					        return success ? 0 : 1;

    7267. 

  7267. 					    }

    7268. 

  7268. 					

    7269. 

  7269. 					    static bool check_T_ArrayIndex<T>()

    7270. 

  7270. 					    {

    7271. 

  7271. 					        return checkEx_T_ArrayIndex<T>(null, -1) &

    7272. 

  7272. 					            checkEx_T_ArrayIndex<T>(null, 0) &

    7273. 

  7273. 					            checkEx_T_ArrayIndex<T>(null, 1) &

    7274. 

  7274. 					

    7275. 

  7275. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(0)) &

    7276. 

  7276. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(1)) &

    7277. 

  7277. 					            check_T_ArrayIndex<T>(genArrT_ArrayIndex<T>(5));

    7278. 

  7278. 					    }

    7279. 

  7279. 					

    7280. 

  7280. 					    static T[] genArrT_ArrayIndex<T>(int size)

    7281. 

  7281. 					    {

    7282. 

  7282. 					        T[] vals = new T[] { default(T) };

    7283. 

  7283. 					        T[] result = new T[size];

    7284. 

  7284. 					        for (int i = 0; i < size; i++)

    7285. 

  7285. 					        {

    7286. 

  7286. 					            result[i] = vals[i % vals.Length];

    7287. 

  7287. 					        }

    7288. 

  7288. 					        return result;

    7289. 

  7289. 					    }

    7290. 

  7290. 					

    7291. 

  7291. 					    static bool check_T_ArrayIndex<T>(T[] val)

    7292. 

  7292. 					    {

    7293. 

  7293. 					        bool success = checkEx_T_ArrayIndex<T>(val, -1);

    7294. 

  7294. 					        for (int i = 0; i < val.Length; i++)

    7295. 

  7295. 					        {

    7296. 

  7296. 					            success &= check_T_ArrayIndex<T>(val, 0);

    7297. 

  7297. 					        }

    7298. 

  7298. 					        success &= checkEx_T_ArrayIndex<T>(val, val.Length);

    7299. 

  7299. 					        return success;

    7300. 

  7300. 					    }

    7301. 

  7301. 					

    7302. 

  7302. 					    static bool checkEx_T_ArrayIndex<T>(T[] val, int index)

    7303. 

  7303. 					    {

    7304. 

  7304. 					        try

    7305. 

  7305. 					        {

    7306. 

  7306. 					            check_T_ArrayIndex<T>(val, index);

    7307. 

  7307. 					            Console.WriteLine("T_ArrayIndex[" + index + "] failed");

    7308. 

  7308. 					            return false;

    7309. 

  7309. 					        }

    7310. 

  7310. 					        catch

    7311. 

  7311. 					        {

    7312. 

  7312. 					            return true;

    7313. 

  7313. 					        }

    7314. 

  7314. 					    }

    7315. 

  7315. 					

    7316. 

  7316. 					    static bool check_T_ArrayIndex<T>(T[] val, int index)

    7317. 

  7317. 					    {

    7318. 

  7318. 					        Expression<Func<T>> e =

    7319. 

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

    7320. 

  7320. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(T[])),

    7321. 

  7321. 					                    Expression.Constant(index, typeof(int))),

    7322. 

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

    7323. 

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

    7324. 

  7324. 					        return object.Equals(f(), val[index]);

    7325. 

  7325. 					    }

    7326. 

  7326. 					}

    7327. 

  7327. 				

    7328. 

  7328. 				

    7329. 

  7329. 				public  static class Ext {

    7330. 

  7330. 				    public static void StartCapture() {

    7331. 

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

    7332. 

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

    7333. 

  7333. 				    }

    7334. 

  7334. 				

    7335. 

  7335. 				    public static void StopCapture() {

    7336. 

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

    7337. 

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

    7338. 

  7338. 				    }

    7339. 

  7339. 				

    7340. 

  7340. 				    public static bool IsIntegralOrEnum(Type type) {

    7341. 

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

    7342. 

  7342. 				            case TypeCode.Byte:

    7343. 

  7343. 				            case TypeCode.SByte:

    7344. 

  7344. 				            case TypeCode.Int16:

    7345. 

  7345. 				            case TypeCode.Int32:

    7346. 

  7346. 				            case TypeCode.Int64:

    7347. 

  7347. 				            case TypeCode.UInt16:

    7348. 

  7348. 				            case TypeCode.UInt32:

    7349. 

  7349. 				            case TypeCode.UInt64:

    7350. 

  7350. 				                return true;

    7351. 

  7351. 				            default:

    7352. 

  7352. 				                return false;

    7353. 

  7353. 				        }

    7354. 

  7354. 				    }

    7355. 

  7355. 				

    7356. 

  7356. 				    public static bool IsFloating(Type type) {

    7357. 

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

    7358. 

  7358. 				            case TypeCode.Single:

    7359. 

  7359. 				            case TypeCode.Double:

    7360. 

  7360. 				                return true;

    7361. 

  7361. 				            default:

    7362. 

  7362. 				                return false;

    7363. 

  7363. 				        }

    7364. 

  7364. 				    }

    7365. 

  7365. 				

    7366. 

  7366. 				    public static Type GetNonNullableType(Type type) {

    7367. 

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

    7368. 

  7368. 				                type.GetGenericArguments()[0] :

    7369. 

  7369. 				                type;

    7370. 

  7370. 				    }

    7371. 

  7371. 				}

    7372. 

  7372. 				

    7373. 

  7373. 			

    7374. 

  7374. 			

    7375. 

  7375. 			

    7376. 

  7376. 			public interface I

    7377. 

  7377. 			{

    7378. 

  7378. 			    void M();

    7379. 

  7379. 			}

    7380. 

  7380. 			

    7381. 

  7381. 			public  class C : IEquatable<C>, I

    7382. 

  7382. 			{

    7383. 

  7383. 			    void I.M()

    7384. 

  7384. 			    {

    7385. 

  7385. 			    }

    7386. 

  7386. 			

    7387. 

  7387. 			    public override bool Equals(object o)

    7388. 

  7388. 			    {

    7389. 

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

    7390. 

  7390. 			    }

    7391. 

  7391. 			

    7392. 

  7392. 			    public bool Equals(C c)

    7393. 

  7393. 			    {

    7394. 

  7394. 			        return c != null;

    7395. 

  7395. 			    }

    7396. 

  7396. 			

    7397. 

  7397. 			    public override int GetHashCode()

    7398. 

  7398. 			    {

    7399. 

  7399. 			        return 0;

    7400. 

  7400. 			    }

    7401. 

  7401. 			}

    7402. 

  7402. 			

    7403. 

  7403. 			public  class D : C, IEquatable<D>

    7404. 

  7404. 			{

    7405. 

  7405. 			    public int Val;

    7406. 

  7406. 			    public D()

    7407. 

  7407. 			    {

    7408. 

  7408. 			    }

    7409. 

  7409. 			    public D(int val)

    7410. 

  7410. 			    {

    7411. 

  7411. 			        Val = val;

    7412. 

  7412. 			    }

    7413. 

  7413. 			

    7414. 

  7414. 			    public override bool Equals(object o)

    7415. 

  7415. 			    {

    7416. 

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

    7417. 

  7417. 			    }

    7418. 

  7418. 			

    7419. 

  7419. 			    public bool Equals(D d)

    7420. 

  7420. 			    {

    7421. 

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

    7422. 

  7422. 			    }

    7423. 

  7423. 			

    7424. 

  7424. 			    public override int GetHashCode()

    7425. 

  7425. 			    {

    7426. 

  7426. 			        return Val;

    7427. 

  7427. 			    }

    7428. 

  7428. 			}

    7429. 

  7429. 			

    7430. 

  7430. 			public enum E

    7431. 

  7431. 			{

    7432. 

  7432. 			    A = 1, B = 2

    7433. 

  7433. 			}

    7434. 

  7434. 			

    7435. 

  7435. 			public enum El : long

    7436. 

  7436. 			{

    7437. 

  7437. 			    A, B, C

    7438. 

  7438. 			}

    7439. 

  7439. 			

    7440. 

  7440. 			public struct S : IEquatable<S>

    7441. 

  7441. 			{

    7442. 

  7442. 			    public override bool Equals(object o)

    7443. 

  7443. 			    {

    7444. 

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

    7445. 

  7445. 			    }

    7446. 

  7446. 			    public bool Equals(S other)

    7447. 

  7447. 			    {

    7448. 

  7448. 			        return true;

    7449. 

  7449. 			    }

    7450. 

  7450. 			    public override int GetHashCode()

    7451. 

  7451. 			    {

    7452. 

  7452. 			        return 0;

    7453. 

  7453. 			    }

    7454. 

  7454. 			}

    7455. 

  7455. 			

    7456. 

  7456. 			public struct Sp : IEquatable<Sp>

    7457. 

  7457. 			{

    7458. 

  7458. 			    public Sp(int i, double d)

    7459. 

  7459. 			    {

    7460. 

  7460. 			        I = i;

    7461. 

  7461. 			        D = d;

    7462. 

  7462. 			    }

    7463. 

  7463. 			

    7464. 

  7464. 			    public int I;

    7465. 

  7465. 			    public double D;

    7466. 

  7466. 			

    7467. 

  7467. 			    public override bool Equals(object o)

    7468. 

  7468. 			    {

    7469. 

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

    7470. 

  7470. 			    }

    7471. 

  7471. 			    public bool Equals(Sp other)

    7472. 

  7472. 			    {

    7473. 

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

    7474. 

  7474. 			    }

    7475. 

  7475. 			    public override int GetHashCode()

    7476. 

  7476. 			    {

    7477. 

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

    7478. 

  7478. 			    }

    7479. 

  7479. 			}

    7480. 

  7480. 			

    7481. 

  7481. 			public struct Ss : IEquatable<Ss>

    7482. 

  7482. 			{

    7483. 

  7483. 			    public Ss(S s)

    7484. 

  7484. 			    {

    7485. 

  7485. 			        Val = s;

    7486. 

  7486. 			    }

    7487. 

  7487. 			

    7488. 

  7488. 			    public S Val;

    7489. 

  7489. 			

    7490. 

  7490. 			    public override bool Equals(object o)

    7491. 

  7491. 			    {

    7492. 

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

    7493. 

  7493. 			    }

    7494. 

  7494. 			    public bool Equals(Ss other)

    7495. 

  7495. 			    {

    7496. 

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

    7497. 

  7497. 			    }

    7498. 

  7498. 			    public override int GetHashCode()

    7499. 

  7499. 			    {

    7500. 

  7500. 			        return Val.GetHashCode();

    7501. 

  7501. 			    }

    7502. 

  7502. 			}

    7503. 

  7503. 			

    7504. 

  7504. 			public struct Sc : IEquatable<Sc>

    7505. 

  7505. 			{

    7506. 

  7506. 			    public Sc(string s)

    7507. 

  7507. 			    {

    7508. 

  7508. 			        S = s;

    7509. 

  7509. 			    }

    7510. 

  7510. 			

    7511. 

  7511. 			    public string S;

    7512. 

  7512. 			

    7513. 

  7513. 			    public override bool Equals(object o)

    7514. 

  7514. 			    {

    7515. 

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

    7516. 

  7516. 			    }

    7517. 

  7517. 			    public bool Equals(Sc other)

    7518. 

  7518. 			    {

    7519. 

  7519. 			        return other.S == S;

    7520. 

  7520. 			    }

    7521. 

  7521. 			    public override int GetHashCode()

    7522. 

  7522. 			    {

    7523. 

  7523. 			        return S.GetHashCode();

    7524. 

  7524. 			    }

    7525. 

  7525. 			}

    7526. 

  7526. 			

    7527. 

  7527. 			public struct Scs : IEquatable<Scs>

    7528. 

  7528. 			{

    7529. 

  7529. 			    public Scs(string s, S val)

    7530. 

  7530. 			    {

    7531. 

  7531. 			        S = s;

    7532. 

  7532. 			        Val = val;

    7533. 

  7533. 			    }

    7534. 

  7534. 			

    7535. 

  7535. 			    public string S;

    7536. 

  7536. 			    public S Val;

    7537. 

  7537. 			

    7538. 

  7538. 			    public override bool Equals(object o)

    7539. 

  7539. 			    {

    7540. 

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

    7541. 

  7541. 			    }

    7542. 

  7542. 			    public bool Equals(Scs other)

    7543. 

  7543. 			    {

    7544. 

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

    7545. 

  7545. 			    }

    7546. 

  7546. 			    public override int GetHashCode()

    7547. 

  7547. 			    {

    7548. 

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

    7549. 

  7549. 			    }

    7550. 

  7550. 			}

    7551. 

  7551. 			

    7552. 

  7552. 		

    7553. 

  7553. 	}

    7554. 

  7554. 				

    7555. 

  7555. 				//-------- Scenario 3156

    7556. 

  7556. 				namespace Scenario3156{

    7557. 

  7557. 					

    7558. 

  7558. 					public class Test

    7559. 

  7559. 					{

    7560. 

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

    7561. 

  7561. 				    public static Expression Tc_ArrayIndex_object___() {

    7562. 

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

    7563. 

  7563. 				           throw new Exception();

    7564. 

  7564. 				       } else { 

    7565. 

  7565. 				           return Expression.Constant(0);

    7566. 

  7566. 				       }

    7567. 

  7567. 				    }

    7568. 

  7568. 					public     static int Main()

    7569. 

  7569. 					    {

    7570. 

  7570. 					        Ext.StartCapture();

    7571. 

  7571. 					        bool success = false;

    7572. 

  7572. 					        try

    7573. 

  7573. 					        {

    7574. 

  7574. 					            success = check_Tc_ArrayIndex<object>();

    7575. 

  7575. 					        }

    7576. 

  7576. 					        finally

    7577. 

  7577. 					        {

    7578. 

  7578. 					            Ext.StopCapture();

    7579. 

  7579. 					        }

    7580. 

  7580. 					        return success ? 0 : 1;

    7581. 

  7581. 					    }

    7582. 

  7582. 					

    7583. 

  7583. 					    static bool check_Tc_ArrayIndex<Tc>() where Tc : class

    7584. 

  7584. 					    {

    7585. 

  7585. 					        return checkEx_Tc_ArrayIndex<Tc>(null, -1) &

    7586. 

  7586. 					            checkEx_Tc_ArrayIndex<Tc>(null, 0) &

    7587. 

  7587. 					            checkEx_Tc_ArrayIndex<Tc>(null, 1) &

    7588. 

  7588. 					

    7589. 

  7589. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(0)) &

    7590. 

  7590. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(1)) &

    7591. 

  7591. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(5));

    7592. 

  7592. 					    }

    7593. 

  7593. 					

    7594. 

  7594. 					    static Tc[] genArrTc_ArrayIndex<Tc>(int size) where Tc : class

    7595. 

  7595. 					    {

    7596. 

  7596. 					        Tc[] vals = new Tc[] { null, default(Tc) };

    7597. 

  7597. 					        Tc[] result = new Tc[size];

    7598. 

  7598. 					        for (int i = 0; i < size; i++)

    7599. 

  7599. 					        {

    7600. 

  7600. 					            result[i] = vals[i % vals.Length];

    7601. 

  7601. 					        }

    7602. 

  7602. 					        return result;

    7603. 

  7603. 					    }

    7604. 

  7604. 					

    7605. 

  7605. 					    static bool check_Tc_ArrayIndex<Tc>(Tc[] val) where Tc : class

    7606. 

  7606. 					    {

    7607. 

  7607. 					        bool success = checkEx_Tc_ArrayIndex<Tc>(val, -1);

    7608. 

  7608. 					        for (int i = 0; i < val.Length; i++)

    7609. 

  7609. 					        {

    7610. 

  7610. 					            success &= check_Tc_ArrayIndex<Tc>(val, 0);

    7611. 

  7611. 					        }

    7612. 

  7612. 					        success &= checkEx_Tc_ArrayIndex<Tc>(val, val.Length);

    7613. 

  7613. 					        return success;

    7614. 

  7614. 					    }

    7615. 

  7615. 					

    7616. 

  7616. 					    static bool checkEx_Tc_ArrayIndex<Tc>(Tc[] val, int index) where Tc : class

    7617. 

  7617. 					    {

    7618. 

  7618. 					        try

    7619. 

  7619. 					        {

    7620. 

  7620. 					            check_Tc_ArrayIndex<Tc>(val, index);

    7621. 

  7621. 					            Console.WriteLine("Tc_ArrayIndex[" + index + "] failed");

    7622. 

  7622. 					            return false;

    7623. 

  7623. 					        }

    7624. 

  7624. 					        catch

    7625. 

  7625. 					        {

    7626. 

  7626. 					            return true;

    7627. 

  7627. 					        }

    7628. 

  7628. 					    }

    7629. 

  7629. 					

    7630. 

  7630. 					    static bool check_Tc_ArrayIndex<Tc>(Tc[] val, int index) where Tc : class

    7631. 

  7631. 					    {

    7632. 

  7632. 					        Expression<Func<Tc>> e =

    7633. 

  7633. 					            Expression.Lambda<Func<Tc>>(

    7634. 

  7634. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Tc[])),

    7635. 

  7635. 					                    Expression.Constant(index, typeof(int))),

    7636. 

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

    7637. 

  7637. 					        Func<Tc> f = e.Compile();

    7638. 

  7638. 					        return object.Equals(f(), val[index]);

    7639. 

  7639. 					    }

    7640. 

  7640. 					}

    7641. 

  7641. 				

    7642. 

  7642. 				

    7643. 

  7643. 				public  static class Ext {

    7644. 

  7644. 				    public static void StartCapture() {

    7645. 

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

    7646. 

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

    7647. 

  7647. 				    }

    7648. 

  7648. 				

    7649. 

  7649. 				    public static void StopCapture() {

    7650. 

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

    7651. 

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

    7652. 

  7652. 				    }

    7653. 

  7653. 				

    7654. 

  7654. 				    public static bool IsIntegralOrEnum(Type type) {

    7655. 

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

    7656. 

  7656. 				            case TypeCode.Byte:

    7657. 

  7657. 				            case TypeCode.SByte:

    7658. 

  7658. 				            case TypeCode.Int16:

    7659. 

  7659. 				            case TypeCode.Int32:

    7660. 

  7660. 				            case TypeCode.Int64:

    7661. 

  7661. 				            case TypeCode.UInt16:

    7662. 

  7662. 				            case TypeCode.UInt32:

    7663. 

  7663. 				            case TypeCode.UInt64:

    7664. 

  7664. 				                return true;

    7665. 

  7665. 				            default:

    7666. 

  7666. 				                return false;

    7667. 

  7667. 				        }

    7668. 

  7668. 				    }

    7669. 

  7669. 				

    7670. 

  7670. 				    public static bool IsFloating(Type type) {

    7671. 

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

    7672. 

  7672. 				            case TypeCode.Single:

    7673. 

  7673. 				            case TypeCode.Double:

    7674. 

  7674. 				                return true;

    7675. 

  7675. 				            default:

    7676. 

  7676. 				                return false;

    7677. 

  7677. 				        }

    7678. 

  7678. 				    }

    7679. 

  7679. 				

    7680. 

  7680. 				    public static Type GetNonNullableType(Type type) {

    7681. 

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

    7682. 

  7682. 				                type.GetGenericArguments()[0] :

    7683. 

  7683. 				                type;

    7684. 

  7684. 				    }

    7685. 

  7685. 				}

    7686. 

  7686. 				

    7687. 

  7687. 			

    7688. 

  7688. 			

    7689. 

  7689. 			

    7690. 

  7690. 			public interface I

    7691. 

  7691. 			{

    7692. 

  7692. 			    void M();

    7693. 

  7693. 			}

    7694. 

  7694. 			

    7695. 

  7695. 			public  class C : IEquatable<C>, I

    7696. 

  7696. 			{

    7697. 

  7697. 			    void I.M()

    7698. 

  7698. 			    {

    7699. 

  7699. 			    }

    7700. 

  7700. 			

    7701. 

  7701. 			    public override bool Equals(object o)

    7702. 

  7702. 			    {

    7703. 

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

    7704. 

  7704. 			    }

    7705. 

  7705. 			

    7706. 

  7706. 			    public bool Equals(C c)

    7707. 

  7707. 			    {

    7708. 

  7708. 			        return c != null;

    7709. 

  7709. 			    }

    7710. 

  7710. 			

    7711. 

  7711. 			    public override int GetHashCode()

    7712. 

  7712. 			    {

    7713. 

  7713. 			        return 0;

    7714. 

  7714. 			    }

    7715. 

  7715. 			}

    7716. 

  7716. 			

    7717. 

  7717. 			public  class D : C, IEquatable<D>

    7718. 

  7718. 			{

    7719. 

  7719. 			    public int Val;

    7720. 

  7720. 			    public D()

    7721. 

  7721. 			    {

    7722. 

  7722. 			    }

    7723. 

  7723. 			    public D(int val)

    7724. 

  7724. 			    {

    7725. 

  7725. 			        Val = val;

    7726. 

  7726. 			    }

    7727. 

  7727. 			

    7728. 

  7728. 			    public override bool Equals(object o)

    7729. 

  7729. 			    {

    7730. 

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

    7731. 

  7731. 			    }

    7732. 

  7732. 			

    7733. 

  7733. 			    public bool Equals(D d)

    7734. 

  7734. 			    {

    7735. 

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

    7736. 

  7736. 			    }

    7737. 

  7737. 			

    7738. 

  7738. 			    public override int GetHashCode()

    7739. 

  7739. 			    {

    7740. 

  7740. 			        return Val;

    7741. 

  7741. 			    }

    7742. 

  7742. 			}

    7743. 

  7743. 			

    7744. 

  7744. 			public enum E

    7745. 

  7745. 			{

    7746. 

  7746. 			    A = 1, B = 2

    7747. 

  7747. 			}

    7748. 

  7748. 			

    7749. 

  7749. 			public enum El : long

    7750. 

  7750. 			{

    7751. 

  7751. 			    A, B, C

    7752. 

  7752. 			}

    7753. 

  7753. 			

    7754. 

  7754. 			public struct S : IEquatable<S>

    7755. 

  7755. 			{

    7756. 

  7756. 			    public override bool Equals(object o)

    7757. 

  7757. 			    {

    7758. 

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

    7759. 

  7759. 			    }

    7760. 

  7760. 			    public bool Equals(S other)

    7761. 

  7761. 			    {

    7762. 

  7762. 			        return true;

    7763. 

  7763. 			    }

    7764. 

  7764. 			    public override int GetHashCode()

    7765. 

  7765. 			    {

    7766. 

  7766. 			        return 0;

    7767. 

  7767. 			    }

    7768. 

  7768. 			}

    7769. 

  7769. 			

    7770. 

  7770. 			public struct Sp : IEquatable<Sp>

    7771. 

  7771. 			{

    7772. 

  7772. 			    public Sp(int i, double d)

    7773. 

  7773. 			    {

    7774. 

  7774. 			        I = i;

    7775. 

  7775. 			        D = d;

    7776. 

  7776. 			    }

    7777. 

  7777. 			

    7778. 

  7778. 			    public int I;

    7779. 

  7779. 			    public double D;

    7780. 

  7780. 			

    7781. 

  7781. 			    public override bool Equals(object o)

    7782. 

  7782. 			    {

    7783. 

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

    7784. 

  7784. 			    }

    7785. 

  7785. 			    public bool Equals(Sp other)

    7786. 

  7786. 			    {

    7787. 

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

    7788. 

  7788. 			    }

    7789. 

  7789. 			    public override int GetHashCode()

    7790. 

  7790. 			    {

    7791. 

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

    7792. 

  7792. 			    }

    7793. 

  7793. 			}

    7794. 

  7794. 			

    7795. 

  7795. 			public struct Ss : IEquatable<Ss>

    7796. 

  7796. 			{

    7797. 

  7797. 			    public Ss(S s)

    7798. 

  7798. 			    {

    7799. 

  7799. 			        Val = s;

    7800. 

  7800. 			    }

    7801. 

  7801. 			

    7802. 

  7802. 			    public S Val;

    7803. 

  7803. 			

    7804. 

  7804. 			    public override bool Equals(object o)

    7805. 

  7805. 			    {

    7806. 

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

    7807. 

  7807. 			    }

    7808. 

  7808. 			    public bool Equals(Ss other)

    7809. 

  7809. 			    {

    7810. 

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

    7811. 

  7811. 			    }

    7812. 

  7812. 			    public override int GetHashCode()

    7813. 

  7813. 			    {

    7814. 

  7814. 			        return Val.GetHashCode();

    7815. 

  7815. 			    }

    7816. 

  7816. 			}

    7817. 

  7817. 			

    7818. 

  7818. 			public struct Sc : IEquatable<Sc>

    7819. 

  7819. 			{

    7820. 

  7820. 			    public Sc(string s)

    7821. 

  7821. 			    {

    7822. 

  7822. 			        S = s;

    7823. 

  7823. 			    }

    7824. 

  7824. 			

    7825. 

  7825. 			    public string S;

    7826. 

  7826. 			

    7827. 

  7827. 			    public override bool Equals(object o)

    7828. 

  7828. 			    {

    7829. 

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

    7830. 

  7830. 			    }

    7831. 

  7831. 			    public bool Equals(Sc other)

    7832. 

  7832. 			    {

    7833. 

  7833. 			        return other.S == S;

    7834. 

  7834. 			    }

    7835. 

  7835. 			    public override int GetHashCode()

    7836. 

  7836. 			    {

    7837. 

  7837. 			        return S.GetHashCode();

    7838. 

  7838. 			    }

    7839. 

  7839. 			}

    7840. 

  7840. 			

    7841. 

  7841. 			public struct Scs : IEquatable<Scs>

    7842. 

  7842. 			{

    7843. 

  7843. 			    public Scs(string s, S val)

    7844. 

  7844. 			    {

    7845. 

  7845. 			        S = s;

    7846. 

  7846. 			        Val = val;

    7847. 

  7847. 			    }

    7848. 

  7848. 			

    7849. 

  7849. 			    public string S;

    7850. 

  7850. 			    public S Val;

    7851. 

  7851. 			

    7852. 

  7852. 			    public override bool Equals(object o)

    7853. 

  7853. 			    {

    7854. 

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

    7855. 

  7855. 			    }

    7856. 

  7856. 			    public bool Equals(Scs other)

    7857. 

  7857. 			    {

    7858. 

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

    7859. 

  7859. 			    }

    7860. 

  7860. 			    public override int GetHashCode()

    7861. 

  7861. 			    {

    7862. 

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

    7863. 

  7863. 			    }

    7864. 

  7864. 			}

    7865. 

  7865. 			

    7866. 

  7866. 		

    7867. 

  7867. 	}

    7868. 

  7868. 				

    7869. 

  7869. 				//-------- Scenario 3157

    7870. 

  7870. 				namespace Scenario3157{

    7871. 

  7871. 					

    7872. 

  7872. 					public class Test

    7873. 

  7873. 					{

    7874. 

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

    7875. 

  7875. 				    public static Expression Tc_ArrayIndex_C___() {

    7876. 

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

    7877. 

  7877. 				           throw new Exception();

    7878. 

  7878. 				       } else { 

    7879. 

  7879. 				           return Expression.Constant(0);

    7880. 

  7880. 				       }

    7881. 

  7881. 				    }

    7882. 

  7882. 					public     static int Main()

    7883. 

  7883. 					    {

    7884. 

  7884. 					        Ext.StartCapture();

    7885. 

  7885. 					        bool success = false;

    7886. 

  7886. 					        try

    7887. 

  7887. 					        {

    7888. 

  7888. 					            success = check_Tc_ArrayIndex<C>();

    7889. 

  7889. 					        }

    7890. 

  7890. 					        finally

    7891. 

  7891. 					        {

    7892. 

  7892. 					            Ext.StopCapture();

    7893. 

  7893. 					        }

    7894. 

  7894. 					        return success ? 0 : 1;

    7895. 

  7895. 					    }

    7896. 

  7896. 					

    7897. 

  7897. 					    static bool check_Tc_ArrayIndex<Tc>() where Tc : class

    7898. 

  7898. 					    {

    7899. 

  7899. 					        return checkEx_Tc_ArrayIndex<Tc>(null, -1) &

    7900. 

  7900. 					            checkEx_Tc_ArrayIndex<Tc>(null, 0) &

    7901. 

  7901. 					            checkEx_Tc_ArrayIndex<Tc>(null, 1) &

    7902. 

  7902. 					

    7903. 

  7903. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(0)) &

    7904. 

  7904. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(1)) &

    7905. 

  7905. 					            check_Tc_ArrayIndex<Tc>(genArrTc_ArrayIndex<Tc>(5));

    7906. 

  7906. 					    }

    7907. 

  7907. 					

    7908. 

  7908. 					    static Tc[] genArrTc_ArrayIndex<Tc>(int size) where Tc : class

    7909. 

  7909. 					    {

    7910. 

  7910. 					        Tc[] vals = new Tc[] { null, default(Tc) };

    7911. 

  7911. 					        Tc[] result = new Tc[size];

    7912. 

  7912. 					        for (int i = 0; i < size; i++)

    7913. 

  7913. 					        {

    7914. 

  7914. 					            result[i] = vals[i % vals.Length];

    7915. 

  7915. 					        }

    7916. 

  7916. 					        return result;

    7917. 

  7917. 					    }

    7918. 

  7918. 					

    7919. 

  7919. 					    static bool check_Tc_ArrayIndex<Tc>(Tc[] val) where Tc : class

    7920. 

  7920. 					    {

    7921. 

  7921. 					        bool success = checkEx_Tc_ArrayIndex<Tc>(val, -1);

    7922. 

  7922. 					        for (int i = 0; i < val.Length; i++)

    7923. 

  7923. 					        {

    7924. 

  7924. 					            success &= check_Tc_ArrayIndex<Tc>(val, 0);

    7925. 

  7925. 					        }

    7926. 

  7926. 					        success &= checkEx_Tc_ArrayIndex<Tc>(val, val.Length);

    7927. 

  7927. 					        return success;

    7928. 

  7928. 					    }

    7929. 

  7929. 					

    7930. 

  7930. 					    static bool checkEx_Tc_ArrayIndex<Tc>(Tc[] val, int index) where Tc : class

    7931. 

  7931. 					    {

    7932. 

  7932. 					        try

    7933. 

  7933. 					        {

    7934. 

  7934. 					            check_Tc_ArrayIndex<Tc>(val, index);

    7935. 

  7935. 					            Console.WriteLine("Tc_ArrayIndex[" + index + "] failed");

    7936. 

  7936. 					            return false;

    7937. 

  7937. 					        }

    7938. 

  7938. 					        catch

    7939. 

  7939. 					        {

    7940. 

  7940. 					            return true;

    7941. 

  7941. 					        }

    7942. 

  7942. 					    }

    7943. 

  7943. 					

    7944. 

  7944. 					    static bool check_Tc_ArrayIndex<Tc>(Tc[] val, int index) where Tc : class

    7945. 

  7945. 					    {

    7946. 

  7946. 					        Expression<Func<Tc>> e =

    7947. 

  7947. 					            Expression.Lambda<Func<Tc>>(

    7948. 

  7948. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Tc[])),

    7949. 

  7949. 					                    Expression.Constant(index, typeof(int))),

    7950. 

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

    7951. 

  7951. 					        Func<Tc> f = e.Compile();

    7952. 

  7952. 					        return object.Equals(f(), val[index]);

    7953. 

  7953. 					    }

    7954. 

  7954. 					}

    7955. 

  7955. 				

    7956. 

  7956. 				

    7957. 

  7957. 				public  static class Ext {

    7958. 

  7958. 				    public static void StartCapture() {

    7959. 

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

    7960. 

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

    7961. 

  7961. 				    }

    7962. 

  7962. 				

    7963. 

  7963. 				    public static void StopCapture() {

    7964. 

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

    7965. 

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

    7966. 

  7966. 				    }

    7967. 

  7967. 				

    7968. 

  7968. 				    public static bool IsIntegralOrEnum(Type type) {

    7969. 

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

    7970. 

  7970. 				            case TypeCode.Byte:

    7971. 

  7971. 				            case TypeCode.SByte:

    7972. 

  7972. 				            case TypeCode.Int16:

    7973. 

  7973. 				            case TypeCode.Int32:

    7974. 

  7974. 				            case TypeCode.Int64:

    7975. 

  7975. 				            case TypeCode.UInt16:

    7976. 

  7976. 				            case TypeCode.UInt32:

    7977. 

  7977. 				            case TypeCode.UInt64:

    7978. 

  7978. 				                return true;

    7979. 

  7979. 				            default:

    7980. 

  7980. 				                return false;

    7981. 

  7981. 				        }

    7982. 

  7982. 				    }

    7983. 

  7983. 				

    7984. 

  7984. 				    public static bool IsFloating(Type type) {

    7985. 

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

    7986. 

  7986. 				            case TypeCode.Single:

    7987. 

  7987. 				            case TypeCode.Double:

    7988. 

  7988. 				                return true;

    7989. 

  7989. 				            default:

    7990. 

  7990. 				                return false;

    7991. 

  7991. 				        }

    7992. 

  7992. 				    }

    7993. 

  7993. 				

    7994. 

  7994. 				    public static Type GetNonNullableType(Type type) {

    7995. 

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

    7996. 

  7996. 				                type.GetGenericArguments()[0] :

    7997. 

  7997. 				                type;

    7998. 

  7998. 				    }

    7999. 

  7999. 				}

    8000. 

  8000. 				

    8001. 

  8001. 			

    8002. 

  8002. 			

    8003. 

  8003. 			

    8004. 

  8004. 			public interface I

    8005. 

  8005. 			{

    8006. 

  8006. 			    void M();

    8007. 

  8007. 			}

    8008. 

  8008. 			

    8009. 

  8009. 			public  class C : IEquatable<C>, I

    8010. 

  8010. 			{

    8011. 

  8011. 			    void I.M()

    8012. 

  8012. 			    {

    8013. 

  8013. 			    }

    8014. 

  8014. 			

    8015. 

  8015. 			    public override bool Equals(object o)

    8016. 

  8016. 			    {

    8017. 

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

    8018. 

  8018. 			    }

    8019. 

  8019. 			

    8020. 

  8020. 			    public bool Equals(C c)

    8021. 

  8021. 			    {

    8022. 

  8022. 			        return c != null;

    8023. 

  8023. 			    }

    8024. 

  8024. 			

    8025. 

  8025. 			    public override int GetHashCode()

    8026. 

  8026. 			    {

    8027. 

  8027. 			        return 0;

    8028. 

  8028. 			    }

    8029. 

  8029. 			}

    8030. 

  8030. 			

    8031. 

  8031. 			public  class D : C, IEquatable<D>

    8032. 

  8032. 			{

    8033. 

  8033. 			    public int Val;

    8034. 

  8034. 			    public D()

    8035. 

  8035. 			    {

    8036. 

  8036. 			    }

    8037. 

  8037. 			    public D(int val)

    8038. 

  8038. 			    {

    8039. 

  8039. 			        Val = val;

    8040. 

  8040. 			    }

    8041. 

  8041. 			

    8042. 

  8042. 			    public override bool Equals(object o)

    8043. 

  8043. 			    {

    8044. 

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

    8045. 

  8045. 			    }

    8046. 

  8046. 			

    8047. 

  8047. 			    public bool Equals(D d)

    8048. 

  8048. 			    {

    8049. 

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

    8050. 

  8050. 			    }

    8051. 

  8051. 			

    8052. 

  8052. 			    public override int GetHashCode()

    8053. 

  8053. 			    {

    8054. 

  8054. 			        return Val;

    8055. 

  8055. 			    }

    8056. 

  8056. 			}

    8057. 

  8057. 			

    8058. 

  8058. 			public enum E

    8059. 

  8059. 			{

    8060. 

  8060. 			    A = 1, B = 2

    8061. 

  8061. 			}

    8062. 

  8062. 			

    8063. 

  8063. 			public enum El : long

    8064. 

  8064. 			{

    8065. 

  8065. 			    A, B, C

    8066. 

  8066. 			}

    8067. 

  8067. 			

    8068. 

  8068. 			public struct S : IEquatable<S>

    8069. 

  8069. 			{

    8070. 

  8070. 			    public override bool Equals(object o)

    8071. 

  8071. 			    {

    8072. 

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

    8073. 

  8073. 			    }

    8074. 

  8074. 			    public bool Equals(S other)

    8075. 

  8075. 			    {

    8076. 

  8076. 			        return true;

    8077. 

  8077. 			    }

    8078. 

  8078. 			    public override int GetHashCode()

    8079. 

  8079. 			    {

    8080. 

  8080. 			        return 0;

    8081. 

  8081. 			    }

    8082. 

  8082. 			}

    8083. 

  8083. 			

    8084. 

  8084. 			public struct Sp : IEquatable<Sp>

    8085. 

  8085. 			{

    8086. 

  8086. 			    public Sp(int i, double d)

    8087. 

  8087. 			    {

    8088. 

  8088. 			        I = i;

    8089. 

  8089. 			        D = d;

    8090. 

  8090. 			    }

    8091. 

  8091. 			

    8092. 

  8092. 			    public int I;

    8093. 

  8093. 			    public double D;

    8094. 

  8094. 			

    8095. 

  8095. 			    public override bool Equals(object o)

    8096. 

  8096. 			    {

    8097. 

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

    8098. 

  8098. 			    }

    8099. 

  8099. 			    public bool Equals(Sp other)

    8100. 

  8100. 			    {

    8101. 

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

    8102. 

  8102. 			    }

    8103. 

  8103. 			    public override int GetHashCode()

    8104. 

  8104. 			    {

    8105. 

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

    8106. 

  8106. 			    }

    8107. 

  8107. 			}

    8108. 

  8108. 			

    8109. 

  8109. 			public struct Ss : IEquatable<Ss>

    8110. 

  8110. 			{

    8111. 

  8111. 			    public Ss(S s)

    8112. 

  8112. 			    {

    8113. 

  8113. 			        Val = s;

    8114. 

  8114. 			    }

    8115. 

  8115. 			

    8116. 

  8116. 			    public S Val;

    8117. 

  8117. 			

    8118. 

  8118. 			    public override bool Equals(object o)

    8119. 

  8119. 			    {

    8120. 

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

    8121. 

  8121. 			    }

    8122. 

  8122. 			    public bool Equals(Ss other)

    8123. 

  8123. 			    {

    8124. 

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

    8125. 

  8125. 			    }

    8126. 

  8126. 			    public override int GetHashCode()

    8127. 

  8127. 			    {

    8128. 

  8128. 			        return Val.GetHashCode();

    8129. 

  8129. 			    }

    8130. 

  8130. 			}

    8131. 

  8131. 			

    8132. 

  8132. 			public struct Sc : IEquatable<Sc>

    8133. 

  8133. 			{

    8134. 

  8134. 			    public Sc(string s)

    8135. 

  8135. 			    {

    8136. 

  8136. 			        S = s;

    8137. 

  8137. 			    }

    8138. 

  8138. 			

    8139. 

  8139. 			    public string S;

    8140. 

  8140. 			

    8141. 

  8141. 			    public override bool Equals(object o)

    8142. 

  8142. 			    {

    8143. 

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

    8144. 

  8144. 			    }

    8145. 

  8145. 			    public bool Equals(Sc other)

    8146. 

  8146. 			    {

    8147. 

  8147. 			        return other.S == S;

    8148. 

  8148. 			    }

    8149. 

  8149. 			    public override int GetHashCode()

    8150. 

  8150. 			    {

    8151. 

  8151. 			        return S.GetHashCode();

    8152. 

  8152. 			    }

    8153. 

  8153. 			}

    8154. 

  8154. 			

    8155. 

  8155. 			public struct Scs : IEquatable<Scs>

    8156. 

  8156. 			{

    8157. 

  8157. 			    public Scs(string s, S val)

    8158. 

  8158. 			    {

    8159. 

  8159. 			        S = s;

    8160. 

  8160. 			        Val = val;

    8161. 

  8161. 			    }

    8162. 

  8162. 			

    8163. 

  8163. 			    public string S;

    8164. 

  8164. 			    public S Val;

    8165. 

  8165. 			

    8166. 

  8166. 			    public override bool Equals(object o)

    8167. 

  8167. 			    {

    8168. 

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

    8169. 

  8169. 			    }

    8170. 

  8170. 			    public bool Equals(Scs other)

    8171. 

  8171. 			    {

    8172. 

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

    8173. 

  8173. 			    }

    8174. 

  8174. 			    public override int GetHashCode()

    8175. 

  8175. 			    {

    8176. 

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

    8177. 

  8177. 			    }

    8178. 

  8178. 			}

    8179. 

  8179. 			

    8180. 

  8180. 		

    8181. 

  8181. 	}

    8182. 

  8182. 				

    8183. 

  8183. 				//-------- Scenario 3158

    8184. 

  8184. 				namespace Scenario3158{

    8185. 

  8185. 					

    8186. 

  8186. 					public class Test

    8187. 

  8187. 					{

    8188. 

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

    8189. 

  8189. 				    public static Expression Tcn_ArrayIndex_object___() {

    8190. 

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

    8191. 

  8191. 				           throw new Exception();

    8192. 

  8192. 				       } else { 

    8193. 

  8193. 				           return Expression.Constant(0);

    8194. 

  8194. 				       }

    8195. 

  8195. 				    }

    8196. 

  8196. 					public     static int Main()

    8197. 

  8197. 					    {

    8198. 

  8198. 					        Ext.StartCapture();

    8199. 

  8199. 					        bool success = false;

    8200. 

  8200. 					        try

    8201. 

  8201. 					        {

    8202. 

  8202. 					            success = check_Tcn_ArrayIndex<object>();

    8203. 

  8203. 					        }

    8204. 

  8204. 					        finally

    8205. 

  8205. 					        {

    8206. 

  8206. 					            Ext.StopCapture();

    8207. 

  8207. 					        }

    8208. 

  8208. 					        return success ? 0 : 1;

    8209. 

  8209. 					    }

    8210. 

  8210. 					

    8211. 

  8211. 					    static bool check_Tcn_ArrayIndex<Tcn>() where Tcn : class, new()

    8212. 

  8212. 					    {

    8213. 

  8213. 					        return checkEx_Tcn_ArrayIndex<Tcn>(null, -1) &

    8214. 

  8214. 					            checkEx_Tcn_ArrayIndex<Tcn>(null, 0) &

    8215. 

  8215. 					            checkEx_Tcn_ArrayIndex<Tcn>(null, 1) &

    8216. 

  8216. 					

    8217. 

  8217. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(0)) &

    8218. 

  8218. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(1)) &

    8219. 

  8219. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(5));

    8220. 

  8220. 					    }

    8221. 

  8221. 					

    8222. 

  8222. 					    static Tcn[] genArrTcn_ArrayIndex<Tcn>(int size) where Tcn : class, new()

    8223. 

  8223. 					    {

    8224. 

  8224. 					        Tcn[] vals = new Tcn[] { null, default(Tcn), new Tcn() };

    8225. 

  8225. 					        Tcn[] result = new Tcn[size];

    8226. 

  8226. 					        for (int i = 0; i < size; i++)

    8227. 

  8227. 					        {

    8228. 

  8228. 					            result[i] = vals[i % vals.Length];

    8229. 

  8229. 					        }

    8230. 

  8230. 					        return result;

    8231. 

  8231. 					    }

    8232. 

  8232. 					

    8233. 

  8233. 					    static bool check_Tcn_ArrayIndex<Tcn>(Tcn[] val) where Tcn : class, new()

    8234. 

  8234. 					    {

    8235. 

  8235. 					        bool success = checkEx_Tcn_ArrayIndex<Tcn>(val, -1);

    8236. 

  8236. 					        for (int i = 0; i < val.Length; i++)

    8237. 

  8237. 					        {

    8238. 

  8238. 					            success &= check_Tcn_ArrayIndex<Tcn>(val, 0);

    8239. 

  8239. 					        }

    8240. 

  8240. 					        success &= checkEx_Tcn_ArrayIndex<Tcn>(val, val.Length);

    8241. 

  8241. 					        return success;

    8242. 

  8242. 					    }

    8243. 

  8243. 					

    8244. 

  8244. 					    static bool checkEx_Tcn_ArrayIndex<Tcn>(Tcn[] val, int index) where Tcn : class, new()

    8245. 

  8245. 					    {

    8246. 

  8246. 					        try

    8247. 

  8247. 					        {

    8248. 

  8248. 					            check_Tcn_ArrayIndex<Tcn>(val, index);

    8249. 

  8249. 					            Console.WriteLine("Tcn_ArrayIndex[" + index + "] failed");

    8250. 

  8250. 					            return false;

    8251. 

  8251. 					        }

    8252. 

  8252. 					        catch

    8253. 

  8253. 					        {

    8254. 

  8254. 					            return true;

    8255. 

  8255. 					        }

    8256. 

  8256. 					    }

    8257. 

  8257. 					

    8258. 

  8258. 					    static bool check_Tcn_ArrayIndex<Tcn>(Tcn[] val, int index) where Tcn : class, new()

    8259. 

  8259. 					    {

    8260. 

  8260. 					        Expression<Func<Tcn>> e =

    8261. 

  8261. 					            Expression.Lambda<Func<Tcn>>(

    8262. 

  8262. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Tcn[])),

    8263. 

  8263. 					                    Expression.Constant(index, typeof(int))),

    8264. 

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

    8265. 

  8265. 					        Func<Tcn> f = e.Compile();

    8266. 

  8266. 					        return object.Equals(f(), val[index]);

    8267. 

  8267. 					    }

    8268. 

  8268. 					}

    8269. 

  8269. 				

    8270. 

  8270. 				

    8271. 

  8271. 				public  static class Ext {

    8272. 

  8272. 				    public static void StartCapture() {

    8273. 

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

    8274. 

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

    8275. 

  8275. 				    }

    8276. 

  8276. 				

    8277. 

  8277. 				    public static void StopCapture() {

    8278. 

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

    8279. 

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

    8280. 

  8280. 				    }

    8281. 

  8281. 				

    8282. 

  8282. 				    public static bool IsIntegralOrEnum(Type type) {

    8283. 

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

    8284. 

  8284. 				            case TypeCode.Byte:

    8285. 

  8285. 				            case TypeCode.SByte:

    8286. 

  8286. 				            case TypeCode.Int16:

    8287. 

  8287. 				            case TypeCode.Int32:

    8288. 

  8288. 				            case TypeCode.Int64:

    8289. 

  8289. 				            case TypeCode.UInt16:

    8290. 

  8290. 				            case TypeCode.UInt32:

    8291. 

  8291. 				            case TypeCode.UInt64:

    8292. 

  8292. 				                return true;

    8293. 

  8293. 				            default:

    8294. 

  8294. 				                return false;

    8295. 

  8295. 				        }

    8296. 

  8296. 				    }

    8297. 

  8297. 				

    8298. 

  8298. 				    public static bool IsFloating(Type type) {

    8299. 

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

    8300. 

  8300. 				            case TypeCode.Single:

    8301. 

  8301. 				            case TypeCode.Double:

    8302. 

  8302. 				                return true;

    8303. 

  8303. 				            default:

    8304. 

  8304. 				                return false;

    8305. 

  8305. 				        }

    8306. 

  8306. 				    }

    8307. 

  8307. 				

    8308. 

  8308. 				    public static Type GetNonNullableType(Type type) {

    8309. 

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

    8310. 

  8310. 				                type.GetGenericArguments()[0] :

    8311. 

  8311. 				                type;

    8312. 

  8312. 				    }

    8313. 

  8313. 				}

    8314. 

  8314. 				

    8315. 

  8315. 			

    8316. 

  8316. 			

    8317. 

  8317. 			

    8318. 

  8318. 			public interface I

    8319. 

  8319. 			{

    8320. 

  8320. 			    void M();

    8321. 

  8321. 			}

    8322. 

  8322. 			

    8323. 

  8323. 			public  class C : IEquatable<C>, I

    8324. 

  8324. 			{

    8325. 

  8325. 			    void I.M()

    8326. 

  8326. 			    {

    8327. 

  8327. 			    }

    8328. 

  8328. 			

    8329. 

  8329. 			    public override bool Equals(object o)

    8330. 

  8330. 			    {

    8331. 

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

    8332. 

  8332. 			    }

    8333. 

  8333. 			

    8334. 

  8334. 			    public bool Equals(C c)

    8335. 

  8335. 			    {

    8336. 

  8336. 			        return c != null;

    8337. 

  8337. 			    }

    8338. 

  8338. 			

    8339. 

  8339. 			    public override int GetHashCode()

    8340. 

  8340. 			    {

    8341. 

  8341. 			        return 0;

    8342. 

  8342. 			    }

    8343. 

  8343. 			}

    8344. 

  8344. 			

    8345. 

  8345. 			public  class D : C, IEquatable<D>

    8346. 

  8346. 			{

    8347. 

  8347. 			    public int Val;

    8348. 

  8348. 			    public D()

    8349. 

  8349. 			    {

    8350. 

  8350. 			    }

    8351. 

  8351. 			    public D(int val)

    8352. 

  8352. 			    {

    8353. 

  8353. 			        Val = val;

    8354. 

  8354. 			    }

    8355. 

  8355. 			

    8356. 

  8356. 			    public override bool Equals(object o)

    8357. 

  8357. 			    {

    8358. 

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

    8359. 

  8359. 			    }

    8360. 

  8360. 			

    8361. 

  8361. 			    public bool Equals(D d)

    8362. 

  8362. 			    {

    8363. 

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

    8364. 

  8364. 			    }

    8365. 

  8365. 			

    8366. 

  8366. 			    public override int GetHashCode()

    8367. 

  8367. 			    {

    8368. 

  8368. 			        return Val;

    8369. 

  8369. 			    }

    8370. 

  8370. 			}

    8371. 

  8371. 			

    8372. 

  8372. 			public enum E

    8373. 

  8373. 			{

    8374. 

  8374. 			    A = 1, B = 2

    8375. 

  8375. 			}

    8376. 

  8376. 			

    8377. 

  8377. 			public enum El : long

    8378. 

  8378. 			{

    8379. 

  8379. 			    A, B, C

    8380. 

  8380. 			}

    8381. 

  8381. 			

    8382. 

  8382. 			public struct S : IEquatable<S>

    8383. 

  8383. 			{

    8384. 

  8384. 			    public override bool Equals(object o)

    8385. 

  8385. 			    {

    8386. 

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

    8387. 

  8387. 			    }

    8388. 

  8388. 			    public bool Equals(S other)

    8389. 

  8389. 			    {

    8390. 

  8390. 			        return true;

    8391. 

  8391. 			    }

    8392. 

  8392. 			    public override int GetHashCode()

    8393. 

  8393. 			    {

    8394. 

  8394. 			        return 0;

    8395. 

  8395. 			    }

    8396. 

  8396. 			}

    8397. 

  8397. 			

    8398. 

  8398. 			public struct Sp : IEquatable<Sp>

    8399. 

  8399. 			{

    8400. 

  8400. 			    public Sp(int i, double d)

    8401. 

  8401. 			    {

    8402. 

  8402. 			        I = i;

    8403. 

  8403. 			        D = d;

    8404. 

  8404. 			    }

    8405. 

  8405. 			

    8406. 

  8406. 			    public int I;

    8407. 

  8407. 			    public double D;

    8408. 

  8408. 			

    8409. 

  8409. 			    public override bool Equals(object o)

    8410. 

  8410. 			    {

    8411. 

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

    8412. 

  8412. 			    }

    8413. 

  8413. 			    public bool Equals(Sp other)

    8414. 

  8414. 			    {

    8415. 

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

    8416. 

  8416. 			    }

    8417. 

  8417. 			    public override int GetHashCode()

    8418. 

  8418. 			    {

    8419. 

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

    8420. 

  8420. 			    }

    8421. 

  8421. 			}

    8422. 

  8422. 			

    8423. 

  8423. 			public struct Ss : IEquatable<Ss>

    8424. 

  8424. 			{

    8425. 

  8425. 			    public Ss(S s)

    8426. 

  8426. 			    {

    8427. 

  8427. 			        Val = s;

    8428. 

  8428. 			    }

    8429. 

  8429. 			

    8430. 

  8430. 			    public S Val;

    8431. 

  8431. 			

    8432. 

  8432. 			    public override bool Equals(object o)

    8433. 

  8433. 			    {

    8434. 

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

    8435. 

  8435. 			    }

    8436. 

  8436. 			    public bool Equals(Ss other)

    8437. 

  8437. 			    {

    8438. 

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

    8439. 

  8439. 			    }

    8440. 

  8440. 			    public override int GetHashCode()

    8441. 

  8441. 			    {

    8442. 

  8442. 			        return Val.GetHashCode();

    8443. 

  8443. 			    }

    8444. 

  8444. 			}

    8445. 

  8445. 			

    8446. 

  8446. 			public struct Sc : IEquatable<Sc>

    8447. 

  8447. 			{

    8448. 

  8448. 			    public Sc(string s)

    8449. 

  8449. 			    {

    8450. 

  8450. 			        S = s;

    8451. 

  8451. 			    }

    8452. 

  8452. 			

    8453. 

  8453. 			    public string S;

    8454. 

  8454. 			

    8455. 

  8455. 			    public override bool Equals(object o)

    8456. 

  8456. 			    {

    8457. 

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

    8458. 

  8458. 			    }

    8459. 

  8459. 			    public bool Equals(Sc other)

    8460. 

  8460. 			    {

    8461. 

  8461. 			        return other.S == S;

    8462. 

  8462. 			    }

    8463. 

  8463. 			    public override int GetHashCode()

    8464. 

  8464. 			    {

    8465. 

  8465. 			        return S.GetHashCode();

    8466. 

  8466. 			    }

    8467. 

  8467. 			}

    8468. 

  8468. 			

    8469. 

  8469. 			public struct Scs : IEquatable<Scs>

    8470. 

  8470. 			{

    8471. 

  8471. 			    public Scs(string s, S val)

    8472. 

  8472. 			    {

    8473. 

  8473. 			        S = s;

    8474. 

  8474. 			        Val = val;

    8475. 

  8475. 			    }

    8476. 

  8476. 			

    8477. 

  8477. 			    public string S;

    8478. 

  8478. 			    public S Val;

    8479. 

  8479. 			

    8480. 

  8480. 			    public override bool Equals(object o)

    8481. 

  8481. 			    {

    8482. 

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

    8483. 

  8483. 			    }

    8484. 

  8484. 			    public bool Equals(Scs other)

    8485. 

  8485. 			    {

    8486. 

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

    8487. 

  8487. 			    }

    8488. 

  8488. 			    public override int GetHashCode()

    8489. 

  8489. 			    {

    8490. 

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

    8491. 

  8491. 			    }

    8492. 

  8492. 			}

    8493. 

  8493. 			

    8494. 

  8494. 		

    8495. 

  8495. 	}

    8496. 

  8496. 				

    8497. 

  8497. 				//-------- Scenario 3159

    8498. 

  8498. 				namespace Scenario3159{

    8499. 

  8499. 					

    8500. 

  8500. 					public class Test

    8501. 

  8501. 					{

    8502. 

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

    8503. 

  8503. 				    public static Expression Tcn_ArrayIndex_C___() {

    8504. 

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

    8505. 

  8505. 				           throw new Exception();

    8506. 

  8506. 				       } else { 

    8507. 

  8507. 				           return Expression.Constant(0);

    8508. 

  8508. 				       }

    8509. 

  8509. 				    }

    8510. 

  8510. 					public     static int Main()

    8511. 

  8511. 					    {

    8512. 

  8512. 					        Ext.StartCapture();

    8513. 

  8513. 					        bool success = false;

    8514. 

  8514. 					        try

    8515. 

  8515. 					        {

    8516. 

  8516. 					            success = check_Tcn_ArrayIndex<C>();

    8517. 

  8517. 					        }

    8518. 

  8518. 					        finally

    8519. 

  8519. 					        {

    8520. 

  8520. 					            Ext.StopCapture();

    8521. 

  8521. 					        }

    8522. 

  8522. 					        return success ? 0 : 1;

    8523. 

  8523. 					    }

    8524. 

  8524. 					

    8525. 

  8525. 					    static bool check_Tcn_ArrayIndex<Tcn>() where Tcn : class, new()

    8526. 

  8526. 					    {

    8527. 

  8527. 					        return checkEx_Tcn_ArrayIndex<Tcn>(null, -1) &

    8528. 

  8528. 					            checkEx_Tcn_ArrayIndex<Tcn>(null, 0) &

    8529. 

  8529. 					            checkEx_Tcn_ArrayIndex<Tcn>(null, 1) &

    8530. 

  8530. 					

    8531. 

  8531. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(0)) &

    8532. 

  8532. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(1)) &

    8533. 

  8533. 					            check_Tcn_ArrayIndex<Tcn>(genArrTcn_ArrayIndex<Tcn>(5));

    8534. 

  8534. 					    }

    8535. 

  8535. 					

    8536. 

  8536. 					    static Tcn[] genArrTcn_ArrayIndex<Tcn>(int size) where Tcn : class, new()

    8537. 

  8537. 					    {

    8538. 

  8538. 					        Tcn[] vals = new Tcn[] { null, default(Tcn), new Tcn() };

    8539. 

  8539. 					        Tcn[] result = new Tcn[size];

    8540. 

  8540. 					        for (int i = 0; i < size; i++)

    8541. 

  8541. 					        {

    8542. 

  8542. 					            result[i] = vals[i % vals.Length];

    8543. 

  8543. 					        }

    8544. 

  8544. 					        return result;

    8545. 

  8545. 					    }

    8546. 

  8546. 					

    8547. 

  8547. 					    static bool check_Tcn_ArrayIndex<Tcn>(Tcn[] val) where Tcn : class, new()

    8548. 

  8548. 					    {

    8549. 

  8549. 					        bool success = checkEx_Tcn_ArrayIndex<Tcn>(val, -1);

    8550. 

  8550. 					        for (int i = 0; i < val.Length; i++)

    8551. 

  8551. 					        {

    8552. 

  8552. 					            success &= check_Tcn_ArrayIndex<Tcn>(val, 0);

    8553. 

  8553. 					        }

    8554. 

  8554. 					        success &= checkEx_Tcn_ArrayIndex<Tcn>(val, val.Length);

    8555. 

  8555. 					        return success;

    8556. 

  8556. 					    }

    8557. 

  8557. 					

    8558. 

  8558. 					    static bool checkEx_Tcn_ArrayIndex<Tcn>(Tcn[] val, int index) where Tcn : class, new()

    8559. 

  8559. 					    {

    8560. 

  8560. 					        try

    8561. 

  8561. 					        {

    8562. 

  8562. 					            check_Tcn_ArrayIndex<Tcn>(val, index);

    8563. 

  8563. 					            Console.WriteLine("Tcn_ArrayIndex[" + index + "] failed");

    8564. 

  8564. 					            return false;

    8565. 

  8565. 					        }

    8566. 

  8566. 					        catch

    8567. 

  8567. 					        {

    8568. 

  8568. 					            return true;

    8569. 

  8569. 					        }

    8570. 

  8570. 					    }

    8571. 

  8571. 					

    8572. 

  8572. 					    static bool check_Tcn_ArrayIndex<Tcn>(Tcn[] val, int index) where Tcn : class, new()

    8573. 

  8573. 					    {

    8574. 

  8574. 					        Expression<Func<Tcn>> e =

    8575. 

  8575. 					            Expression.Lambda<Func<Tcn>>(

    8576. 

  8576. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(Tcn[])),

    8577. 

  8577. 					                    Expression.Constant(index, typeof(int))),

    8578. 

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

    8579. 

  8579. 					        Func<Tcn> f = e.Compile();

    8580. 

  8580. 					        return object.Equals(f(), val[index]);

    8581. 

  8581. 					    }

    8582. 

  8582. 					}

    8583. 

  8583. 				

    8584. 

  8584. 				

    8585. 

  8585. 				public  static class Ext {

    8586. 

  8586. 				    public static void StartCapture() {

    8587. 

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

    8588. 

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

    8589. 

  8589. 				    }

    8590. 

  8590. 				

    8591. 

  8591. 				    public static void StopCapture() {

    8592. 

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

    8593. 

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

    8594. 

  8594. 				    }

    8595. 

  8595. 				

    8596. 

  8596. 				    public static bool IsIntegralOrEnum(Type type) {

    8597. 

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

    8598. 

  8598. 				            case TypeCode.Byte:

    8599. 

  8599. 				            case TypeCode.SByte:

    8600. 

  8600. 				            case TypeCode.Int16:

    8601. 

  8601. 				            case TypeCode.Int32:

    8602. 

  8602. 				            case TypeCode.Int64:

    8603. 

  8603. 				            case TypeCode.UInt16:

    8604. 

  8604. 				            case TypeCode.UInt32:

    8605. 

  8605. 				            case TypeCode.UInt64:

    8606. 

  8606. 				                return true;

    8607. 

  8607. 				            default:

    8608. 

  8608. 				                return false;

    8609. 

  8609. 				        }

    8610. 

  8610. 				    }

    8611. 

  8611. 				

    8612. 

  8612. 				    public static bool IsFloating(Type type) {

    8613. 

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

    8614. 

  8614. 				            case TypeCode.Single:

    8615. 

  8615. 				            case TypeCode.Double:

    8616. 

  8616. 				                return true;

    8617. 

  8617. 				            default:

    8618. 

  8618. 				                return false;

    8619. 

  8619. 				        }

    8620. 

  8620. 				    }

    8621. 

  8621. 				

    8622. 

  8622. 				    public static Type GetNonNullableType(Type type) {

    8623. 

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

    8624. 

  8624. 				                type.GetGenericArguments()[0] :

    8625. 

  8625. 				                type;

    8626. 

  8626. 				    }

    8627. 

  8627. 				}

    8628. 

  8628. 				

    8629. 

  8629. 			

    8630. 

  8630. 			

    8631. 

  8631. 			

    8632. 

  8632. 			public interface I

    8633. 

  8633. 			{

    8634. 

  8634. 			    void M();

    8635. 

  8635. 			}

    8636. 

  8636. 			

    8637. 

  8637. 			public  class C : IEquatable<C>, I

    8638. 

  8638. 			{

    8639. 

  8639. 			    void I.M()

    8640. 

  8640. 			    {

    8641. 

  8641. 			    }

    8642. 

  8642. 			

    8643. 

  8643. 			    public override bool Equals(object o)

    8644. 

  8644. 			    {

    8645. 

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

    8646. 

  8646. 			    }

    8647. 

  8647. 			

    8648. 

  8648. 			    public bool Equals(C c)

    8649. 

  8649. 			    {

    8650. 

  8650. 			        return c != null;

    8651. 

  8651. 			    }

    8652. 

  8652. 			

    8653. 

  8653. 			    public override int GetHashCode()

    8654. 

  8654. 			    {

    8655. 

  8655. 			        return 0;

    8656. 

  8656. 			    }

    8657. 

  8657. 			}

    8658. 

  8658. 			

    8659. 

  8659. 			public  class D : C, IEquatable<D>

    8660. 

  8660. 			{

    8661. 

  8661. 			    public int Val;

    8662. 

  8662. 			    public D()

    8663. 

  8663. 			    {

    8664. 

  8664. 			    }

    8665. 

  8665. 			    public D(int val)

    8666. 

  8666. 			    {

    8667. 

  8667. 			        Val = val;

    8668. 

  8668. 			    }

    8669. 

  8669. 			

    8670. 

  8670. 			    public override bool Equals(object o)

    8671. 

  8671. 			    {

    8672. 

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

    8673. 

  8673. 			    }

    8674. 

  8674. 			

    8675. 

  8675. 			    public bool Equals(D d)

    8676. 

  8676. 			    {

    8677. 

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

    8678. 

  8678. 			    }

    8679. 

  8679. 			

    8680. 

  8680. 			    public override int GetHashCode()

    8681. 

  8681. 			    {

    8682. 

  8682. 			        return Val;

    8683. 

  8683. 			    }

    8684. 

  8684. 			}

    8685. 

  8685. 			

    8686. 

  8686. 			public enum E

    8687. 

  8687. 			{

    8688. 

  8688. 			    A = 1, B = 2

    8689. 

  8689. 			}

    8690. 

  8690. 			

    8691. 

  8691. 			public enum El : long

    8692. 

  8692. 			{

    8693. 

  8693. 			    A, B, C

    8694. 

  8694. 			}

    8695. 

  8695. 			

    8696. 

  8696. 			public struct S : IEquatable<S>

    8697. 

  8697. 			{

    8698. 

  8698. 			    public override bool Equals(object o)

    8699. 

  8699. 			    {

    8700. 

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

    8701. 

  8701. 			    }

    8702. 

  8702. 			    public bool Equals(S other)

    8703. 

  8703. 			    {

    8704. 

  8704. 			        return true;

    8705. 

  8705. 			    }

    8706. 

  8706. 			    public override int GetHashCode()

    8707. 

  8707. 			    {

    8708. 

  8708. 			        return 0;

    8709. 

  8709. 			    }

    8710. 

  8710. 			}

    8711. 

  8711. 			

    8712. 

  8712. 			public struct Sp : IEquatable<Sp>

    8713. 

  8713. 			{

    8714. 

  8714. 			    public Sp(int i, double d)

    8715. 

  8715. 			    {

    8716. 

  8716. 			        I = i;

    8717. 

  8717. 			        D = d;

    8718. 

  8718. 			    }

    8719. 

  8719. 			

    8720. 

  8720. 			    public int I;

    8721. 

  8721. 			    public double D;

    8722. 

  8722. 			

    8723. 

  8723. 			    public override bool Equals(object o)

    8724. 

  8724. 			    {

    8725. 

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

    8726. 

  8726. 			    }

    8727. 

  8727. 			    public bool Equals(Sp other)

    8728. 

  8728. 			    {

    8729. 

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

    8730. 

  8730. 			    }

    8731. 

  8731. 			    public override int GetHashCode()

    8732. 

  8732. 			    {

    8733. 

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

    8734. 

  8734. 			    }

    8735. 

  8735. 			}

    8736. 

  8736. 			

    8737. 

  8737. 			public struct Ss : IEquatable<Ss>

    8738. 

  8738. 			{

    8739. 

  8739. 			    public Ss(S s)

    8740. 

  8740. 			    {

    8741. 

  8741. 			        Val = s;

    8742. 

  8742. 			    }

    8743. 

  8743. 			

    8744. 

  8744. 			    public S Val;

    8745. 

  8745. 			

    8746. 

  8746. 			    public override bool Equals(object o)

    8747. 

  8747. 			    {

    8748. 

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

    8749. 

  8749. 			    }

    8750. 

  8750. 			    public bool Equals(Ss other)

    8751. 

  8751. 			    {

    8752. 

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

    8753. 

  8753. 			    }

    8754. 

  8754. 			    public override int GetHashCode()

    8755. 

  8755. 			    {

    8756. 

  8756. 			        return Val.GetHashCode();

    8757. 

  8757. 			    }

    8758. 

  8758. 			}

    8759. 

  8759. 			

    8760. 

  8760. 			public struct Sc : IEquatable<Sc>

    8761. 

  8761. 			{

    8762. 

  8762. 			    public Sc(string s)

    8763. 

  8763. 			    {

    8764. 

  8764. 			        S = s;

    8765. 

  8765. 			    }

    8766. 

  8766. 			

    8767. 

  8767. 			    public string S;

    8768. 

  8768. 			

    8769. 

  8769. 			    public override bool Equals(object o)

    8770. 

  8770. 			    {

    8771. 

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

    8772. 

  8772. 			    }

    8773. 

  8773. 			    public bool Equals(Sc other)

    8774. 

  8774. 			    {

    8775. 

  8775. 			        return other.S == S;

    8776. 

  8776. 			    }

    8777. 

  8777. 			    public override int GetHashCode()

    8778. 

  8778. 			    {

    8779. 

  8779. 			        return S.GetHashCode();

    8780. 

  8780. 			    }

    8781. 

  8781. 			}

    8782. 

  8782. 			

    8783. 

  8783. 			public struct Scs : IEquatable<Scs>

    8784. 

  8784. 			{

    8785. 

  8785. 			    public Scs(string s, S val)

    8786. 

  8786. 			    {

    8787. 

  8787. 			        S = s;

    8788. 

  8788. 			        Val = val;

    8789. 

  8789. 			    }

    8790. 

  8790. 			

    8791. 

  8791. 			    public string S;

    8792. 

  8792. 			    public S Val;

    8793. 

  8793. 			

    8794. 

  8794. 			    public override bool Equals(object o)

    8795. 

  8795. 			    {

    8796. 

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

    8797. 

  8797. 			    }

    8798. 

  8798. 			    public bool Equals(Scs other)

    8799. 

  8799. 			    {

    8800. 

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

    8801. 

  8801. 			    }

    8802. 

  8802. 			    public override int GetHashCode()

    8803. 

  8803. 			    {

    8804. 

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

    8805. 

  8805. 			    }

    8806. 

  8806. 			}

    8807. 

  8807. 			

    8808. 

  8808. 		

    8809. 

  8809. 	}

    8810. 

  8810. 				

    8811. 

  8811. 				//-------- Scenario 3160

    8812. 

  8812. 				namespace Scenario3160{

    8813. 

  8813. 					

    8814. 

  8814. 					public class Test

    8815. 

  8815. 					{

    8816. 

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

    8817. 

  8817. 				    public static Expression TC_ArrayIndex_C_a__() {

    8818. 

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

    8819. 

  8819. 				           throw new Exception();

    8820. 

  8820. 				       } else { 

    8821. 

  8821. 				           return Expression.Constant(0);

    8822. 

  8822. 				       }

    8823. 

  8823. 				    }

    8824. 

  8824. 					public     static int Main()

    8825. 

  8825. 					    {

    8826. 

  8826. 					        Ext.StartCapture();

    8827. 

  8827. 					        bool success = false;

    8828. 

  8828. 					        try

    8829. 

  8829. 					        {

    8830. 

  8830. 					            success = check_TC_ArrayIndex<C>();

    8831. 

  8831. 					        }

    8832. 

  8832. 					        finally

    8833. 

  8833. 					        {

    8834. 

  8834. 					            Ext.StopCapture();

    8835. 

  8835. 					        }

    8836. 

  8836. 					        return success ? 0 : 1;

    8837. 

  8837. 					    }

    8838. 

  8838. 					

    8839. 

  8839. 					    static bool check_TC_ArrayIndex<TC>() where TC : C

    8840. 

  8840. 					    {

    8841. 

  8841. 					        return checkEx_TC_ArrayIndex<TC>(null, -1) &

    8842. 

  8842. 					            checkEx_TC_ArrayIndex<TC>(null, 0) &

    8843. 

  8843. 					            checkEx_TC_ArrayIndex<TC>(null, 1) &

    8844. 

  8844. 					

    8845. 

  8845. 					            check_TC_ArrayIndex<TC>(genArrTC_ArrayIndex<TC>(0)) &

    8846. 

  8846. 					            check_TC_ArrayIndex<TC>(genArrTC_ArrayIndex<TC>(1)) &

    8847. 

  8847. 					            check_TC_ArrayIndex<TC>(genArrTC_ArrayIndex<TC>(5));

    8848. 

  8848. 					    }

    8849. 

  8849. 					

    8850. 

  8850. 					    static TC[] genArrTC_ArrayIndex<TC>(int size) where TC : C

    8851. 

  8851. 					    {

    8852. 

  8852. 					        TC[] vals = new TC[] { null, default(TC), (TC)new C() };

    8853. 

  8853. 					        TC[] result = new TC[size];

    8854. 

  8854. 					        for (int i = 0; i < size; i++)

    8855. 

  8855. 					        {

    8856. 

  8856. 					            result[i] = vals[i % vals.Length];

    8857. 

  8857. 					        }

    8858. 

  8858. 					        return result;

    8859. 

  8859. 					    }

    8860. 

  8860. 					

    8861. 

  8861. 					    static bool check_TC_ArrayIndex<TC>(TC[] val) where TC : C

    8862. 

  8862. 					    {

    8863. 

  8863. 					        bool success = checkEx_TC_ArrayIndex<TC>(val, -1);

    8864. 

  8864. 					        for (int i = 0; i < val.Length; i++)

    8865. 

  8865. 					        {

    8866. 

  8866. 					            success &= check_TC_ArrayIndex<TC>(val, 0);

    8867. 

  8867. 					        }

    8868. 

  8868. 					        success &= checkEx_TC_ArrayIndex<TC>(val, val.Length);

    8869. 

  8869. 					        return success;

    8870. 

  8870. 					    }

    8871. 

  8871. 					

    8872. 

  8872. 					    static bool checkEx_TC_ArrayIndex<TC>(TC[] val, int index) where TC : C

    8873. 

  8873. 					    {

    8874. 

  8874. 					        try

    8875. 

  8875. 					        {

    8876. 

  8876. 					            check_TC_ArrayIndex<TC>(val, index);

    8877. 

  8877. 					            Console.WriteLine("TC_ArrayIndex[" + index + "] failed");

    8878. 

  8878. 					            return false;

    8879. 

  8879. 					        }

    8880. 

  8880. 					        catch

    8881. 

  8881. 					        {

    8882. 

  8882. 					            return true;

    8883. 

  8883. 					        }

    8884. 

  8884. 					    }

    8885. 

  8885. 					

    8886. 

  8886. 					    static bool check_TC_ArrayIndex<TC>(TC[] val, int index) where TC : C

    8887. 

  8887. 					    {

    8888. 

  8888. 					        Expression<Func<TC>> e =

    8889. 

  8889. 					            Expression.Lambda<Func<TC>>(

    8890. 

  8890. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(TC[])),

    8891. 

  8891. 					                    Expression.Constant(index, typeof(int))),

    8892. 

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

    8893. 

  8893. 					        Func<TC> f = e.Compile();

    8894. 

  8894. 					        return object.Equals(f(), val[index]);

    8895. 

  8895. 					    }

    8896. 

  8896. 					}

    8897. 

  8897. 				

    8898. 

  8898. 				

    8899. 

  8899. 				public  static class Ext {

    8900. 

  8900. 				    public static void StartCapture() {

    8901. 

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

    8902. 

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

    8903. 

  8903. 				    }

    8904. 

  8904. 				

    8905. 

  8905. 				    public static void StopCapture() {

    8906. 

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

    8907. 

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

    8908. 

  8908. 				    }

    8909. 

  8909. 				

    8910. 

  8910. 				    public static bool IsIntegralOrEnum(Type type) {

    8911. 

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

    8912. 

  8912. 				            case TypeCode.Byte:

    8913. 

  8913. 				            case TypeCode.SByte:

    8914. 

  8914. 				            case TypeCode.Int16:

    8915. 

  8915. 				            case TypeCode.Int32:

    8916. 

  8916. 				            case TypeCode.Int64:

    8917. 

  8917. 				            case TypeCode.UInt16:

    8918. 

  8918. 				            case TypeCode.UInt32:

    8919. 

  8919. 				            case TypeCode.UInt64:

    8920. 

  8920. 				                return true;

    8921. 

  8921. 				            default:

    8922. 

  8922. 				                return false;

    8923. 

  8923. 				        }

    8924. 

  8924. 				    }

    8925. 

  8925. 				

    8926. 

  8926. 				    public static bool IsFloating(Type type) {

    8927. 

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

    8928. 

  8928. 				            case TypeCode.Single:

    8929. 

  8929. 				            case TypeCode.Double:

    8930. 

  8930. 				                return true;

    8931. 

  8931. 				            default:

    8932. 

  8932. 				                return false;

    8933. 

  8933. 				        }

    8934. 

  8934. 				    }

    8935. 

  8935. 				

    8936. 

  8936. 				    public static Type GetNonNullableType(Type type) {

    8937. 

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

    8938. 

  8938. 				                type.GetGenericArguments()[0] :

    8939. 

  8939. 				                type;

    8940. 

  8940. 				    }

    8941. 

  8941. 				}

    8942. 

  8942. 				

    8943. 

  8943. 			

    8944. 

  8944. 			

    8945. 

  8945. 			

    8946. 

  8946. 			public interface I

    8947. 

  8947. 			{

    8948. 

  8948. 			    void M();

    8949. 

  8949. 			}

    8950. 

  8950. 			

    8951. 

  8951. 			public  class C : IEquatable<C>, I

    8952. 

  8952. 			{

    8953. 

  8953. 			    void I.M()

    8954. 

  8954. 			    {

    8955. 

  8955. 			    }

    8956. 

  8956. 			

    8957. 

  8957. 			    public override bool Equals(object o)

    8958. 

  8958. 			    {

    8959. 

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

    8960. 

  8960. 			    }

    8961. 

  8961. 			

    8962. 

  8962. 			    public bool Equals(C c)

    8963. 

  8963. 			    {

    8964. 

  8964. 			        return c != null;

    8965. 

  8965. 			    }

    8966. 

  8966. 			

    8967. 

  8967. 			    public override int GetHashCode()

    8968. 

  8968. 			    {

    8969. 

  8969. 			        return 0;

    8970. 

  8970. 			    }

    8971. 

  8971. 			}

    8972. 

  8972. 			

    8973. 

  8973. 			public  class D : C, IEquatable<D>

    8974. 

  8974. 			{

    8975. 

  8975. 			    public int Val;

    8976. 

  8976. 			    public D()

    8977. 

  8977. 			    {

    8978. 

  8978. 			    }

    8979. 

  8979. 			    public D(int val)

    8980. 

  8980. 			    {

    8981. 

  8981. 			        Val = val;

    8982. 

  8982. 			    }

    8983. 

  8983. 			

    8984. 

  8984. 			    public override bool Equals(object o)

    8985. 

  8985. 			    {

    8986. 

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

    8987. 

  8987. 			    }

    8988. 

  8988. 			

    8989. 

  8989. 			    public bool Equals(D d)

    8990. 

  8990. 			    {

    8991. 

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

    8992. 

  8992. 			    }

    8993. 

  8993. 			

    8994. 

  8994. 			    public override int GetHashCode()

    8995. 

  8995. 			    {

    8996. 

  8996. 			        return Val;

    8997. 

  8997. 			    }

    8998. 

  8998. 			}

    8999. 

  8999. 			

    9000. 

  9000. 			public enum E

    9001. 

  9001. 			{

    9002. 

  9002. 			    A = 1, B = 2

    9003. 

  9003. 			}

    9004. 

  9004. 			

    9005. 

  9005. 			public enum El : long

    9006. 

  9006. 			{

    9007. 

  9007. 			    A, B, C

    9008. 

  9008. 			}

    9009. 

  9009. 			

    9010. 

  9010. 			public struct S : IEquatable<S>

    9011. 

  9011. 			{

    9012. 

  9012. 			    public override bool Equals(object o)

    9013. 

  9013. 			    {

    9014. 

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

    9015. 

  9015. 			    }

    9016. 

  9016. 			    public bool Equals(S other)

    9017. 

  9017. 			    {

    9018. 

  9018. 			        return true;

    9019. 

  9019. 			    }

    9020. 

  9020. 			    public override int GetHashCode()

    9021. 

  9021. 			    {

    9022. 

  9022. 			        return 0;

    9023. 

  9023. 			    }

    9024. 

  9024. 			}

    9025. 

  9025. 			

    9026. 

  9026. 			public struct Sp : IEquatable<Sp>

    9027. 

  9027. 			{

    9028. 

  9028. 			    public Sp(int i, double d)

    9029. 

  9029. 			    {

    9030. 

  9030. 			        I = i;

    9031. 

  9031. 			        D = d;

    9032. 

  9032. 			    }

    9033. 

  9033. 			

    9034. 

  9034. 			    public int I;

    9035. 

  9035. 			    public double D;

    9036. 

  9036. 			

    9037. 

  9037. 			    public override bool Equals(object o)

    9038. 

  9038. 			    {

    9039. 

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

    9040. 

  9040. 			    }

    9041. 

  9041. 			    public bool Equals(Sp other)

    9042. 

  9042. 			    {

    9043. 

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

    9044. 

  9044. 			    }

    9045. 

  9045. 			    public override int GetHashCode()

    9046. 

  9046. 			    {

    9047. 

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

    9048. 

  9048. 			    }

    9049. 

  9049. 			}

    9050. 

  9050. 			

    9051. 

  9051. 			public struct Ss : IEquatable<Ss>

    9052. 

  9052. 			{

    9053. 

  9053. 			    public Ss(S s)

    9054. 

  9054. 			    {

    9055. 

  9055. 			        Val = s;

    9056. 

  9056. 			    }

    9057. 

  9057. 			

    9058. 

  9058. 			    public S Val;

    9059. 

  9059. 			

    9060. 

  9060. 			    public override bool Equals(object o)

    9061. 

  9061. 			    {

    9062. 

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

    9063. 

  9063. 			    }

    9064. 

  9064. 			    public bool Equals(Ss other)

    9065. 

  9065. 			    {

    9066. 

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

    9067. 

  9067. 			    }

    9068. 

  9068. 			    public override int GetHashCode()

    9069. 

  9069. 			    {

    9070. 

  9070. 			        return Val.GetHashCode();

    9071. 

  9071. 			    }

    9072. 

  9072. 			}

    9073. 

  9073. 			

    9074. 

  9074. 			public struct Sc : IEquatable<Sc>

    9075. 

  9075. 			{

    9076. 

  9076. 			    public Sc(string s)

    9077. 

  9077. 			    {

    9078. 

  9078. 			        S = s;

    9079. 

  9079. 			    }

    9080. 

  9080. 			

    9081. 

  9081. 			    public string S;

    9082. 

  9082. 			

    9083. 

  9083. 			    public override bool Equals(object o)

    9084. 

  9084. 			    {

    9085. 

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

    9086. 

  9086. 			    }

    9087. 

  9087. 			    public bool Equals(Sc other)

    9088. 

  9088. 			    {

    9089. 

  9089. 			        return other.S == S;

    9090. 

  9090. 			    }

    9091. 

  9091. 			    public override int GetHashCode()

    9092. 

  9092. 			    {

    9093. 

  9093. 			        return S.GetHashCode();

    9094. 

  9094. 			    }

    9095. 

  9095. 			}

    9096. 

  9096. 			

    9097. 

  9097. 			public struct Scs : IEquatable<Scs>

    9098. 

  9098. 			{

    9099. 

  9099. 			    public Scs(string s, S val)

    9100. 

  9100. 			    {

    9101. 

  9101. 			        S = s;

    9102. 

  9102. 			        Val = val;

    9103. 

  9103. 			    }

    9104. 

  9104. 			

    9105. 

  9105. 			    public string S;

    9106. 

  9106. 			    public S Val;

    9107. 

  9107. 			

    9108. 

  9108. 			    public override bool Equals(object o)

    9109. 

  9109. 			    {

    9110. 

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

    9111. 

  9111. 			    }

    9112. 

  9112. 			    public bool Equals(Scs other)

    9113. 

  9113. 			    {

    9114. 

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

    9115. 

  9115. 			    }

    9116. 

  9116. 			    public override int GetHashCode()

    9117. 

  9117. 			    {

    9118. 

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

    9119. 

  9119. 			    }

    9120. 

  9120. 			}

    9121. 

  9121. 			

    9122. 

  9122. 		

    9123. 

  9123. 	}

    9124. 

  9124. 				

    9125. 

  9125. 				//-------- Scenario 3161

    9126. 

  9126. 				namespace Scenario3161{

    9127. 

  9127. 					

    9128. 

  9128. 					public class Test

    9129. 

  9129. 					{

    9130. 

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

    9131. 

  9131. 				    public static Expression TCn_ArrayIndex_C_a__() {

    9132. 

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

    9133. 

  9133. 				           throw new Exception();

    9134. 

  9134. 				       } else { 

    9135. 

  9135. 				           return Expression.Constant(0);

    9136. 

  9136. 				       }

    9137. 

  9137. 				    }

    9138. 

  9138. 					public     static int Main()

    9139. 

  9139. 					    {

    9140. 

  9140. 					        Ext.StartCapture();

    9141. 

  9141. 					        bool success = false;

    9142. 

  9142. 					        try

    9143. 

  9143. 					        {

    9144. 

  9144. 					            success = check_TCn_ArrayIndex<C>();

    9145. 

  9145. 					        }

    9146. 

  9146. 					        finally

    9147. 

  9147. 					        {

    9148. 

  9148. 					            Ext.StopCapture();

    9149. 

  9149. 					        }

    9150. 

  9150. 					        return success ? 0 : 1;

    9151. 

  9151. 					    }

    9152. 

  9152. 					

    9153. 

  9153. 					    static bool check_TCn_ArrayIndex<TCn>() where TCn : C, new()

    9154. 

  9154. 					    {

    9155. 

  9155. 					        return checkEx_TCn_ArrayIndex<TCn>(null, -1) &

    9156. 

  9156. 					            checkEx_TCn_ArrayIndex<TCn>(null, 0) &

    9157. 

  9157. 					            checkEx_TCn_ArrayIndex<TCn>(null, 1) &

    9158. 

  9158. 					

    9159. 

  9159. 					            check_TCn_ArrayIndex<TCn>(genArrTCn_ArrayIndex<TCn>(0)) &

    9160. 

  9160. 					            check_TCn_ArrayIndex<TCn>(genArrTCn_ArrayIndex<TCn>(1)) &

    9161. 

  9161. 					            check_TCn_ArrayIndex<TCn>(genArrTCn_ArrayIndex<TCn>(5));

    9162. 

  9162. 					    }

    9163. 

  9163. 					

    9164. 

  9164. 					    static TCn[] genArrTCn_ArrayIndex<TCn>(int size) where TCn : C, new()

    9165. 

  9165. 					    {

    9166. 

  9166. 					        TCn[] vals = new TCn[] { null, default(TCn), new TCn(), (TCn)new C() };

    9167. 

  9167. 					        TCn[] result = new TCn[size];

    9168. 

  9168. 					        for (int i = 0; i < size; i++)

    9169. 

  9169. 					        {

    9170. 

  9170. 					            result[i] = vals[i % vals.Length];

    9171. 

  9171. 					        }

    9172. 

  9172. 					        return result;

    9173. 

  9173. 					    }

    9174. 

  9174. 					

    9175. 

  9175. 					    static bool check_TCn_ArrayIndex<TCn>(TCn[] val) where TCn : C, new()

    9176. 

  9176. 					    {

    9177. 

  9177. 					        bool success = checkEx_TCn_ArrayIndex<TCn>(val, -1);

    9178. 

  9178. 					        for (int i = 0; i < val.Length; i++)

    9179. 

  9179. 					        {

    9180. 

  9180. 					            success &= check_TCn_ArrayIndex<TCn>(val, 0);

    9181. 

  9181. 					        }

    9182. 

  9182. 					        success &= checkEx_TCn_ArrayIndex<TCn>(val, val.Length);

    9183. 

  9183. 					        return success;

    9184. 

  9184. 					    }

    9185. 

  9185. 					

    9186. 

  9186. 					    static bool checkEx_TCn_ArrayIndex<TCn>(TCn[] val, int index) where TCn : C, new()

    9187. 

  9187. 					    {

    9188. 

  9188. 					        try

    9189. 

  9189. 					        {

    9190. 

  9190. 					            check_TCn_ArrayIndex<TCn>(val, index);

    9191. 

  9191. 					            Console.WriteLine("TCn_ArrayIndex[" + index + "] failed");

    9192. 

  9192. 					            return false;

    9193. 

  9193. 					        }

    9194. 

  9194. 					        catch

    9195. 

  9195. 					        {

    9196. 

  9196. 					            return true;

    9197. 

  9197. 					        }

    9198. 

  9198. 					    }

    9199. 

  9199. 					

    9200. 

  9200. 					    static bool check_TCn_ArrayIndex<TCn>(TCn[] val, int index) where TCn : C, new()

    9201. 

  9201. 					    {

    9202. 

  9202. 					        Expression<Func<TCn>> e =

    9203. 

  9203. 					            Expression.Lambda<Func<TCn>>(

    9204. 

  9204. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(TCn[])),

    9205. 

  9205. 					                    Expression.Constant(index, typeof(int))),

    9206. 

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

    9207. 

  9207. 					        Func<TCn> f = e.Compile();

    9208. 

  9208. 					        return object.Equals(f(), val[index]);

    9209. 

  9209. 					    }

    9210. 

  9210. 					}

    9211. 

  9211. 				

    9212. 

  9212. 				

    9213. 

  9213. 				public  static class Ext {

    9214. 

  9214. 				    public static void StartCapture() {

    9215. 

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

    9216. 

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

    9217. 

  9217. 				    }

    9218. 

  9218. 				

    9219. 

  9219. 				    public static void StopCapture() {

    9220. 

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

    9221. 

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

    9222. 

  9222. 				    }

    9223. 

  9223. 				

    9224. 

  9224. 				    public static bool IsIntegralOrEnum(Type type) {

    9225. 

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

    9226. 

  9226. 				            case TypeCode.Byte:

    9227. 

  9227. 				            case TypeCode.SByte:

    9228. 

  9228. 				            case TypeCode.Int16:

    9229. 

  9229. 				            case TypeCode.Int32:

    9230. 

  9230. 				            case TypeCode.Int64:

    9231. 

  9231. 				            case TypeCode.UInt16:

    9232. 

  9232. 				            case TypeCode.UInt32:

    9233. 

  9233. 				            case TypeCode.UInt64:

    9234. 

  9234. 				                return true;

    9235. 

  9235. 				            default:

    9236. 

  9236. 				                return false;

    9237. 

  9237. 				        }

    9238. 

  9238. 				    }

    9239. 

  9239. 				

    9240. 

  9240. 				    public static bool IsFloating(Type type) {

    9241. 

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

    9242. 

  9242. 				            case TypeCode.Single:

    9243. 

  9243. 				            case TypeCode.Double:

    9244. 

  9244. 				                return true;

    9245. 

  9245. 				            default:

    9246. 

  9246. 				                return false;

    9247. 

  9247. 				        }

    9248. 

  9248. 				    }

    9249. 

  9249. 				

    9250. 

  9250. 				    public static Type GetNonNullableType(Type type) {

    9251. 

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

    9252. 

  9252. 				                type.GetGenericArguments()[0] :

    9253. 

  9253. 				                type;

    9254. 

  9254. 				    }

    9255. 

  9255. 				}

    9256. 

  9256. 				

    9257. 

  9257. 			

    9258. 

  9258. 			

    9259. 

  9259. 			

    9260. 

  9260. 			public interface I

    9261. 

  9261. 			{

    9262. 

  9262. 			    void M();

    9263. 

  9263. 			}

    9264. 

  9264. 			

    9265. 

  9265. 			public  class C : IEquatable<C>, I

    9266. 

  9266. 			{

    9267. 

  9267. 			    void I.M()

    9268. 

  9268. 			    {

    9269. 

  9269. 			    }

    9270. 

  9270. 			

    9271. 

  9271. 			    public override bool Equals(object o)

    9272. 

  9272. 			    {

    9273. 

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

    9274. 

  9274. 			    }

    9275. 

  9275. 			

    9276. 

  9276. 			    public bool Equals(C c)

    9277. 

  9277. 			    {

    9278. 

  9278. 			        return c != null;

    9279. 

  9279. 			    }

    9280. 

  9280. 			

    9281. 

  9281. 			    public override int GetHashCode()

    9282. 

  9282. 			    {

    9283. 

  9283. 			        return 0;

    9284. 

  9284. 			    }

    9285. 

  9285. 			}

    9286. 

  9286. 			

    9287. 

  9287. 			public  class D : C, IEquatable<D>

    9288. 

  9288. 			{

    9289. 

  9289. 			    public int Val;

    9290. 

  9290. 			    public D()

    9291. 

  9291. 			    {

    9292. 

  9292. 			    }

    9293. 

  9293. 			    public D(int val)

    9294. 

  9294. 			    {

    9295. 

  9295. 			        Val = val;

    9296. 

  9296. 			    }

    9297. 

  9297. 			

    9298. 

  9298. 			    public override bool Equals(object o)

    9299. 

  9299. 			    {

    9300. 

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

    9301. 

  9301. 			    }

    9302. 

  9302. 			

    9303. 

  9303. 			    public bool Equals(D d)

    9304. 

  9304. 			    {

    9305. 

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

    9306. 

  9306. 			    }

    9307. 

  9307. 			

    9308. 

  9308. 			    public override int GetHashCode()

    9309. 

  9309. 			    {

    9310. 

  9310. 			        return Val;

    9311. 

  9311. 			    }

    9312. 

  9312. 			}

    9313. 

  9313. 			

    9314. 

  9314. 			public enum E

    9315. 

  9315. 			{

    9316. 

  9316. 			    A = 1, B = 2

    9317. 

  9317. 			}

    9318. 

  9318. 			

    9319. 

  9319. 			public enum El : long

    9320. 

  9320. 			{

    9321. 

  9321. 			    A, B, C

    9322. 

  9322. 			}

    9323. 

  9323. 			

    9324. 

  9324. 			public struct S : IEquatable<S>

    9325. 

  9325. 			{

    9326. 

  9326. 			    public override bool Equals(object o)

    9327. 

  9327. 			    {

    9328. 

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

    9329. 

  9329. 			    }

    9330. 

  9330. 			    public bool Equals(S other)

    9331. 

  9331. 			    {

    9332. 

  9332. 			        return true;

    9333. 

  9333. 			    }

    9334. 

  9334. 			    public override int GetHashCode()

    9335. 

  9335. 			    {

    9336. 

  9336. 			        return 0;

    9337. 

  9337. 			    }

    9338. 

  9338. 			}

    9339. 

  9339. 			

    9340. 

  9340. 			public struct Sp : IEquatable<Sp>

    9341. 

  9341. 			{

    9342. 

  9342. 			    public Sp(int i, double d)

    9343. 

  9343. 			    {

    9344. 

  9344. 			        I = i;

    9345. 

  9345. 			        D = d;

    9346. 

  9346. 			    }

    9347. 

  9347. 			

    9348. 

  9348. 			    public int I;

    9349. 

  9349. 			    public double D;

    9350. 

  9350. 			

    9351. 

  9351. 			    public override bool Equals(object o)

    9352. 

  9352. 			    {

    9353. 

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

    9354. 

  9354. 			    }

    9355. 

  9355. 			    public bool Equals(Sp other)

    9356. 

  9356. 			    {

    9357. 

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

    9358. 

  9358. 			    }

    9359. 

  9359. 			    public override int GetHashCode()

    9360. 

  9360. 			    {

    9361. 

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

    9362. 

  9362. 			    }

    9363. 

  9363. 			}

    9364. 

  9364. 			

    9365. 

  9365. 			public struct Ss : IEquatable<Ss>

    9366. 

  9366. 			{

    9367. 

  9367. 			    public Ss(S s)

    9368. 

  9368. 			    {

    9369. 

  9369. 			        Val = s;

    9370. 

  9370. 			    }

    9371. 

  9371. 			

    9372. 

  9372. 			    public S Val;

    9373. 

  9373. 			

    9374. 

  9374. 			    public override bool Equals(object o)

    9375. 

  9375. 			    {

    9376. 

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

    9377. 

  9377. 			    }

    9378. 

  9378. 			    public bool Equals(Ss other)

    9379. 

  9379. 			    {

    9380. 

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

    9381. 

  9381. 			    }

    9382. 

  9382. 			    public override int GetHashCode()

    9383. 

  9383. 			    {

    9384. 

  9384. 			        return Val.GetHashCode();

    9385. 

  9385. 			    }

    9386. 

  9386. 			}

    9387. 

  9387. 			

    9388. 

  9388. 			public struct Sc : IEquatable<Sc>

    9389. 

  9389. 			{

    9390. 

  9390. 			    public Sc(string s)

    9391. 

  9391. 			    {

    9392. 

  9392. 			        S = s;

    9393. 

  9393. 			    }

    9394. 

  9394. 			

    9395. 

  9395. 			    public string S;

    9396. 

  9396. 			

    9397. 

  9397. 			    public override bool Equals(object o)

    9398. 

  9398. 			    {

    9399. 

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

    9400. 

  9400. 			    }

    9401. 

  9401. 			    public bool Equals(Sc other)

    9402. 

  9402. 			    {

    9403. 

  9403. 			        return other.S == S;

    9404. 

  9404. 			    }

    9405. 

  9405. 			    public override int GetHashCode()

    9406. 

  9406. 			    {

    9407. 

  9407. 			        return S.GetHashCode();

    9408. 

  9408. 			    }

    9409. 

  9409. 			}

    9410. 

  9410. 			

    9411. 

  9411. 			public struct Scs : IEquatable<Scs>

    9412. 

  9412. 			{

    9413. 

  9413. 			    public Scs(string s, S val)

    9414. 

  9414. 			    {

    9415. 

  9415. 			        S = s;

    9416. 

  9416. 			        Val = val;

    9417. 

  9417. 			    }

    9418. 

  9418. 			

    9419. 

  9419. 			    public string S;

    9420. 

  9420. 			    public S Val;

    9421. 

  9421. 			

    9422. 

  9422. 			    public override bool Equals(object o)

    9423. 

  9423. 			    {

    9424. 

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

    9425. 

  9425. 			    }

    9426. 

  9426. 			    public bool Equals(Scs other)

    9427. 

  9427. 			    {

    9428. 

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

    9429. 

  9429. 			    }

    9430. 

  9430. 			    public override int GetHashCode()

    9431. 

  9431. 			    {

    9432. 

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

    9433. 

  9433. 			    }

    9434. 

  9434. 			}

    9435. 

  9435. 			

    9436. 

  9436. 		

    9437. 

  9437. 	}

    9438. 

  9438. 			

    9439. 

  9439. 			//-------- Scenario 3162

    9440. 

  9440. 			namespace Scenario3162{

    9441. 

  9441. 				

    9442. 

  9442. 				public class Test

    9443. 

  9443. 				{

    9444. 

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

    9445. 

  9445. 			    public static Expression Delegate_ArrayIndex__() {

    9446. 

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

    9447. 

  9447. 			           throw new Exception();

    9448. 

  9448. 			       } else { 

    9449. 

  9449. 			           return Expression.Constant(0);

    9450. 

  9450. 			       }

    9451. 

  9451. 			    }

    9452. 

  9452. 				public     static int Main()

    9453. 

  9453. 				    {

    9454. 

  9454. 				        Ext.StartCapture();

    9455. 

  9455. 				        bool success = false;

    9456. 

  9456. 				        try

    9457. 

  9457. 				        {

    9458. 

  9458. 				            success = check_Delegate_ArrayIndex();

    9459. 

  9459. 				        }

    9460. 

  9460. 				        finally

    9461. 

  9461. 				        {

    9462. 

  9462. 				            Ext.StopCapture();

    9463. 

  9463. 				        }

    9464. 

  9464. 				        return success ? 0 : 1;

    9465. 

  9465. 				    }

    9466. 

  9466. 				

    9467. 

  9467. 				    static bool check_Delegate_ArrayIndex()

    9468. 

  9468. 				    {

    9469. 

  9469. 				        return checkEx_Delegate_ArrayIndex(null, -1) &

    9470. 

  9470. 				            checkEx_Delegate_ArrayIndex(null, 0) &

    9471. 

  9471. 				            checkEx_Delegate_ArrayIndex(null, 1) &

    9472. 

  9472. 				

    9473. 

  9473. 				            check_Delegate_ArrayIndex(genArrDelegate_ArrayIndex(0)) &

    9474. 

  9474. 				            check_Delegate_ArrayIndex(genArrDelegate_ArrayIndex(1)) &

    9475. 

  9475. 				            check_Delegate_ArrayIndex(genArrDelegate_ArrayIndex(5));

    9476. 

  9476. 				    }

    9477. 

  9477. 				

    9478. 

  9478. 				    static Delegate[] genArrDelegate_ArrayIndex(int size)

    9479. 

  9479. 				    {

    9480. 

  9480. 				        Delegate[] vals = new Delegate[] { null, (Func<object>)delegate() { return null; }, (Func<int, int>)delegate(int i) { return i + 1; }, (Action<object>)delegate { } };

    9481. 

  9481. 				        Delegate[] result = new Delegate[size];

    9482. 

  9482. 				        for (int i = 0; i < size; i++)

    9483. 

  9483. 				        {

    9484. 

  9484. 				            result[i] = vals[i % vals.Length];

    9485. 

  9485. 				        }

    9486. 

  9486. 				        return result;

    9487. 

  9487. 				    }

    9488. 

  9488. 				

    9489. 

  9489. 				    static bool check_Delegate_ArrayIndex(Delegate[] val)

    9490. 

  9490. 				    {

    9491. 

  9491. 				        bool success = checkEx_Delegate_ArrayIndex(val, -1);

    9492. 

  9492. 				        for (int i = 0; i < val.Length; i++)

    9493. 

  9493. 				        {

    9494. 

  9494. 				            success &= check_Delegate_ArrayIndex(val, 0);

    9495. 

  9495. 				        }

    9496. 

  9496. 				        success &= checkEx_Delegate_ArrayIndex(val, val.Length);

    9497. 

  9497. 				        return success;

    9498. 

  9498. 				    }

    9499. 

  9499. 				

    9500. 

  9500. 				    static bool checkEx_Delegate_ArrayIndex(Delegate[] val, int index)

    9501. 

  9501. 				    {

    9502. 

  9502. 				        try

    9503. 

  9503. 				        {

    9504. 

  9504. 				            check_Delegate_ArrayIndex(val, index);

    9505. 

  9505. 				            Console.WriteLine("Delegate_ArrayIndex[" + index + "] failed");

    9506. 

  9506. 				            return false;

    9507. 

  9507. 				        }

    9508. 

  9508. 				        catch

    9509. 

  9509. 				        {

    9510. 

  9510. 				            return true;

    9511. 

  9511. 				        }

    9512. 

  9512. 				    }

    9513. 

  9513. 				

    9514. 

  9514. 				    static bool check_Delegate_ArrayIndex(Delegate[] val, int index)

    9515. 

  9515. 				    {

    9516. 

  9516. 				        Expression<Func<Delegate>> e =

    9517. 

  9517. 				            Expression.Lambda<Func<Delegate>>(

    9518. 

  9518. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(Delegate[])),

    9519. 

  9519. 				                    Expression.Constant(index, typeof(int))),

    9520. 

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

    9521. 

  9521. 				        Func<Delegate> f = e.Compile();

    9522. 

  9522. 				        return object.Equals(f(), val[index]);

    9523. 

  9523. 				    }

    9524. 

  9524. 				}

    9525. 

  9525. 			

    9526. 

  9526. 			

    9527. 

  9527. 			public  static class Ext {

    9528. 

  9528. 			    public static void StartCapture() {

    9529. 

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

    9530. 

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

    9531. 

  9531. 			    }

    9532. 

  9532. 			

    9533. 

  9533. 			    public static void StopCapture() {

    9534. 

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

    9535. 

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

    9536. 

  9536. 			    }

    9537. 

  9537. 			

    9538. 

  9538. 			    public static bool IsIntegralOrEnum(Type type) {

    9539. 

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

    9540. 

  9540. 			            case TypeCode.Byte:

    9541. 

  9541. 			            case TypeCode.SByte:

    9542. 

  9542. 			            case TypeCode.Int16:

    9543. 

  9543. 			            case TypeCode.Int32:

    9544. 

  9544. 			            case TypeCode.Int64:

    9545. 

  9545. 			            case TypeCode.UInt16:

    9546. 

  9546. 			            case TypeCode.UInt32:

    9547. 

  9547. 			            case TypeCode.UInt64:

    9548. 

  9548. 			                return true;

    9549. 

  9549. 			            default:

    9550. 

  9550. 			                return false;

    9551. 

  9551. 			        }

    9552. 

  9552. 			    }

    9553. 

  9553. 			

    9554. 

  9554. 			    public static bool IsFloating(Type type) {

    9555. 

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

    9556. 

  9556. 			            case TypeCode.Single:

    9557. 

  9557. 			            case TypeCode.Double:

    9558. 

  9558. 			                return true;

    9559. 

  9559. 			            default:

    9560. 

  9560. 			                return false;

    9561. 

  9561. 			        }

    9562. 

  9562. 			    }

    9563. 

  9563. 			

    9564. 

  9564. 			    public static Type GetNonNullableType(Type type) {

    9565. 

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

    9566. 

  9566. 			                type.GetGenericArguments()[0] :

    9567. 

  9567. 			                type;

    9568. 

  9568. 			    }

    9569. 

  9569. 			}

    9570. 

  9570. 			

    9571. 

  9571. 		

    9572. 

  9572. 	}

    9573. 

  9573. 			

    9574. 

  9574. 			//-------- Scenario 3163

    9575. 

  9575. 			namespace Scenario3163{

    9576. 

  9576. 				

    9577. 

  9577. 				public class Test

    9578. 

  9578. 				{

    9579. 

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

    9580. 

  9580. 			    public static Expression Func_object_ArrayIndex__() {

    9581. 

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

    9582. 

  9582. 			           throw new Exception();

    9583. 

  9583. 			       } else { 

    9584. 

  9584. 			           return Expression.Constant(0);

    9585. 

  9585. 			       }

    9586. 

  9586. 			    }

    9587. 

  9587. 				public     static int Main()

    9588. 

  9588. 				    {

    9589. 

  9589. 				        Ext.StartCapture();

    9590. 

  9590. 				        bool success = false;

    9591. 

  9591. 				        try

    9592. 

  9592. 				        {

    9593. 

  9593. 				            success = check_Func_object_ArrayIndex();

    9594. 

  9594. 				        }

    9595. 

  9595. 				        finally

    9596. 

  9596. 				        {

    9597. 

  9597. 				            Ext.StopCapture();

    9598. 

  9598. 				        }

    9599. 

  9599. 				        return success ? 0 : 1;

    9600. 

  9600. 				    }

    9601. 

  9601. 				

    9602. 

  9602. 				    static bool check_Func_object_ArrayIndex()

    9603. 

  9603. 				    {

    9604. 

  9604. 				        return checkEx_Func_object_ArrayIndex(null, -1) &

    9605. 

  9605. 				            checkEx_Func_object_ArrayIndex(null, 0) &

    9606. 

  9606. 				            checkEx_Func_object_ArrayIndex(null, 1) &

    9607. 

  9607. 				

    9608. 

  9608. 				            check_Func_object_ArrayIndex(genArrFunc_object_ArrayIndex(0)) &

    9609. 

  9609. 				            check_Func_object_ArrayIndex(genArrFunc_object_ArrayIndex(1)) &

    9610. 

  9610. 				            check_Func_object_ArrayIndex(genArrFunc_object_ArrayIndex(5));

    9611. 

  9611. 				    }

    9612. 

  9612. 				

    9613. 

  9613. 				    static Func<object>[] genArrFunc_object_ArrayIndex(int size)

    9614. 

  9614. 				    {

    9615. 

  9615. 				        Func<object>[] vals = new Func<object>[] { null, (Func<object>)delegate() { return null; } };

    9616. 

  9616. 				        Func<object>[] result = new Func<object>[size];

    9617. 

  9617. 				        for (int i = 0; i < size; i++)

    9618. 

  9618. 				        {

    9619. 

  9619. 				            result[i] = vals[i % vals.Length];

    9620. 

  9620. 				        }

    9621. 

  9621. 				        return result;

    9622. 

  9622. 				    }

    9623. 

  9623. 				

    9624. 

  9624. 				    static bool check_Func_object_ArrayIndex(Func<object>[] val)

    9625. 

  9625. 				    {

    9626. 

  9626. 				        bool success = checkEx_Func_object_ArrayIndex(val, -1);

    9627. 

  9627. 				        for (int i = 0; i < val.Length; i++)

    9628. 

  9628. 				        {

    9629. 

  9629. 				            success &= check_Func_object_ArrayIndex(val, 0);

    9630. 

  9630. 				        }

    9631. 

  9631. 				        success &= checkEx_Func_object_ArrayIndex(val, val.Length);

    9632. 

  9632. 				        return success;

    9633. 

  9633. 				    }

    9634. 

  9634. 				

    9635. 

  9635. 				    static bool checkEx_Func_object_ArrayIndex(Func<object>[] val, int index)

    9636. 

  9636. 				    {

    9637. 

  9637. 				        try

    9638. 

  9638. 				        {

    9639. 

  9639. 				            check_Func_object_ArrayIndex(val, index);

    9640. 

  9640. 				            Console.WriteLine("Func_object_ArrayIndex[" + index + "] failed");

    9641. 

  9641. 				            return false;

    9642. 

  9642. 				        }

    9643. 

  9643. 				        catch

    9644. 

  9644. 				        {

    9645. 

  9645. 				            return true;

    9646. 

  9646. 				        }

    9647. 

  9647. 				    }

    9648. 

  9648. 				

    9649. 

  9649. 				    static bool check_Func_object_ArrayIndex(Func<object>[] val, int index)

    9650. 

  9650. 				    {

    9651. 

  9651. 				        Expression<Func<Func<object>>> e =

    9652. 

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

    9653. 

  9653. 				                Expression.ArrayIndex(Expression.Constant(val, typeof(Func<object>[])),

    9654. 

  9654. 				                    Expression.Constant(index, typeof(int))),

    9655. 

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

    9656. 

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

    9657. 

  9657. 				        return object.Equals(f(), val[index]);

    9658. 

  9658. 				    }

    9659. 

  9659. 				}

    9660. 

  9660. 			

    9661. 

  9661. 			

    9662. 

  9662. 			public  static class Ext {

    9663. 

  9663. 			    public static void StartCapture() {

    9664. 

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

    9665. 

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

    9666. 

  9666. 			    }

    9667. 

  9667. 			

    9668. 

  9668. 			    public static void StopCapture() {

    9669. 

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

    9670. 

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

    9671. 

  9671. 			    }

    9672. 

  9672. 			

    9673. 

  9673. 			    public static bool IsIntegralOrEnum(Type type) {

    9674. 

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

    9675. 

  9675. 			            case TypeCode.Byte:

    9676. 

  9676. 			            case TypeCode.SByte:

    9677. 

  9677. 			            case TypeCode.Int16:

    9678. 

  9678. 			            case TypeCode.Int32:

    9679. 

  9679. 			            case TypeCode.Int64:

    9680. 

  9680. 			            case TypeCode.UInt16:

    9681. 

  9681. 			            case TypeCode.UInt32:

    9682. 

  9682. 			            case TypeCode.UInt64:

    9683. 

  9683. 			                return true;

    9684. 

  9684. 			            default:

    9685. 

  9685. 			                return false;

    9686. 

  9686. 			        }

    9687. 

  9687. 			    }

    9688. 

  9688. 			

    9689. 

  9689. 			    public static bool IsFloating(Type type) {

    9690. 

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

    9691. 

  9691. 			            case TypeCode.Single:

    9692. 

  9692. 			            case TypeCode.Double:

    9693. 

  9693. 			                return true;

    9694. 

  9694. 			            default:

    9695. 

  9695. 			                return false;

    9696. 

  9696. 			        }

    9697. 

  9697. 			    }

    9698. 

  9698. 			

    9699. 

  9699. 			    public static Type GetNonNullableType(Type type) {

    9700. 

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

    9701. 

  9701. 			                type.GetGenericArguments()[0] :

    9702. 

  9702. 			                type;

    9703. 

  9703. 			    }

    9704. 

  9704. 			}

    9705. 

  9705. 			

    9706. 

  9706. 		

    9707. 

  9707. 	}

    9708. 

  9708. 				

    9709. 

  9709. 				//-------- Scenario 3164

    9710. 

  9710. 				namespace Scenario3164{

    9711. 

  9711. 					

    9712. 

  9712. 					public class Test

    9713. 

  9713. 					{

    9714. 

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

    9715. 

  9715. 				    public static Expression IEquatable_C_ArrayIndex__() {

    9716. 

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

    9717. 

  9717. 				           throw new Exception();

    9718. 

  9718. 				       } else { 

    9719. 

  9719. 				           return Expression.Constant(0);

    9720. 

  9720. 				       }

    9721. 

  9721. 				    }

    9722. 

  9722. 					public     static int Main()

    9723. 

  9723. 					    {

    9724. 

  9724. 					        Ext.StartCapture();

    9725. 

  9725. 					        bool success = false;

    9726. 

  9726. 					        try

    9727. 

  9727. 					        {

    9728. 

  9728. 					            success = check_IEquatable_C_ArrayIndex();

    9729. 

  9729. 					        }

    9730. 

  9730. 					        finally

    9731. 

  9731. 					        {

    9732. 

  9732. 					            Ext.StopCapture();

    9733. 

  9733. 					        }

    9734. 

  9734. 					        return success ? 0 : 1;

    9735. 

  9735. 					    }

    9736. 

  9736. 					

    9737. 

  9737. 					    static bool check_IEquatable_C_ArrayIndex()

    9738. 

  9738. 					    {

    9739. 

  9739. 					        return checkEx_IEquatable_C_ArrayIndex(null, -1) &

    9740. 

  9740. 					            checkEx_IEquatable_C_ArrayIndex(null, 0) &

    9741. 

  9741. 					            checkEx_IEquatable_C_ArrayIndex(null, 1) &

    9742. 

  9742. 					

    9743. 

  9743. 					            check_IEquatable_C_ArrayIndex(genArrIEquatable_C_ArrayIndex(0)) &

    9744. 

  9744. 					            check_IEquatable_C_ArrayIndex(genArrIEquatable_C_ArrayIndex(1)) &

    9745. 

  9745. 					            check_IEquatable_C_ArrayIndex(genArrIEquatable_C_ArrayIndex(5));

    9746. 

  9746. 					    }

    9747. 

  9747. 					

    9748. 

  9748. 					    static IEquatable<C>[] genArrIEquatable_C_ArrayIndex(int size)

    9749. 

  9749. 					    {

    9750. 

  9750. 					        IEquatable<C>[] vals = new IEquatable<C>[] { null, new C(), new D(), new D(0), new D(5) };

    9751. 

  9751. 					        IEquatable<C>[] result = new IEquatable<C>[size];

    9752. 

  9752. 					        for (int i = 0; i < size; i++)

    9753. 

  9753. 					        {

    9754. 

  9754. 					            result[i] = vals[i % vals.Length];

    9755. 

  9755. 					        }

    9756. 

  9756. 					        return result;

    9757. 

  9757. 					    }

    9758. 

  9758. 					

    9759. 

  9759. 					    static bool check_IEquatable_C_ArrayIndex(IEquatable<C>[] val)

    9760. 

  9760. 					    {

    9761. 

  9761. 					        bool success = checkEx_IEquatable_C_ArrayIndex(val, -1);

    9762. 

  9762. 					        for (int i = 0; i < val.Length; i++)

    9763. 

  9763. 					        {

    9764. 

  9764. 					            success &= check_IEquatable_C_ArrayIndex(val, 0);

    9765. 

  9765. 					        }

    9766. 

  9766. 					        success &= checkEx_IEquatable_C_ArrayIndex(val, val.Length);

    9767. 

  9767. 					        return success;

    9768. 

  9768. 					    }

    9769. 

  9769. 					

    9770. 

  9770. 					    static bool checkEx_IEquatable_C_ArrayIndex(IEquatable<C>[] val, int index)

    9771. 

  9771. 					    {

    9772. 

  9772. 					        try

    9773. 

  9773. 					        {

    9774. 

  9774. 					            check_IEquatable_C_ArrayIndex(val, index);

    9775. 

  9775. 					            Console.WriteLine("IEquatable_C_ArrayIndex[" + index + "] failed");

    9776. 

  9776. 					            return false;

    9777. 

  9777. 					        }

    9778. 

  9778. 					        catch

    9779. 

  9779. 					        {

    9780. 

  9780. 					            return true;

    9781. 

  9781. 					        }

    9782. 

  9782. 					    }

    9783. 

  9783. 					

    9784. 

  9784. 					    static bool check_IEquatable_C_ArrayIndex(IEquatable<C>[] val, int index)

    9785. 

  9785. 					    {

    9786. 

  9786. 					        Expression<Func<IEquatable<C>>> e =

    9787. 

  9787. 					            Expression.Lambda<Func<IEquatable<C>>>(

    9788. 

  9788. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(IEquatable<C>[])),

    9789. 

  9789. 					                    Expression.Constant(index, typeof(int))),

    9790. 

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

    9791. 

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

    9792. 

  9792. 					        return object.Equals(f(), val[index]);

    9793. 

  9793. 					    }

    9794. 

  9794. 					}

    9795. 

  9795. 				

    9796. 

  9796. 				

    9797. 

  9797. 				public  static class Ext {

    9798. 

  9798. 				    public static void StartCapture() {

    9799. 

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

    9800. 

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

    9801. 

  9801. 				    }

    9802. 

  9802. 				

    9803. 

  9803. 				    public static void StopCapture() {

    9804. 

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

    9805. 

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

    9806. 

  9806. 				    }

    9807. 

  9807. 				

    9808. 

  9808. 				    public static bool IsIntegralOrEnum(Type type) {

    9809. 

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

    9810. 

  9810. 				            case TypeCode.Byte:

    9811. 

  9811. 				            case TypeCode.SByte:

    9812. 

  9812. 				            case TypeCode.Int16:

    9813. 

  9813. 				            case TypeCode.Int32:

    9814. 

  9814. 				            case TypeCode.Int64:

    9815. 

  9815. 				            case TypeCode.UInt16:

    9816. 

  9816. 				            case TypeCode.UInt32:

    9817. 

  9817. 				            case TypeCode.UInt64:

    9818. 

  9818. 				                return true;

    9819. 

  9819. 				            default:

    9820. 

  9820. 				                return false;

    9821. 

  9821. 				        }

    9822. 

  9822. 				    }

    9823. 

  9823. 				

    9824. 

  9824. 				    public static bool IsFloating(Type type) {

    9825. 

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

    9826. 

  9826. 				            case TypeCode.Single:

    9827. 

  9827. 				            case TypeCode.Double:

    9828. 

  9828. 				                return true;

    9829. 

  9829. 				            default:

    9830. 

  9830. 				                return false;

    9831. 

  9831. 				        }

    9832. 

  9832. 				    }

    9833. 

  9833. 				

    9834. 

  9834. 				    public static Type GetNonNullableType(Type type) {

    9835. 

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

    9836. 

  9836. 				                type.GetGenericArguments()[0] :

    9837. 

  9837. 				                type;

    9838. 

  9838. 				    }

    9839. 

  9839. 				}

    9840. 

  9840. 				

    9841. 

  9841. 			

    9842. 

  9842. 			

    9843. 

  9843. 			

    9844. 

  9844. 			public interface I

    9845. 

  9845. 			{

    9846. 

  9846. 			    void M();

    9847. 

  9847. 			}

    9848. 

  9848. 			

    9849. 

  9849. 			public  class C : IEquatable<C>, I

    9850. 

  9850. 			{

    9851. 

  9851. 			    void I.M()

    9852. 

  9852. 			    {

    9853. 

  9853. 			    }

    9854. 

  9854. 			

    9855. 

  9855. 			    public override bool Equals(object o)

    9856. 

  9856. 			    {

    9857. 

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

    9858. 

  9858. 			    }

    9859. 

  9859. 			

    9860. 

  9860. 			    public bool Equals(C c)

    9861. 

  9861. 			    {

    9862. 

  9862. 			        return c != null;

    9863. 

  9863. 			    }

    9864. 

  9864. 			

    9865. 

  9865. 			    public override int GetHashCode()

    9866. 

  9866. 			    {

    9867. 

  9867. 			        return 0;

    9868. 

  9868. 			    }

    9869. 

  9869. 			}

    9870. 

  9870. 			

    9871. 

  9871. 			public  class D : C, IEquatable<D>

    9872. 

  9872. 			{

    9873. 

  9873. 			    public int Val;

    9874. 

  9874. 			    public D()

    9875. 

  9875. 			    {

    9876. 

  9876. 			    }

    9877. 

  9877. 			    public D(int val)

    9878. 

  9878. 			    {

    9879. 

  9879. 			        Val = val;

    9880. 

  9880. 			    }

    9881. 

  9881. 			

    9882. 

  9882. 			    public override bool Equals(object o)

    9883. 

  9883. 			    {

    9884. 

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

    9885. 

  9885. 			    }

    9886. 

  9886. 			

    9887. 

  9887. 			    public bool Equals(D d)

    9888. 

  9888. 			    {

    9889. 

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

    9890. 

  9890. 			    }

    9891. 

  9891. 			

    9892. 

  9892. 			    public override int GetHashCode()

    9893. 

  9893. 			    {

    9894. 

  9894. 			        return Val;

    9895. 

  9895. 			    }

    9896. 

  9896. 			}

    9897. 

  9897. 			

    9898. 

  9898. 			public enum E

    9899. 

  9899. 			{

    9900. 

  9900. 			    A = 1, B = 2

    9901. 

  9901. 			}

    9902. 

  9902. 			

    9903. 

  9903. 			public enum El : long

    9904. 

  9904. 			{

    9905. 

  9905. 			    A, B, C

    9906. 

  9906. 			}

    9907. 

  9907. 			

    9908. 

  9908. 			public struct S : IEquatable<S>

    9909. 

  9909. 			{

    9910. 

  9910. 			    public override bool Equals(object o)

    9911. 

  9911. 			    {

    9912. 

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

    9913. 

  9913. 			    }

    9914. 

  9914. 			    public bool Equals(S other)

    9915. 

  9915. 			    {

    9916. 

  9916. 			        return true;

    9917. 

  9917. 			    }

    9918. 

  9918. 			    public override int GetHashCode()

    9919. 

  9919. 			    {

    9920. 

  9920. 			        return 0;

    9921. 

  9921. 			    }

    9922. 

  9922. 			}

    9923. 

  9923. 			

    9924. 

  9924. 			public struct Sp : IEquatable<Sp>

    9925. 

  9925. 			{

    9926. 

  9926. 			    public Sp(int i, double d)

    9927. 

  9927. 			    {

    9928. 

  9928. 			        I = i;

    9929. 

  9929. 			        D = d;

    9930. 

  9930. 			    }

    9931. 

  9931. 			

    9932. 

  9932. 			    public int I;

    9933. 

  9933. 			    public double D;

    9934. 

  9934. 			

    9935. 

  9935. 			    public override bool Equals(object o)

    9936. 

  9936. 			    {

    9937. 

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

    9938. 

  9938. 			    }

    9939. 

  9939. 			    public bool Equals(Sp other)

    9940. 

  9940. 			    {

    9941. 

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

    9942. 

  9942. 			    }

    9943. 

  9943. 			    public override int GetHashCode()

    9944. 

  9944. 			    {

    9945. 

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

    9946. 

  9946. 			    }

    9947. 

  9947. 			}

    9948. 

  9948. 			

    9949. 

  9949. 			public struct Ss : IEquatable<Ss>

    9950. 

  9950. 			{

    9951. 

  9951. 			    public Ss(S s)

    9952. 

  9952. 			    {

    9953. 

  9953. 			        Val = s;

    9954. 

  9954. 			    }

    9955. 

  9955. 			

    9956. 

  9956. 			    public S Val;

    9957. 

  9957. 			

    9958. 

  9958. 			    public override bool Equals(object o)

    9959. 

  9959. 			    {

    9960. 

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

    9961. 

  9961. 			    }

    9962. 

  9962. 			    public bool Equals(Ss other)

    9963. 

  9963. 			    {

    9964. 

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

    9965. 

  9965. 			    }

    9966. 

  9966. 			    public override int GetHashCode()

    9967. 

  9967. 			    {

    9968. 

  9968. 			        return Val.GetHashCode();

    9969. 

  9969. 			    }

    9970. 

  9970. 			}

    9971. 

  9971. 			

    9972. 

  9972. 			public struct Sc : IEquatable<Sc>

    9973. 

  9973. 			{

    9974. 

  9974. 			    public Sc(string s)

    9975. 

  9975. 			    {

    9976. 

  9976. 			        S = s;

    9977. 

  9977. 			    }

    9978. 

  9978. 			

    9979. 

  9979. 			    public string S;

    9980. 

  9980. 			

    9981. 

  9981. 			    public override bool Equals(object o)

    9982. 

  9982. 			    {

    9983. 

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

    9984. 

  9984. 			    }

    9985. 

  9985. 			    public bool Equals(Sc other)

    9986. 

  9986. 			    {

    9987. 

  9987. 			        return other.S == S;

    9988. 

  9988. 			    }

    9989. 

  9989. 			    public override int GetHashCode()

    9990. 

  9990. 			    {

    9991. 

  9991. 			        return S.GetHashCode();

    9992. 

  9992. 			    }

    9993. 

  9993. 			}

    9994. 

  9994. 			

    9995. 

  9995. 			public struct Scs : IEquatable<Scs>

    9996. 

  9996. 			{

    9997. 

  9997. 			    public Scs(string s, S val)

    9998. 

  9998. 			    {

    9999. 

  9999. 			        S = s;

    10000. 

  10000. 			        Val = val;

    10001. 

  10001. 			    }

    10002. 

  10002. 			

    10003. 

  10003. 			    public string S;

    10004. 

  10004. 			    public S Val;

    10005. 

  10005. 			

    10006. 

  10006. 			    public override bool Equals(object o)

    10007. 

  10007. 			    {

    10008. 

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

    10009. 

  10009. 			    }

    10010. 

  10010. 			    public bool Equals(Scs other)

    10011. 

  10011. 			    {

    10012. 

  10012. 			        return other.S == S && other.Val.Equals(Val);

    10013. 

  10013. 			    }

    10014. 

  10014. 			    public override int GetHashCode()

    10015. 

  10015. 			    {

    10016. 

  10016. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10017. 

  10017. 			    }

    10018. 

  10018. 			}

    10019. 

  10019. 			

    10020. 

  10020. 		

    10021. 

  10021. 	}

    10022. 

  10022. 				

    10023. 

  10023. 				//-------- Scenario 3165

    10024. 

  10024. 				namespace Scenario3165{

    10025. 

  10025. 					

    10026. 

  10026. 					public class Test

    10027. 

  10027. 					{

    10028. 

  10028. 				    [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "IEquatable_D_ArrayIndex__", new string[] { "positive", "cslinq", "FullTrustOnly","Pri1" })]

    10029. 

  10029. 				    public static Expression IEquatable_D_ArrayIndex__() {

    10030. 

  10030. 				       if(Main() != 0 ) {

    10031. 

  10031. 				           throw new Exception();

    10032. 

  10032. 				       } else { 

    10033. 

  10033. 				           return Expression.Constant(0);

    10034. 

  10034. 				       }

    10035. 

  10035. 				    }

    10036. 

  10036. 					public     static int Main()

    10037. 

  10037. 					    {

    10038. 

  10038. 					        Ext.StartCapture();

    10039. 

  10039. 					        bool success = false;

    10040. 

  10040. 					        try

    10041. 

  10041. 					        {

    10042. 

  10042. 					            success = check_IEquatable_D_ArrayIndex();

    10043. 

  10043. 					        }

    10044. 

  10044. 					        finally

    10045. 

  10045. 					        {

    10046. 

  10046. 					            Ext.StopCapture();

    10047. 

  10047. 					        }

    10048. 

  10048. 					        return success ? 0 : 1;

    10049. 

  10049. 					    }

    10050. 

  10050. 					

    10051. 

  10051. 					    static bool check_IEquatable_D_ArrayIndex()

    10052. 

  10052. 					    {

    10053. 

  10053. 					        return checkEx_IEquatable_D_ArrayIndex(null, -1) &

    10054. 

  10054. 					            checkEx_IEquatable_D_ArrayIndex(null, 0) &

    10055. 

  10055. 					            checkEx_IEquatable_D_ArrayIndex(null, 1) &

    10056. 

  10056. 					

    10057. 

  10057. 					            check_IEquatable_D_ArrayIndex(genArrIEquatable_D_ArrayIndex(0)) &

    10058. 

  10058. 					            check_IEquatable_D_ArrayIndex(genArrIEquatable_D_ArrayIndex(1)) &

    10059. 

  10059. 					            check_IEquatable_D_ArrayIndex(genArrIEquatable_D_ArrayIndex(5));

    10060. 

  10060. 					    }

    10061. 

  10061. 					

    10062. 

  10062. 					    static IEquatable<D>[] genArrIEquatable_D_ArrayIndex(int size)

    10063. 

  10063. 					    {

    10064. 

  10064. 					        IEquatable<D>[] vals = new IEquatable<D>[] { null, new D(), new D(0), new D(5) };

    10065. 

  10065. 					        IEquatable<D>[] result = new IEquatable<D>[size];

    10066. 

  10066. 					        for (int i = 0; i < size; i++)

    10067. 

  10067. 					        {

    10068. 

  10068. 					            result[i] = vals[i % vals.Length];

    10069. 

  10069. 					        }

    10070. 

  10070. 					        return result;

    10071. 

  10071. 					    }

    10072. 

  10072. 					

    10073. 

  10073. 					    static bool check_IEquatable_D_ArrayIndex(IEquatable<D>[] val)

    10074. 

  10074. 					    {

    10075. 

  10075. 					        bool success = checkEx_IEquatable_D_ArrayIndex(val, -1);

    10076. 

  10076. 					        for (int i = 0; i < val.Length; i++)

    10077. 

  10077. 					        {

    10078. 

  10078. 					            success &= check_IEquatable_D_ArrayIndex(val, 0);

    10079. 

  10079. 					        }

    10080. 

  10080. 					        success &= checkEx_IEquatable_D_ArrayIndex(val, val.Length);

    10081. 

  10081. 					        return success;

    10082. 

  10082. 					    }

    10083. 

  10083. 					

    10084. 

  10084. 					    static bool checkEx_IEquatable_D_ArrayIndex(IEquatable<D>[] val, int index)

    10085. 

  10085. 					    {

    10086. 

  10086. 					        try

    10087. 

  10087. 					        {

    10088. 

  10088. 					            check_IEquatable_D_ArrayIndex(val, index);

    10089. 

  10089. 					            Console.WriteLine("IEquatable_D_ArrayIndex[" + index + "] failed");

    10090. 

  10090. 					            return false;

    10091. 

  10091. 					        }

    10092. 

  10092. 					        catch

    10093. 

  10093. 					        {

    10094. 

  10094. 					            return true;

    10095. 

  10095. 					        }

    10096. 

  10096. 					    }

    10097. 

  10097. 					

    10098. 

  10098. 					    static bool check_IEquatable_D_ArrayIndex(IEquatable<D>[] val, int index)

    10099. 

  10099. 					    {

    10100. 

  10100. 					        Expression<Func<IEquatable<D>>> e =

    10101. 

  10101. 					            Expression.Lambda<Func<IEquatable<D>>>(

    10102. 

  10102. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(IEquatable<D>[])),

    10103. 

  10103. 					                    Expression.Constant(index, typeof(int))),

    10104. 

  10104. 					                new System.Collections.Generic.List<ParameterExpression>());

    10105. 

  10105. 					        Func<IEquatable<D>> f = e.Compile();

    10106. 

  10106. 					        return object.Equals(f(), val[index]);

    10107. 

  10107. 					    }

    10108. 

  10108. 					}

    10109. 

  10109. 				

    10110. 

  10110. 				

    10111. 

  10111. 				public  static class Ext {

    10112. 

  10112. 				    public static void StartCapture() {

    10113. 

  10113. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10114. 

  10114. 				//        m.Invoke(null, new object[] { "test.dll" });

    10115. 

  10115. 				    }

    10116. 

  10116. 				

    10117. 

  10117. 				    public static void StopCapture() {

    10118. 

  10118. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10119. 

  10119. 				//        m.Invoke(null, new object[0]);

    10120. 

  10120. 				    }

    10121. 

  10121. 				

    10122. 

  10122. 				    public static bool IsIntegralOrEnum(Type type) {

    10123. 

  10123. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10124. 

  10124. 				            case TypeCode.Byte:

    10125. 

  10125. 				            case TypeCode.SByte:

    10126. 

  10126. 				            case TypeCode.Int16:

    10127. 

  10127. 				            case TypeCode.Int32:

    10128. 

  10128. 				            case TypeCode.Int64:

    10129. 

  10129. 				            case TypeCode.UInt16:

    10130. 

  10130. 				            case TypeCode.UInt32:

    10131. 

  10131. 				            case TypeCode.UInt64:

    10132. 

  10132. 				                return true;

    10133. 

  10133. 				            default:

    10134. 

  10134. 				                return false;

    10135. 

  10135. 				        }

    10136. 

  10136. 				    }

    10137. 

  10137. 				

    10138. 

  10138. 				    public static bool IsFloating(Type type) {

    10139. 

  10139. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10140. 

  10140. 				            case TypeCode.Single:

    10141. 

  10141. 				            case TypeCode.Double:

    10142. 

  10142. 				                return true;

    10143. 

  10143. 				            default:

    10144. 

  10144. 				                return false;

    10145. 

  10145. 				        }

    10146. 

  10146. 				    }

    10147. 

  10147. 				

    10148. 

  10148. 				    public static Type GetNonNullableType(Type type) {

    10149. 

  10149. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10150. 

  10150. 				                type.GetGenericArguments()[0] :

    10151. 

  10151. 				                type;

    10152. 

  10152. 				    }

    10153. 

  10153. 				}

    10154. 

  10154. 				

    10155. 

  10155. 			

    10156. 

  10156. 			

    10157. 

  10157. 			

    10158. 

  10158. 			public interface I

    10159. 

  10159. 			{

    10160. 

  10160. 			    void M();

    10161. 

  10161. 			}

    10162. 

  10162. 			

    10163. 

  10163. 			public  class C : IEquatable<C>, I

    10164. 

  10164. 			{

    10165. 

  10165. 			    void I.M()

    10166. 

  10166. 			    {

    10167. 

  10167. 			    }

    10168. 

  10168. 			

    10169. 

  10169. 			    public override bool Equals(object o)

    10170. 

  10170. 			    {

    10171. 

  10171. 			        return o is C && Equals((C)o);

    10172. 

  10172. 			    }

    10173. 

  10173. 			

    10174. 

  10174. 			    public bool Equals(C c)

    10175. 

  10175. 			    {

    10176. 

  10176. 			        return c != null;

    10177. 

  10177. 			    }

    10178. 

  10178. 			

    10179. 

  10179. 			    public override int GetHashCode()

    10180. 

  10180. 			    {

    10181. 

  10181. 			        return 0;

    10182. 

  10182. 			    }

    10183. 

  10183. 			}

    10184. 

  10184. 			

    10185. 

  10185. 			public  class D : C, IEquatable<D>

    10186. 

  10186. 			{

    10187. 

  10187. 			    public int Val;

    10188. 

  10188. 			    public D()

    10189. 

  10189. 			    {

    10190. 

  10190. 			    }

    10191. 

  10191. 			    public D(int val)

    10192. 

  10192. 			    {

    10193. 

  10193. 			        Val = val;

    10194. 

  10194. 			    }

    10195. 

  10195. 			

    10196. 

  10196. 			    public override bool Equals(object o)

    10197. 

  10197. 			    {

    10198. 

  10198. 			        return o is D && Equals((D)o);

    10199. 

  10199. 			    }

    10200. 

  10200. 			

    10201. 

  10201. 			    public bool Equals(D d)

    10202. 

  10202. 			    {

    10203. 

  10203. 			        return d != null && d.Val == Val;

    10204. 

  10204. 			    }

    10205. 

  10205. 			

    10206. 

  10206. 			    public override int GetHashCode()

    10207. 

  10207. 			    {

    10208. 

  10208. 			        return Val;

    10209. 

  10209. 			    }

    10210. 

  10210. 			}

    10211. 

  10211. 			

    10212. 

  10212. 			public enum E

    10213. 

  10213. 			{

    10214. 

  10214. 			    A = 1, B = 2

    10215. 

  10215. 			}

    10216. 

  10216. 			

    10217. 

  10217. 			public enum El : long

    10218. 

  10218. 			{

    10219. 

  10219. 			    A, B, C

    10220. 

  10220. 			}

    10221. 

  10221. 			

    10222. 

  10222. 			public struct S : IEquatable<S>

    10223. 

  10223. 			{

    10224. 

  10224. 			    public override bool Equals(object o)

    10225. 

  10225. 			    {

    10226. 

  10226. 			        return (o is S) && Equals((S)o);

    10227. 

  10227. 			    }

    10228. 

  10228. 			    public bool Equals(S other)

    10229. 

  10229. 			    {

    10230. 

  10230. 			        return true;

    10231. 

  10231. 			    }

    10232. 

  10232. 			    public override int GetHashCode()

    10233. 

  10233. 			    {

    10234. 

  10234. 			        return 0;

    10235. 

  10235. 			    }

    10236. 

  10236. 			}

    10237. 

  10237. 			

    10238. 

  10238. 			public struct Sp : IEquatable<Sp>

    10239. 

  10239. 			{

    10240. 

  10240. 			    public Sp(int i, double d)

    10241. 

  10241. 			    {

    10242. 

  10242. 			        I = i;

    10243. 

  10243. 			        D = d;

    10244. 

  10244. 			    }

    10245. 

  10245. 			

    10246. 

  10246. 			    public int I;

    10247. 

  10247. 			    public double D;

    10248. 

  10248. 			

    10249. 

  10249. 			    public override bool Equals(object o)

    10250. 

  10250. 			    {

    10251. 

  10251. 			        return (o is Sp) && Equals((Sp)o);

    10252. 

  10252. 			    }

    10253. 

  10253. 			    public bool Equals(Sp other)

    10254. 

  10254. 			    {

    10255. 

  10255. 			        return other.I == I && other.D == D;

    10256. 

  10256. 			    }

    10257. 

  10257. 			    public override int GetHashCode()

    10258. 

  10258. 			    {

    10259. 

  10259. 			        return I.GetHashCode() ^ D.GetHashCode();

    10260. 

  10260. 			    }

    10261. 

  10261. 			}

    10262. 

  10262. 			

    10263. 

  10263. 			public struct Ss : IEquatable<Ss>

    10264. 

  10264. 			{

    10265. 

  10265. 			    public Ss(S s)

    10266. 

  10266. 			    {

    10267. 

  10267. 			        Val = s;

    10268. 

  10268. 			    }

    10269. 

  10269. 			

    10270. 

  10270. 			    public S Val;

    10271. 

  10271. 			

    10272. 

  10272. 			    public override bool Equals(object o)

    10273. 

  10273. 			    {

    10274. 

  10274. 			        return (o is Ss) && Equals((Ss)o);

    10275. 

  10275. 			    }

    10276. 

  10276. 			    public bool Equals(Ss other)

    10277. 

  10277. 			    {

    10278. 

  10278. 			        return other.Val.Equals(Val);

    10279. 

  10279. 			    }

    10280. 

  10280. 			    public override int GetHashCode()

    10281. 

  10281. 			    {

    10282. 

  10282. 			        return Val.GetHashCode();

    10283. 

  10283. 			    }

    10284. 

  10284. 			}

    10285. 

  10285. 			

    10286. 

  10286. 			public struct Sc : IEquatable<Sc>

    10287. 

  10287. 			{

    10288. 

  10288. 			    public Sc(string s)

    10289. 

  10289. 			    {

    10290. 

  10290. 			        S = s;

    10291. 

  10291. 			    }

    10292. 

  10292. 			

    10293. 

  10293. 			    public string S;

    10294. 

  10294. 			

    10295. 

  10295. 			    public override bool Equals(object o)

    10296. 

  10296. 			    {

    10297. 

  10297. 			        return (o is Sc) && Equals((Sc)o);

    10298. 

  10298. 			    }

    10299. 

  10299. 			    public bool Equals(Sc other)

    10300. 

  10300. 			    {

    10301. 

  10301. 			        return other.S == S;

    10302. 

  10302. 			    }

    10303. 

  10303. 			    public override int GetHashCode()

    10304. 

  10304. 			    {

    10305. 

  10305. 			        return S.GetHashCode();

    10306. 

  10306. 			    }

    10307. 

  10307. 			}

    10308. 

  10308. 			

    10309. 

  10309. 			public struct Scs : IEquatable<Scs>

    10310. 

  10310. 			{

    10311. 

  10311. 			    public Scs(string s, S val)

    10312. 

  10312. 			    {

    10313. 

  10313. 			        S = s;

    10314. 

  10314. 			        Val = val;

    10315. 

  10315. 			    }

    10316. 

  10316. 			

    10317. 

  10317. 			    public string S;

    10318. 

  10318. 			    public S Val;

    10319. 

  10319. 			

    10320. 

  10320. 			    public override bool Equals(object o)

    10321. 

  10321. 			    {

    10322. 

  10322. 			        return (o is Scs) && Equals((Scs)o);

    10323. 

  10323. 			    }

    10324. 

  10324. 			    public bool Equals(Scs other)

    10325. 

  10325. 			    {

    10326. 

  10326. 			        return other.S == S && other.Val.Equals(Val);

    10327. 

  10327. 			    }

    10328. 

  10328. 			    public override int GetHashCode()

    10329. 

  10329. 			    {

    10330. 

  10330. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10331. 

  10331. 			    }

    10332. 

  10332. 			}

    10333. 

  10333. 			

    10334. 

  10334. 		

    10335. 

  10335. 	}

    10336. 

  10336. 				

    10337. 

  10337. 				//-------- Scenario 3166

    10338. 

  10338. 				namespace Scenario3166{

    10339. 

  10339. 					

    10340. 

  10340. 					public class Test

    10341. 

  10341. 					{

    10342. 

  10342. 				    [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "I_ArrayIndex__", new string[] { "positive", "cslinq", "FullTrustOnly","Pri1" })]

    10343. 

  10343. 				    public static Expression I_ArrayIndex__() {

    10344. 

  10344. 				       if(Main() != 0 ) {

    10345. 

  10345. 				           throw new Exception();

    10346. 

  10346. 				       } else { 

    10347. 

  10347. 				           return Expression.Constant(0);

    10348. 

  10348. 				       }

    10349. 

  10349. 				    }

    10350. 

  10350. 					public     static int Main()

    10351. 

  10351. 					    {

    10352. 

  10352. 					        Ext.StartCapture();

    10353. 

  10353. 					        bool success = false;

    10354. 

  10354. 					        try

    10355. 

  10355. 					        {

    10356. 

  10356. 					            success = check_I_ArrayIndex();

    10357. 

  10357. 					        }

    10358. 

  10358. 					        finally

    10359. 

  10359. 					        {

    10360. 

  10360. 					            Ext.StopCapture();

    10361. 

  10361. 					        }

    10362. 

  10362. 					        return success ? 0 : 1;

    10363. 

  10363. 					    }

    10364. 

  10364. 					

    10365. 

  10365. 					    static bool check_I_ArrayIndex()

    10366. 

  10366. 					    {

    10367. 

  10367. 					        return checkEx_I_ArrayIndex(null, -1) &

    10368. 

  10368. 					            checkEx_I_ArrayIndex(null, 0) &

    10369. 

  10369. 					            checkEx_I_ArrayIndex(null, 1) &

    10370. 

  10370. 					

    10371. 

  10371. 					            check_I_ArrayIndex(genArrI_ArrayIndex(0)) &

    10372. 

  10372. 					            check_I_ArrayIndex(genArrI_ArrayIndex(1)) &

    10373. 

  10373. 					            check_I_ArrayIndex(genArrI_ArrayIndex(5));

    10374. 

  10374. 					    }

    10375. 

  10375. 					

    10376. 

  10376. 					    static I[] genArrI_ArrayIndex(int size)

    10377. 

  10377. 					    {

    10378. 

  10378. 					        I[] vals = new I[] { null, new C(), new D(), new D(0), new D(5) };

    10379. 

  10379. 					        I[] result = new I[size];

    10380. 

  10380. 					        for (int i = 0; i < size; i++)

    10381. 

  10381. 					        {

    10382. 

  10382. 					            result[i] = vals[i % vals.Length];

    10383. 

  10383. 					        }

    10384. 

  10384. 					        return result;

    10385. 

  10385. 					    }

    10386. 

  10386. 					

    10387. 

  10387. 					    static bool check_I_ArrayIndex(I[] val)

    10388. 

  10388. 					    {

    10389. 

  10389. 					        bool success = checkEx_I_ArrayIndex(val, -1);

    10390. 

  10390. 					        for (int i = 0; i < val.Length; i++)

    10391. 

  10391. 					        {

    10392. 

  10392. 					            success &= check_I_ArrayIndex(val, 0);

    10393. 

  10393. 					        }

    10394. 

  10394. 					        success &= checkEx_I_ArrayIndex(val, val.Length);

    10395. 

  10395. 					        return success;

    10396. 

  10396. 					    }

    10397. 

  10397. 					

    10398. 

  10398. 					    static bool checkEx_I_ArrayIndex(I[] val, int index)

    10399. 

  10399. 					    {

    10400. 

  10400. 					        try

    10401. 

  10401. 					        {

    10402. 

  10402. 					            check_I_ArrayIndex(val, index);

    10403. 

  10403. 					            Console.WriteLine("I_ArrayIndex[" + index + "] failed");

    10404. 

  10404. 					            return false;

    10405. 

  10405. 					        }

    10406. 

  10406. 					        catch

    10407. 

  10407. 					        {

    10408. 

  10408. 					            return true;

    10409. 

  10409. 					        }

    10410. 

  10410. 					    }

    10411. 

  10411. 					

    10412. 

  10412. 					    static bool check_I_ArrayIndex(I[] val, int index)

    10413. 

  10413. 					    {

    10414. 

  10414. 					        Expression<Func<I>> e =

    10415. 

  10415. 					            Expression.Lambda<Func<I>>(

    10416. 

  10416. 					                Expression.ArrayIndex(Expression.Constant(val, typeof(I[])),

    10417. 

  10417. 					                    Expression.Constant(index, typeof(int))),

    10418. 

  10418. 					                new System.Collections.Generic.List<ParameterExpression>());

    10419. 

  10419. 					        Func<I> f = e.Compile();

    10420. 

  10420. 					        return object.Equals(f(), val[index]);

    10421. 

  10421. 					    }

    10422. 

  10422. 					}

    10423. 

  10423. 				

    10424. 

  10424. 				

    10425. 

  10425. 				public  static class Ext {

    10426. 

  10426. 				    public static void StartCapture() {

    10427. 

  10427. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StartCaptureToFile", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10428. 

  10428. 				//        m.Invoke(null, new object[] { "test.dll" });

    10429. 

  10429. 				    }

    10430. 

  10430. 				

    10431. 

  10431. 				    public static void StopCapture() {

    10432. 

  10432. 				//        MethodInfo m = Assembly.GetAssembly(typeof(Expression)).GetType("System.Linq.Expressions.ExpressionCompiler").GetMethod("StopCapture", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

    10433. 

  10433. 				//        m.Invoke(null, new object[0]);

    10434. 

  10434. 				    }

    10435. 

  10435. 				

    10436. 

  10436. 				    public static bool IsIntegralOrEnum(Type type) {

    10437. 

  10437. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10438. 

  10438. 				            case TypeCode.Byte:

    10439. 

  10439. 				            case TypeCode.SByte:

    10440. 

  10440. 				            case TypeCode.Int16:

    10441. 

  10441. 				            case TypeCode.Int32:

    10442. 

  10442. 				            case TypeCode.Int64:

    10443. 

  10443. 				            case TypeCode.UInt16:

    10444. 

  10444. 				            case TypeCode.UInt32:

    10445. 

  10445. 				            case TypeCode.UInt64:

    10446. 

  10446. 				                return true;

    10447. 

  10447. 				            default:

    10448. 

  10448. 				                return false;

    10449. 

  10449. 				        }

    10450. 

  10450. 				    }

    10451. 

  10451. 				

    10452. 

  10452. 				    public static bool IsFloating(Type type) {

    10453. 

  10453. 				        switch (Type.GetTypeCode(GetNonNullableType(type))) {

    10454. 

  10454. 				            case TypeCode.Single:

    10455. 

  10455. 				            case TypeCode.Double:

    10456. 

  10456. 				                return true;

    10457. 

  10457. 				            default:

    10458. 

  10458. 				                return false;

    10459. 

  10459. 				        }

    10460. 

  10460. 				    }

    10461. 

  10461. 				

    10462. 

  10462. 				    public static Type GetNonNullableType(Type type) {

    10463. 

  10463. 				        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) ?

    10464. 

  10464. 				                type.GetGenericArguments()[0] :

    10465. 

  10465. 				                type;

    10466. 

  10466. 				    }

    10467. 

  10467. 				}

    10468. 

  10468. 				

    10469. 

  10469. 			

    10470. 

  10470. 			

    10471. 

  10471. 			

    10472. 

  10472. 			public interface I

    10473. 

  10473. 			{

    10474. 

  10474. 			    void M();

    10475. 

  10475. 			}

    10476. 

  10476. 			

    10477. 

  10477. 			public  class C : IEquatable<C>, I

    10478. 

  10478. 			{

    10479. 

  10479. 			    void I.M()

    10480. 

  10480. 			    {

    10481. 

  10481. 			    }

    10482. 

  10482. 			

    10483. 

  10483. 			    public override bool Equals(object o)

    10484. 

  10484. 			    {

    10485. 

  10485. 			        return o is C && Equals((C)o);

    10486. 

  10486. 			    }

    10487. 

  10487. 			

    10488. 

  10488. 			    public bool Equals(C c)

    10489. 

  10489. 			    {

    10490. 

  10490. 			        return c != null;

    10491. 

  10491. 			    }

    10492. 

  10492. 			

    10493. 

  10493. 			    public override int GetHashCode()

    10494. 

  10494. 			    {

    10495. 

  10495. 			        return 0;

    10496. 

  10496. 			    }

    10497. 

  10497. 			}

    10498. 

  10498. 			

    10499. 

  10499. 			public  class D : C, IEquatable<D>

    10500. 

  10500. 			{

    10501. 

  10501. 			    public int Val;

    10502. 

  10502. 			    public D()

    10503. 

  10503. 			    {

    10504. 

  10504. 			    }

    10505. 

  10505. 			    public D(int val)

    10506. 

  10506. 			    {

    10507. 

  10507. 			        Val = val;

    10508. 

  10508. 			    }

    10509. 

  10509. 			

    10510. 

  10510. 			    public override bool Equals(object o)

    10511. 

  10511. 			    {

    10512. 

  10512. 			        return o is D && Equals((D)o);

    10513. 

  10513. 			    }

    10514. 

  10514. 			

    10515. 

  10515. 			    public bool Equals(D d)

    10516. 

  10516. 			    {

    10517. 

  10517. 			        return d != null && d.Val == Val;

    10518. 

  10518. 			    }

    10519. 

  10519. 			

    10520. 

  10520. 			    public override int GetHashCode()

    10521. 

  10521. 			    {

    10522. 

  10522. 			        return Val;

    10523. 

  10523. 			    }

    10524. 

  10524. 			}

    10525. 

  10525. 			

    10526. 

  10526. 			public enum E

    10527. 

  10527. 			{

    10528. 

  10528. 			    A = 1, B = 2

    10529. 

  10529. 			}

    10530. 

  10530. 			

    10531. 

  10531. 			public enum El : long

    10532. 

  10532. 			{

    10533. 

  10533. 			    A, B, C

    10534. 

  10534. 			}

    10535. 

  10535. 			

    10536. 

  10536. 			public struct S : IEquatable<S>

    10537. 

  10537. 			{

    10538. 

  10538. 			    public override bool Equals(object o)

    10539. 

  10539. 			    {

    10540. 

  10540. 			        return (o is S) && Equals((S)o);

    10541. 

  10541. 			    }

    10542. 

  10542. 			    public bool Equals(S other)

    10543. 

  10543. 			    {

    10544. 

  10544. 			        return true;

    10545. 

  10545. 			    }

    10546. 

  10546. 			    public override int GetHashCode()

    10547. 

  10547. 			    {

    10548. 

  10548. 			        return 0;

    10549. 

  10549. 			    }

    10550. 

  10550. 			}

    10551. 

  10551. 			

    10552. 

  10552. 			public struct Sp : IEquatable<Sp>

    10553. 

  10553. 			{

    10554. 

  10554. 			    public Sp(int i, double d)

    10555. 

  10555. 			    {

    10556. 

  10556. 			        I = i;

    10557. 

  10557. 			        D = d;

    10558. 

  10558. 			    }

    10559. 

  10559. 			

    10560. 

  10560. 			    public int I;

    10561. 

  10561. 			    public double D;

    10562. 

  10562. 			

    10563. 

  10563. 			    public override bool Equals(object o)

    10564. 

  10564. 			    {

    10565. 

  10565. 			        return (o is Sp) && Equals((Sp)o);

    10566. 

  10566. 			    }

    10567. 

  10567. 			    public bool Equals(Sp other)

    10568. 

  10568. 			    {

    10569. 

  10569. 			        return other.I == I && other.D == D;

    10570. 

  10570. 			    }

    10571. 

  10571. 			    public override int GetHashCode()

    10572. 

  10572. 			    {

    10573. 

  10573. 			        return I.GetHashCode() ^ D.GetHashCode();

    10574. 

  10574. 			    }

    10575. 

  10575. 			}

    10576. 

  10576. 			

    10577. 

  10577. 			public struct Ss : IEquatable<Ss>

    10578. 

  10578. 			{

    10579. 

  10579. 			    public Ss(S s)

    10580. 

  10580. 			    {

    10581. 

  10581. 			        Val = s;

    10582. 

  10582. 			    }

    10583. 

  10583. 			

    10584. 

  10584. 			    public S Val;

    10585. 

  10585. 			

    10586. 

  10586. 			    public override bool Equals(object o)

    10587. 

  10587. 			    {

    10588. 

  10588. 			        return (o is Ss) && Equals((Ss)o);

    10589. 

  10589. 			    }

    10590. 

  10590. 			    public bool Equals(Ss other)

    10591. 

  10591. 			    {

    10592. 

  10592. 			        return other.Val.Equals(Val);

    10593. 

  10593. 			    }

    10594. 

  10594. 			    public override int GetHashCode()

    10595. 

  10595. 			    {

    10596. 

  10596. 			        return Val.GetHashCode();

    10597. 

  10597. 			    }

    10598. 

  10598. 			}

    10599. 

  10599. 			

    10600. 

  10600. 			public struct Sc : IEquatable<Sc>

    10601. 

  10601. 			{

    10602. 

  10602. 			    public Sc(string s)

    10603. 

  10603. 			    {

    10604. 

  10604. 			        S = s;

    10605. 

  10605. 			    }

    10606. 

  10606. 			

    10607. 

  10607. 			    public string S;

    10608. 

  10608. 			

    10609. 

  10609. 			    public override bool Equals(object o)

    10610. 

  10610. 			    {

    10611. 

  10611. 			        return (o is Sc) && Equals((Sc)o);

    10612. 

  10612. 			    }

    10613. 

  10613. 			    public bool Equals(Sc other)

    10614. 

  10614. 			    {

    10615. 

  10615. 			        return other.S == S;

    10616. 

  10616. 			    }

    10617. 

  10617. 			    public override int GetHashCode()

    10618. 

  10618. 			    {

    10619. 

  10619. 			        return S.GetHashCode();

    10620. 

  10620. 			    }

    10621. 

  10621. 			}

    10622. 

  10622. 			

    10623. 

  10623. 			public struct Scs : IEquatable<Scs>

    10624. 

  10624. 			{

    10625. 

  10625. 			    public Scs(string s, S val)

    10626. 

  10626. 			    {

    10627. 

  10627. 			        S = s;

    10628. 

  10628. 			        Val = val;

    10629. 

  10629. 			    }

    10630. 

  10630. 			

    10631. 

  10631. 			    public string S;

    10632. 

  10632. 			    public S Val;

    10633. 

  10633. 			

    10634. 

  10634. 			    public override bool Equals(object o)

    10635. 

  10635. 			    {

    10636. 

  10636. 			        return (o is Scs) && Equals((Scs)o);

    10637. 

  10637. 			    }

    10638. 

  10638. 			    public bool Equals(Scs other)

    10639. 

  10639. 			    {

    10640. 

  10640. 			        return other.S == S && other.Val.Equals(Val);

    10641. 

  10641. 			    }

    10642. 

  10642. 			    public override int GetHashCode()

    10643. 

  10643. 			    {

    10644. 

  10644. 			        return S.GetHashCode() ^ Val.GetHashCode();

    10645. 

  10645. 			    }

    10646. 

  10646. 			}

    10647. 

  10647. 			

    10648. 

  10648. 		

    10649. 

  10649. 	}

    10650. 

  10650. 	

    10651. 

  10651. }

    10652. 

  10652.