mcs/tests/gtest-409.cs

   1 // Compiler options: -langversion:latest
   2 using System;
   3
   4 //
   5 // parser conditional and cast expression tests
   6 //
   7
   8 class A<T>
   9 {
  10         public static int Value;
  11 }
  12
  13 public class ConditionalParsing
  14 {
  15         class T
  16         {
  17                 public T (string path, bool mode)
  18                         : this (path, mode, (mode == true ? 1 : 2), 1, int.MaxValue)
  19                 {
  20                 }
  21
  22                 public T (string s, bool m, int i, int i2, int i3)
  23                 {
  24                 }
  25         }
  26
  27         class Const
  28         {
  29                 const int c = true ? 1 : 2;
  30         }
  31
  32         struct S
  33         {
  34         }
  35
  36         struct MyTestStruct : IDisposable
  37         {
  38                 public void Dispose ()
  39                 {
  40                 }
  41
  42                 public static implicit operator MyTestStruct (int i)
  43                 {
  44                         return new MyTestStruct ();
  45                 }
  46         }
  47
  48         void Test_1 (bool a)
  49         {
  50                 int? b = a ? 3 : 4;
  51         }
  52
  53         void Test_2 ()
  54         {
  55                 string mp = "";
  56                 int a = 1;
  57                 int _provider = mp.Length == a ? _provider = 4 : 5;
  58         }
  59
  60         T? Test_3<T> (Func<T, T, T> result, T t) where T : struct
  61         {
  62                 return new T? (result (t, t));
  63         }
  64
  65         void Test_4 (bool x, bool y)
  66         {
  67                 int s = x ? (y ? 2 : 4) : (y ? 5 : 7);
  68         }
  69
  70         void Test_5 (bool a, IDisposable fs)
  71         {
  72                 using (a ? fs : null) {
  73                         Console.WriteLine ("");
  74                 }
  75         }
  76
  77         void Test_6 (bool a)
  78         {
  79                 char[] escaped_text_chars =
  80                         a != false ?
  81                         new char [] {'&', '<', '>', '\r', '\n'} :
  82                         new char [] {'&', '<', '>'};
  83         }
  84
  85         void Test_7 (object o)
  86         {
  87                 object a = (S?[]) o;
  88         }
  89
  90         void Test_8 (DateTime value)
  91         {
  92                 var     _endDate = value > DateTime.MinValue ? new DateTime ? (value) : null;
  93         }
  94
  95         void Test_9 ()
  96         {
  97                 bool b = (1 == 2);
  98                 bool c = (1 == 1);
  99                 string a = (b ? (c ? "#" : "#") : "");
 100         }
 101
 102         void Test_10 ()
 103         {
 104                 int i = new int [] { 1, 2, 3 } [1];
 105         }
 106
 107         void Test_11 ()
 108         {
 109                 int a = (int)(A<int>.Value);
 110         }
 111
 112         static int Test_12 (bool arg)
 113         {
 114                 return arg ? Foo (() => { return 1; }) : 1;
 115         }
 116
 117         static int Foo (Func<int> arg)
 118         {
 119                 return 1;
 120         }
 121
 122         void Test_13 (object param)
 123         {
 124                 if (param as bool? ?? false) {} else {}
 125         }
 126
 127         int? Test_14 ()
 128         {
 129                 bool a = false, b = false;
 130                 object c = null;
 131
 132                 return a ? (b ? c as int? : null) : null;
 133         }
 134
 135         Action<int> Test_15 (Action<int> arg)
 136         {
 137                 return arg ?? (Helper<int>);
 138         }
 139
 140         void Test_16 ()
 141         {
 142                 bool? b = Test (1, arg:2);
 143         }
 144
 145         void Test_17 ()
 146         {
 147                 {
 148                         using (MyTestStruct? mts = (int?) 1)
 149                         {
 150                         }
 151                 }
 152         }
 153
 154         void Test_18 (bool b, Action a)
 155         {
 156                 var e = b ? () => { } : a;
 157         }
 158
 159         void Test_19 (int[,] table)
 160         {
 161                 var x = 1 > 0  ? table[5, 1] : 0;
 162         }
 163
 164         void Test_20 ()
 165         {
 166                 var t = (Object)string.Empty;
 167         }
 168
 169         void Test_21 ()
 170         {
 171                 var t = (Int32)sbyte.MaxValue;
 172         }
 173
 174         void Test_22 (bool args)
 175         {
 176                 var x = args ?.2f : -.2f;
 177         }
 178
 179         void Test_23 (string args)
 180         {
 181                 var x = args == null ? default : 1;
 182         }
 183
 184         static void Helper<T> (T arg)
 185         {
 186         }
 187
 188         static bool Test (object b, int arg)
 189         {
 190                 return false;
 191         }
 192
 193         public static void Main ()
 194         {
 195         }
 196 }
 197