/IronPython_Main/Runtime/Tests/ETScenarios/Conversions.cs

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

  1#if !CLR2
  2using System.Linq.Expressions;
  3#else
  4using Microsoft.Scripting.Ast;
  5#endif
  6
  7using System;
  8using System.Collections.Generic;
  9using System.Reflection;
 10
 11namespace ETScenarios {
 12    using EU = ETUtils.ExpressionUtils;
 13    using Expr = Expression;
 14    using AstUtils = Microsoft.Scripting.Ast.Utils;
 15        
 16    public class Conversions {
 17        private static Expr TE(Type t, string Message) {
 18            ConstructorInfo ci = t.GetConstructor(new Type[] { typeof(String) });
 19            Expression Ex = Expr.New(ci, Expr.Constant(Message));
 20            return Ex;
 21        }
 22
 23
 24
 25
 26
 27
 28        //Void type. No declaration needed
 29
 30        public class BooleanType {
 31            public static Boolean TrueVal = true;
 32            public static Boolean FalseVal = false;
 33            public static Boolean defaultvalueval = true;
 34        }
 35
 36        public class sbyteType {
 37            public static sbyte MinValue = sbyte.MinValue;
 38            public static sbyte MaxValue = sbyte.MaxValue;
 39            public static sbyte defaultvalueval = (sbyte)5;
 40            public static sbyte Zero = (sbyte)0;
 41        }
 42
 43        public class byteType {
 44            public static byte MinValue = byte.MinValue;
 45            public static byte MaxValue = byte.MaxValue;
 46            public static byte defaultvalueval = (byte)5;
 47            public static byte Zero = (byte)0;
 48        }
 49
 50        public class shortType {
 51            public static short MinValue = short.MinValue;
 52            public static short MaxValue = short.MaxValue;
 53            public static short defaultvalueval = (short)5;
 54            public static short Zero = (short)0;
 55        }
 56
 57        public class ushortType {
 58            public static ushort MinValue = ushort.MinValue;
 59            public static ushort MaxValue = ushort.MaxValue;
 60            public static ushort defaultvalueval = (ushort)5;
 61            public static ushort Zero = (ushort)0;
 62        }
 63
 64        public class intType {
 65            public static int MinValue = int.MinValue;
 66            public static int MaxValue = int.MaxValue;
 67            public static int defaultvalueval = (int)5;
 68            public static int Zero = (int)0;
 69        }
 70
 71        public class uintType {
 72            public static uint MinValue = uint.MinValue;
 73            public static uint MaxValue = uint.MaxValue;
 74            public static uint defaultvalueval = (uint)5;
 75            public static uint Zero = (uint)0;
 76        }
 77
 78        public class longType {
 79            public static long MinValue = long.MinValue;
 80            public static long MaxValue = long.MaxValue;
 81            public static long defaultvalueval = (long)5;
 82            public static long Zero = (long)0;
 83        }
 84
 85        public class ulongType {
 86            public static ulong MinValue = ulong.MinValue;
 87            public static ulong MaxValue = ulong.MaxValue;
 88            public static ulong defaultvalueval = (ulong)5;
 89            public static ulong Zero = (ulong)0;
 90        }
 91
 92        public class decimalType {
 93            public static decimal MinValue = decimal.MinValue;
 94            public static decimal MaxValue = decimal.MaxValue;
 95            public static decimal defaultvalueval = (decimal)5;
 96            public static decimal Zero = (decimal)0;
 97        }
 98
 99        public class floatType {
100            public static float MinValue = float.MinValue;
101            public static float MaxValue = float.MaxValue;
102            public static float defaultvalueval = (float)5;
103            public static float Zero = (float)0;
104        }
105
106        public class doubleType {
107            public static double MinValue = double.MinValue;
108            public static double MaxValue = double.MaxValue;
109            public static double defaultvalueval = (double)5;
110            public static double Zero = (double)0;
111        }
112
113        public class DateTimeType {
114            public static DateTime MinValue = DateTime.MinValue;
115            public static DateTime MaxValue = DateTime.MaxValue;
116            public static DateTime defaultvalueval = DateTime.Parse("1/2/3");
117            public static DateTime Zero = DateTime.Parse("1/1/1");
118        }
119
120        public class stringType {
121            public static string defaultvalueval = "abc123!";
122            public static string nullval = (string)null;
123            public static string Zero = "";
124        }
125
126        public class charType {
127            public static char defaultvalueval = 'c';
128#if SILVERLIGHT
129            public static char Zero = Convert.ToChar(0);
130#else
131            public static char Zero = char.ConvertFromUtf32(0)[0];
132#endif
133        }
134
135        public enum sbyteenum : sbyte {
136        }
137        public class sbyteenumType {
138            public static sbyteenum MinValue = (sbyteenum)sbyte.MinValue;
139            public static sbyteenum MaxValue = (sbyteenum)sbyte.MaxValue;
140            public static sbyteenum defaultvalueval = (sbyteenum)5;
141            public static sbyteenum Zero = (sbyteenum)0;
142        }
143
144        public enum byteenum : byte {
145        }
146        public class byteenumType {
147            public static byteenum MinValue = (byteenum)byte.MinValue;
148            public static byteenum MaxValue = (byteenum)byte.MaxValue;
149            public static byteenum defaultvalueval = (byteenum)5;
150            public static byteenum Zero = (byteenum)0;
151        }
152
153        public enum shortenum : short {
154        }
155        public class shortenumType {
156            public static shortenum MinValue = (shortenum)short.MinValue;
157            public static shortenum MaxValue = (shortenum)short.MaxValue;
158            public static shortenum defaultvalueval = (shortenum)5;
159            public static shortenum Zero = (shortenum)0;
160        }
161
162        public enum ushortenum : ushort {
163        }
164        public class ushortenumType {
165            public static ushortenum MinValue = (ushortenum)ushort.MinValue;
166            public static ushortenum MaxValue = (ushortenum)ushort.MaxValue;
167            public static ushortenum defaultvalueval = (ushortenum)5;
168            public static ushortenum Zero = (ushortenum)0;
169        }
170
171        public enum intenum : int {
172        }
173        public class intenumType {
174            public static intenum MinValue = (intenum)int.MinValue;
175            public static intenum MaxValue = (intenum)int.MaxValue;
176            public static intenum defaultvalueval = (intenum)5;
177            public static intenum Zero = (intenum)0;
178        }
179
180        public enum uintenum : uint {
181        }
182        public class uintenumType {
183            public static uintenum MinValue = (uintenum)uint.MinValue;
184            public static uintenum MaxValue = (uintenum)uint.MaxValue;
185            public static uintenum defaultvalueval = (uintenum)5;
186            public static uintenum Zero = (uintenum)0;
187        }
188
189        public enum longenum : long {
190        }
191        public class longenumType {
192            public static longenum MinValue = (longenum)long.MinValue;
193            public static longenum MaxValue = (longenum)long.MaxValue;
194            public static longenum defaultvalueval = (longenum)5;
195            public static longenum Zero = (longenum)0;
196        }
197
198        public enum ulongenum : ulong {
199        }
200        public class ulongenumType {
201            public static ulongenum MinValue = (ulongenum)ulong.MinValue;
202            public static ulongenum MaxValue = (ulongenum)ulong.MaxValue;
203            public static ulongenum defaultvalueval = (ulongenum)5;
204            public static ulongenum Zero = (ulongenum)0;
205        }
206
207        public struct structure {
208            int x;
209            void foo() {
210                x = 5;
211                Console.WriteLine(x);
212            }
213            public static bool operator ==(structure a, structure b) {
214                return a.x == b.x;
215            }
216            public static bool operator !=(structure a, structure b) {
217                return a.x != b.x;
218            }
219            public override int GetHashCode() {
220                return base.GetHashCode();
221            }
222            public override bool Equals(object obj) {
223                return base.Equals(obj);
224            }
225        }
226        public class structureType {
227            public static structure defaultvalueval;
228        }
229
230        public class BooleanNullableType {
231            public static Boolean? TrueVal = (Boolean?)true;
232            public static Boolean? FalseVal = (Boolean?)false;
233            public static Boolean? nullval = (Boolean?)null;
234            public static Boolean? defaultvalueval = (Boolean?)true;
235        }
236
237        public class sbyteNullableType {
238            public static sbyte? MinValue = (sbyte?)sbyte.MinValue;
239            public static sbyte? MaxValue = (sbyte?)sbyte.MaxValue;
240            public static sbyte? nullval = (sbyte?)null;
241            public static sbyte? defaultvalueval = (sbyte?)5;
242            public static sbyte? Zero = (sbyte?)0;
243        }
244
245        public class byteNullableType {
246            public static byte? MinValue = (byte?)byte.MinValue;
247            public static byte? MaxValue = (byte?)byte.MaxValue;
248            public static byte? nullval = (byte?)null;
249            public static byte? defaultvalueval = (byte?)5;
250            public static byte? Zero = (byte?)0;
251        }
252
253        public class shortNullableType {
254            public static short? MinValue = (short?)short.MinValue;
255            public static short? MaxValue = (short?)short.MaxValue;
256            public static short? nullval = (short?)null;
257            public static short? defaultvalueval = (short?)5;
258            public static short? Zero = (short?)0;
259        }
260
261        public class ushortNullableType {
262            public static ushort? MinValue = (ushort?)ushort.MinValue;
263            public static ushort? MaxValue = (ushort?)ushort.MaxValue;
264            public static ushort? nullval = (ushort?)null;
265            public static ushort? defaultvalueval = (ushort?)5;
266            public static ushort? Zero = (ushort?)0;
267        }
268
269        public class intNullableType {
270            public static int? MinValue = (int?)int.MinValue;
271            public static int? MaxValue = (int?)int.MaxValue;
272            public static int? nullval = (int?)null;
273            public static int? defaultvalueval = (int?)5;
274            public static int? Zero = (int?)0;
275        }
276
277        public class uintNullableType {
278            public static uint? MinValue = (uint?)uint.MinValue;
279            public static uint? MaxValue = (uint?)uint.MaxValue;
280            public static uint? nullval = (uint?)null;
281            public static uint? defaultvalueval = (uint?)5;
282            public static uint? Zero = (uint?)0;
283        }
284
285        public class longNullableType {
286            public static long? MinValue = (long?)long.MinValue;
287            public static long? MaxValue = (long?)long.MaxValue;
288            public static long? nullval = (long?)null;
289            public static long? defaultvalueval = (long?)5;
290            public static long? Zero = (long?)0;
291        }
292
293        public class ulongNullableType {
294            public static ulong? MinValue = (ulong?)ulong.MinValue;
295            public static ulong? MaxValue = (ulong?)ulong.MaxValue;
296            public static ulong? nullval = (ulong?)null;
297            public static ulong? defaultvalueval = (ulong?)5;
298            public static ulong? Zero = (ulong?)0;
299        }
300
301        public class decimalNullableType {
302            public static decimal? MinValue = (decimal?)decimal.MinValue;
303            public static decimal? MaxValue = (decimal?)decimal.MaxValue;
304            public static decimal? nullval = (decimal?)null;
305            public static decimal? defaultvalueval = (decimal?)5;
306            public static decimal? Zero = (decimal?)0;
307        }
308
309        public class floatNullableType {
310            public static float? MinValue = (float?)float.MinValue;
311            public static float? MaxValue = (float?)float.MaxValue;
312            public static float? nullval = (float?)null;
313            public static float? defaultvalueval = (float?)5;
314            public static float? Zero = (float?)0;
315        }
316
317        public class doubleNullableType {
318            public static double? MinValue = (double?)double.MinValue;
319            public static double? MaxValue = (double?)double.MaxValue;
320            public static double? nullval = (double?)null;
321            public static double? defaultvalueval = (double?)5;
322            public static double? Zero = (double?)0;
323        }
324
325        public class DateTimeNullableType {
326            public static DateTime? MinValue = (DateTime?)DateTime.MinValue;
327            public static DateTime? MaxValue = (DateTime?)DateTime.MaxValue;
328            public static DateTime? nullval = (DateTime?)null;
329            public static DateTime? defaultvalueval = (DateTime?)DateTime.Parse("1/2/3");
330            public static DateTime? Zero = (DateTime?)DateTime.Parse("1/1/1");
331        }
332
333        public class charNullableType {
334            public static char? defaultvalueval = (char?)'c';
335            public static char? nullval = (char?)null;
336#if SILVERLIGHT
337            public static char? Zero = (char?)Convert.ToChar(0);
338#else
339            public static char? Zero = (char?)char.ConvertFromUtf32(0)[0];
340#endif
341        }
342
343        public enum sbyteenumNullable : sbyte {
344        }
345        public class sbyteenumNullableType {
346            public static sbyteenum? MinValue = (sbyteenum?)sbyte.MinValue;
347            public static sbyteenum? MaxValue = (sbyteenum?)sbyte.MaxValue;
348            public static sbyteenum? defaultvalueval = (sbyteenum?)5;
349            public static sbyteenum? nullval = (sbyteenum?)null;
350            public static sbyteenum? Zero = (sbyteenum?)0;
351        }
352
353        public enum byteenumNullable : byte {
354        }
355        public class byteenumNullableType {
356            public static byteenum? MinValue = (byteenum?)byte.MinValue;
357            public static byteenum? MaxValue = (byteenum?)byte.MaxValue;
358            public static byteenum? nullval = (byteenum?)null;
359            public static byteenum? defaultvalueval = (byteenum?)5;
360            public static byteenum? Zero = (byteenum?)0;
361        }
362
363        public enum shortenumNullable : short {
364        }
365        public class shortenumNullableType {
366            public static shortenum? MinValue = (shortenum?)short.MinValue;
367            public static shortenum? MaxValue = (shortenum?)short.MaxValue;
368            public static shortenum? nullval = (shortenum?)null;
369            public static shortenum? defaultvalueval = (shortenum?)5;
370            public static shortenum? Zero = (shortenum?)0;
371        }
372
373        public enum ushortenumNullable : ushort {
374        }
375        public class ushortenumNullableType {
376            public static ushortenum? MinValue = (ushortenum?)ushort.MinValue;
377            public static ushortenum? MaxValue = (ushortenum?)ushort.MaxValue;
378            public static ushortenum? nullval = (ushortenum?)null;
379            public static ushortenum? defaultvalueval = (ushortenum?)5;
380            public static ushortenum? Zero = (ushortenum?)0;
381        }
382
383        public enum intenumNullable : int {
384        }
385        public class intenumNullableType {
386            public static intenum? MinValue = (intenum?)int.MinValue;
387            public static intenum? MaxValue = (intenum?)int.MaxValue;
388            public static intenum? nullval = (intenum?)null;
389            public static intenum? defaultvalueval = (intenum?)5;
390            public static intenum? Zero = (intenum?)0;
391        }
392
393        public enum uintenumNullable : uint {
394        }
395        public class uintenumNullableType {
396            public static uintenum? MinValue = (uintenum?)uint.MinValue;
397            public static uintenum? MaxValue = (uintenum?)uint.MaxValue;
398            public static uintenum? nullval = (uintenum?)null;
399            public static uintenum? defaultvalueval = (uintenum?)5;
400            public static uintenum? Zero = (uintenum?)0;
401        }
402
403        public enum longenumNullable : long {
404        }
405        public class longenumNullableType {
406            public static longenum? MinValue = (longenum?)long.MinValue;
407            public static longenum? MaxValue = (longenum?)long.MaxValue;
408            public static longenum? nullval = (longenum?)null;
409            public static longenum? defaultvalueval = (longenum?)5;
410            public static longenum? Zero = (longenum?)0;
411        }
412
413        public enum ulongenumNullable : ulong {
414        }
415        public class ulongenumNullableType {
416            public static ulongenum? MinValue = (ulongenum?)ulong.MinValue;
417            public static ulongenum? MaxValue = (ulongenum?)ulong.MaxValue;
418            public static ulongenum? nullval = (ulongenum?)null;
419            public static ulongenum? defaultvalueval = (ulongenum?)5;
420            public static ulongenum? Zero = (ulongenum?)0;
421        }
422
423        public struct structureNullable {
424            int x;
425            void foo() {
426                x = 5;
427                Console.WriteLine(x);
428            }
429        }
430        public class structureNullableType {
431            public static structure? defaultvalueval = new structure();
432            public static structure? nullval = (structure?)null;
433        }
434
435        public class Class1 {
436            int x;
437            void foo() {
438                x = 5;
439                Console.WriteLine(x);
440            }
441        }
442        public class Class1Type {
443            public static Class1 defaultvalueval = new Class1();
444            public static Class1 nullval = (Class1)null;
445        }
446
447        public interface Interface1 {
448            int x();
449        }
450        public class Interface1Type {
451            public static Interface1 defaultvalueval;
452            public static Interface1 nullval = (Interface1)null;
453        }
454
455        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 1", new string[] { "positive", "convert", "Pri2" }, Priority = 2)]
456        public static Expr Convert1(EU.IValidator V) {
457            List<Expression> Expressions = new List<Expression>();
458            //just checking no exception is thrown.
459            Expressions.Add(Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(void)));
460            var tree = Expr.Block(Expressions);
461            V.Validate(tree);
462            return tree;
463        }
464        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 2", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
465        public static Expr Convert2(EU.IValidator V) {
466            List<Expression> Expressions = new List<Expression>();
467            ParameterExpression Result = Expr.Variable(typeof(Boolean), "");
468            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
469            {
470                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(Boolean)));
471            }));
472            var tree = Expr.Block(new[] { Result }, Expressions);
473
474            return tree;
475        }
476        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 3", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
477        public static Expr Convert3(EU.IValidator V) {
478            List<Expression> Expressions = new List<Expression>();
479            ParameterExpression Result = Expr.Variable(typeof(sbyte), "");
480            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
481	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(sbyte)));}) );
482            var tree = Expr.Block(new[] { Result }, Expressions);
483
484            return tree;
485        }
486        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 4", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
487        public static Expr Convert4(EU.IValidator V) {
488            List<Expression> Expressions = new List<Expression>();
489            ParameterExpression Result = Expr.Variable(typeof(byte), "");
490            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
491	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(byte)));}) );
492            var tree = Expr.Block(new[] { Result }, Expressions);
493
494            return tree;
495        }
496        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 5", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
497        public static Expr Convert5(EU.IValidator V) {
498            List<Expression> Expressions = new List<Expression>();
499            ParameterExpression Result = Expr.Variable(typeof(short), "");
500            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
501	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(short)));}) );
502            var tree = Expr.Block(new[] { Result }, Expressions);
503
504            return tree;
505        }
506        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 6", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
507        public static Expr Convert6(EU.IValidator V) {
508            List<Expression> Expressions = new List<Expression>();
509            ParameterExpression Result = Expr.Variable(typeof(ushort), "");
510            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
511	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ushort)));}) );
512            var tree = Expr.Block(new[] { Result }, Expressions);
513
514            return tree;
515        }
516        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 7", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
517        public static Expr Convert7(EU.IValidator V) {
518            List<Expression> Expressions = new List<Expression>();
519            ParameterExpression Result = Expr.Variable(typeof(int), "");
520            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
521	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(int)));}) );
522            var tree = Expr.Block(new[] { Result }, Expressions);
523
524            return tree;
525        }
526        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 8", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
527        public static Expr Convert8(EU.IValidator V) {
528            List<Expression> Expressions = new List<Expression>();
529            ParameterExpression Result = Expr.Variable(typeof(uint), "");
530            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
531	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(uint)));}) );
532            var tree = Expr.Block(new[] { Result }, Expressions);
533
534            return tree;
535        }
536        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 9", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
537        public static Expr Convert9(EU.IValidator V) {
538            List<Expression> Expressions = new List<Expression>();
539            ParameterExpression Result = Expr.Variable(typeof(long), "");
540            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
541	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(long)));}) );
542            var tree = Expr.Block(new[] { Result }, Expressions);
543
544            return tree;
545        }
546        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 10", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
547        public static Expr Convert10(EU.IValidator V) {
548            List<Expression> Expressions = new List<Expression>();
549            ParameterExpression Result = Expr.Variable(typeof(ulong), "");
550            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
551            {
552                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ulong)));
553            }));
554            var tree = Expr.Block(new[] { Result }, Expressions);
555
556            return tree;
557        }
558
559        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 11", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
560        public static Expr Convert11(EU.IValidator V) {
561            List<Expression> Expressions = new List<Expression>();
562            ParameterExpression Result = Expr.Variable(typeof(decimal), "");
563            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
564            {
565                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(decimal)));
566            }));
567            var tree = Expr.Block(new[] { Result }, Expressions);
568
569            return tree;
570        }
571        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 12", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
572        public static Expr Convert12(EU.IValidator V) {
573            List<Expression> Expressions = new List<Expression>();
574            ParameterExpression Result = Expr.Variable(typeof(float), "");
575            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
576            {
577                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(float)));
578            }));
579            var tree = Expr.Block(new[] { Result }, Expressions);
580
581            return tree;
582        }
583        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 13", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
584        public static Expr Convert13(EU.IValidator V) {
585            List<Expression> Expressions = new List<Expression>();
586            ParameterExpression Result = Expr.Variable(typeof(double), "");
587            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
588            {
589                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(double)));
590            }));
591            var tree = Expr.Block(new[] { Result }, Expressions);
592
593            return tree;
594        }
595        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 14", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
596        public static Expr Convert14(EU.IValidator V) {
597            List<Expression> Expressions = new List<Expression>();
598            ParameterExpression Result = Expr.Variable(typeof(DateTime), "");
599            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
600            {
601                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(DateTime)));
602            }));
603            var tree = Expr.Block(new[] { Result }, Expressions);
604
605            return tree;
606        }
607        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 15", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
608        public static Expr Convert15(EU.IValidator V) {
609            List<Expression> Expressions = new List<Expression>();
610            ParameterExpression Result = Expr.Variable(typeof(string), "");
611            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
612            {
613                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(string)));
614            }));
615            var tree = Expr.Block(new[] { Result }, Expressions);
616
617            return tree;
618        }
619        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 16", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
620        public static Expr Convert16(EU.IValidator V) {
621            List<Expression> Expressions = new List<Expression>();
622            ParameterExpression Result = Expr.Variable(typeof(char), "");
623            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
624            {
625                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(char)));
626            }));
627            var tree = Expr.Block(new[] { Result }, Expressions);
628
629            return tree;
630        }
631        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 17", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
632        public static Expr Convert17(EU.IValidator V) {
633            List<Expression> Expressions = new List<Expression>();
634            ParameterExpression Result = Expr.Variable(typeof(sbyteenum), "");
635            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
636            {
637                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(sbyteenum)));
638            }));
639            var tree = Expr.Block(new[] { Result }, Expressions);
640
641            return tree;
642        }
643        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 18", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
644        public static Expr Convert18(EU.IValidator V) {
645            List<Expression> Expressions = new List<Expression>();
646            ParameterExpression Result = Expr.Variable(typeof(byteenum), "");
647            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
648            {
649                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(byteenum)));
650            }));
651            var tree = Expr.Block(new[] { Result }, Expressions);
652
653            return tree;
654        }
655        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 19", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
656        public static Expr Convert19(EU.IValidator V) {
657            List<Expression> Expressions = new List<Expression>();
658            ParameterExpression Result = Expr.Variable(typeof(shortenum), "");
659            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
660            {
661                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(shortenum)));
662            }));
663            var tree = Expr.Block(new[] { Result }, Expressions);
664
665            return tree;
666        }
667        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 20", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
668        public static Expr Convert20(EU.IValidator V) {
669            List<Expression> Expressions = new List<Expression>();
670            ParameterExpression Result = Expr.Variable(typeof(ushortenum), "");
671            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
672            {
673                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ushortenum)));
674            }));
675            var tree = Expr.Block(new[] { Result }, Expressions);
676
677            return tree;
678        }
679        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 21", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
680        public static Expr Convert21(EU.IValidator V) {
681            List<Expression> Expressions = new List<Expression>();
682            ParameterExpression Result = Expr.Variable(typeof(intenum), "");
683            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
684            {
685                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(intenum)));
686            }));
687            var tree = Expr.Block(new[] { Result }, Expressions);
688
689            return tree;
690        }
691        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 22", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
692        public static Expr Convert22(EU.IValidator V) {
693            List<Expression> Expressions = new List<Expression>();
694            ParameterExpression Result = Expr.Variable(typeof(uintenum), "");
695            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
696            {
697                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(uintenum)));
698            }));
699            var tree = Expr.Block(new[] { Result }, Expressions);
700
701            return tree;
702        }
703        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 23", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
704        public static Expr Convert23(EU.IValidator V) {
705            List<Expression> Expressions = new List<Expression>();
706            ParameterExpression Result = Expr.Variable(typeof(longenum), "");
707            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
708            {
709                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(longenum)));
710            }));
711            var tree = Expr.Block(new[] { Result }, Expressions);
712
713            return tree;
714        }
715        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 24", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
716        public static Expr Convert24(EU.IValidator V) {
717            List<Expression> Expressions = new List<Expression>();
718            ParameterExpression Result = Expr.Variable(typeof(ulongenum), "");
719            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
720            {
721                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ulongenum)));
722            }));
723            var tree = Expr.Block(new[] { Result }, Expressions);
724
725            return tree;
726        }
727        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 25", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
728        public static Expr Convert25(EU.IValidator V) {
729            List<Expression> Expressions = new List<Expression>();
730            ParameterExpression Result = Expr.Variable(typeof(structure), "");
731            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
732            {
733                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(structure)));
734            }));
735            var tree = Expr.Block(new[] { Result }, Expressions);
736
737            return tree;
738        }
739        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 26", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
740        public static Expr Convert26(EU.IValidator V) {
741            List<Expression> Expressions = new List<Expression>();
742            ParameterExpression Result = Expr.Variable(typeof(Boolean?), "");
743            Expressions.Add(EU.Throws<System.InvalidOperationException>(() =>
744            {
745                Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(Boolean?)));
746            }));
747            var tree = Expr.Block(new[] { Result }, Expressions);
748
749            return tree;
750        }
751        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 27", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
752        public static Expr Convert27(EU.IValidator V) {
753            List<Expression> Expressions = new List<Expression>();
754            ParameterExpression Result = Expr.Variable(typeof(sbyte?), "");
755            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
756	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(sbyte?)));}) );
757            var tree = Expr.Block(new[] { Result }, Expressions);
758
759            return tree;
760        }
761        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 28", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
762        public static Expr Convert28(EU.IValidator V) {
763            List<Expression> Expressions = new List<Expression>();
764            ParameterExpression Result = Expr.Variable(typeof(byte?), "");
765            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
766	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(byte?)));}) );
767            var tree = Expr.Block(new[] { Result }, Expressions);
768
769            return tree;
770        }
771        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 29", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
772        public static Expr Convert29(EU.IValidator V) {
773            List<Expression> Expressions = new List<Expression>();
774            ParameterExpression Result = Expr.Variable(typeof(short?), "");
775            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
776	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(short?)));}) );
777            var tree = Expr.Block(new[] { Result }, Expressions);
778
779            return tree;
780        }
781        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 30", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
782        public static Expr Convert30(EU.IValidator V) {
783            List<Expression> Expressions = new List<Expression>();
784            ParameterExpression Result = Expr.Variable(typeof(ushort?), "");
785            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
786	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ushort?)));}) );
787            var tree = Expr.Block(new[] { Result }, Expressions);
788
789            return tree;
790        }
791        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 31", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
792        public static Expr Convert31(EU.IValidator V) {
793            List<Expression> Expressions = new List<Expression>();
794            ParameterExpression Result = Expr.Variable(typeof(int?), "");
795            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
796	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(int?)));}) );
797            var tree = Expr.Block(new[] { Result }, Expressions);
798
799            return tree;
800        }
801        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 32", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
802        public static Expr Convert32(EU.IValidator V) {
803            List<Expression> Expressions = new List<Expression>();
804            ParameterExpression Result = Expr.Variable(typeof(uint?), "");
805            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
806	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(uint?)));}) );
807            var tree = Expr.Block(new[] { Result }, Expressions);
808
809            return tree;
810        }
811        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 33", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
812        public static Expr Convert33(EU.IValidator V) {
813            List<Expression> Expressions = new List<Expression>();
814            ParameterExpression Result = Expr.Variable(typeof(long?), "");
815            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
816	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(long?)));}) );
817            var tree = Expr.Block(new[] { Result }, Expressions);
818
819            return tree;
820        }
821        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 34", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
822        public static Expr Convert34(EU.IValidator V) {
823            List<Expression> Expressions = new List<Expression>();
824            ParameterExpression Result = Expr.Variable(typeof(ulong?), "");
825            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
826	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ulong?)));}) );
827            var tree = Expr.Block(new[] { Result }, Expressions);
828
829            return tree;
830        }
831        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 35", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
832        public static Expr Convert35(EU.IValidator V) {
833            List<Expression> Expressions = new List<Expression>();
834            ParameterExpression Result = Expr.Variable(typeof(decimal?), "");
835            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
836	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(decimal?)));}) );
837            var tree = Expr.Block(new[] { Result }, Expressions);
838
839            return tree;
840        }
841        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 36", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
842        public static Expr Convert36(EU.IValidator V) {
843            List<Expression> Expressions = new List<Expression>();
844            ParameterExpression Result = Expr.Variable(typeof(float?), "");
845            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
846	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(float?)));}) );
847            var tree = Expr.Block(new[] { Result }, Expressions);
848
849            return tree;
850        }
851        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 37", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
852        public static Expr Convert37(EU.IValidator V) {
853            List<Expression> Expressions = new List<Expression>();
854            ParameterExpression Result = Expr.Variable(typeof(double?), "");
855            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
856	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(double?)));}) );
857            var tree = Expr.Block(new[] { Result }, Expressions);
858
859            return tree;
860        }
861        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 38", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
862        public static Expr Convert38(EU.IValidator V) {
863            List<Expression> Expressions = new List<Expression>();
864            ParameterExpression Result = Expr.Variable(typeof(DateTime?), "");
865            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
866	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(DateTime?)));}) );
867            var tree = Expr.Block(new[] { Result }, Expressions);
868
869            return tree;
870        }
871        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 39", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
872        public static Expr Convert39(EU.IValidator V) {
873            List<Expression> Expressions = new List<Expression>();
874            ParameterExpression Result = Expr.Variable(typeof(char?), "");
875            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
876	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(char?)));}) );
877            var tree = Expr.Block(new[] { Result }, Expressions);
878
879            return tree;
880        }
881        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 40", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
882        public static Expr Convert40(EU.IValidator V) {
883            List<Expression> Expressions = new List<Expression>();
884            ParameterExpression Result = Expr.Variable(typeof(sbyteenum?), "");
885            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
886	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(sbyteenum?)));}) );
887            var tree = Expr.Block(new[] { Result }, Expressions);
888
889            return tree;
890        }
891        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 41", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
892        public static Expr Convert41(EU.IValidator V) {
893            List<Expression> Expressions = new List<Expression>();
894            ParameterExpression Result = Expr.Variable(typeof(byteenum?), "");
895            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
896	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(byteenum?)));}) );
897            var tree = Expr.Block(new[] { Result }, Expressions);
898
899            return tree;
900        }
901        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 42", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
902        public static Expr Convert42(EU.IValidator V) {
903            List<Expression> Expressions = new List<Expression>();
904            ParameterExpression Result = Expr.Variable(typeof(shortenum?), "");
905            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
906	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(shortenum?)));}) );
907            var tree = Expr.Block(new[] { Result }, Expressions);
908
909            return tree;
910        }
911        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 43", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
912        public static Expr Convert43(EU.IValidator V) {
913            List<Expression> Expressions = new List<Expression>();
914            ParameterExpression Result = Expr.Variable(typeof(ushortenum?), "");
915            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
916	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ushortenum?)));}) );
917            var tree = Expr.Block(new[] { Result }, Expressions);
918
919            return tree;
920        }
921        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 44", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
922        public static Expr Convert44(EU.IValidator V) {
923            List<Expression> Expressions = new List<Expression>();
924            ParameterExpression Result = Expr.Variable(typeof(intenum?), "");
925            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
926	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(intenum?)));}) );
927            var tree = Expr.Block(new[] { Result }, Expressions);
928
929            return tree;
930        }
931        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 45", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
932        public static Expr Convert45(EU.IValidator V) {
933            List<Expression> Expressions = new List<Expression>();
934            ParameterExpression Result = Expr.Variable(typeof(uintenum?), "");
935            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
936	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(uintenum?)));}) );
937            var tree = Expr.Block(new[] { Result }, Expressions);
938
939            return tree;
940        }
941        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 46", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
942        public static Expr Convert46(EU.IValidator V) {
943            List<Expression> Expressions = new List<Expression>();
944            ParameterExpression Result = Expr.Variable(typeof(longenum?), "");
945            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
946	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(longenum?)));}) );
947            var tree = Expr.Block(new[] { Result }, Expressions);
948
949            return tree;
950        }
951        [ETUtils.TestAttribute(ETUtils.TestState.Enabled, "Convert 47", new string[] { "negative", "convert", "Pri2" }, Exception = typeof(InvalidOperationException), Priority = 2)]
952        public static Expr Convert47(EU.IValidator V) {
953            List<Expression> Expressions = new List<Expression>();
954            ParameterExpression Result = Expr.Variable(typeof(ulongenum?), "");
955            Expressions.Add(			EU.Throws<System.InvalidOperationException>(() => {
956	Expr.Assign(Result, Expr.Convert(AstUtils.Void(Expr.Empty()), typeof(ulongenum?)));}) );
957            var tree = Expr.Block(new[] { Result }, Expressions);
958
959            return tree;
960        }
961        [ETUtils.TestAttribute(ETUtils.…