Resolve conditional expression unreachable expression with unreachable flag set

[mono.git] / mcs / tests / test-async-13.cs

diff --git a/mcs/tests/test-async-13.cs b/mcs/tests/test-async-13.cs
index 3d0bfdc89c16a0b43676b670a40a12d0d7a48a44..303bf8bd9887503eb4ce7da2590b556ceaa8b4eb 100644 (file)
--- a/mcs/tests/test-async-13.cs
+++ b/mcs/tests/test-async-13.cs
@@ -24,6 +24,13 @@ struct S
        {
                return new S (400, "a");
        }
+       
+       public static S operator + (S a, S b)
+       {
+               return new S () {
+                       Value = a.Value + b.Value
+               };
+       }
 }
 
 enum E
@@ -33,7 +40,7 @@ enum E
 
 class Base
 {
-       public int field_int;
+       public volatile int field_int;
        protected int field_this;
        protected int property_this_counter;
        
@@ -132,6 +139,11 @@ class Base
                return s.Value;
        }
        
+       public T[] CreateArray<T> (int size)
+       {
+               return new T [size];
+       }
+       
        protected static void CallRefParams (ref int i, params int[] i2)
        {
                i = 5;
@@ -224,6 +236,40 @@ class Tester : Base
                int[] a = new int[3] { 3, 6, 9 };
                return a [await Task.Factory.StartNew (() => (long)1)] + value;
        }
+       
+       async Task<bool> ArrayAccessTest_7 ()
+       {
+               short?[] s = new short?[] { 3, 2, 1 };
+               var r = s [await Task.Factory.StartNew (() => 1)]++;
+               return r == 2;
+       }
+
+       async Task<int> ArrayAccessTest_8 ()
+       {
+               var s = new byte?[] { 3, 2, 1 };
+               var r = s [await Task.Factory.StartNew (() => 1)] += await Task.Factory.StartNew (() => (byte)30);
+               if (r != 32)
+                       return 1;
+               
+               if (s [1] != 32)
+                       return 2;
+               
+               return 0;
+       }
+
+       async Task<int> ArrayAccessTest_9 ()
+       {
+               var s = new Base ();
+               s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += 9;
+               s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => 9);
+               
+               var res = s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => 9);
+               if (res != 9)
+                       return 1;
+
+               s.CreateArray<S> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => new S () { Value = 4 });
+               return 0;
+       }
 
        async Task<int> AssignTest_1 ()
        {
@@ -231,6 +277,23 @@ class Tester : Base
                return field_int;
        }
        
+       async Task<bool> AssignTest_2 ()
+       {
+               long? l = await Task.Factory.StartNew<sbyte?> (() => null);
+               return l == null;
+       }
+       
+       async Task<int> AssignTest_3 ()
+       {
+               int a = await Task.Factory.StartNew (() => 1), b = await Task.Factory.StartNew (() => 2);
+               if (a != 1)
+                       return 1;
+               if (b != 2)
+                       return b;
+               
+               return 0;
+       }
+       
        async Task<int> BinaryTest_1 ()
        {
                return await Task.Factory.StartNew (() => { Thread.Sleep (10); return 5; }) +
@@ -248,6 +311,36 @@ class Tester : Base
                return b ? -1 : i == 8 ? 0 : i;
        }
        
+       async Task<int> BinaryTest_3 ()
+       {
+               var r = await Task.Factory.StartNew<bool?> (() => true) & await Task.Factory.StartNew<bool?> (() => null);
+               if (r != null)
+                       return 1;
+
+               r = await Task.Factory.StartNew<bool?> (() => null) | await Task.Factory.StartNew<bool?> (() => true);
+               if (r != true)
+                       return 2;
+               
+               r = await Task.Factory.StartNew<bool?> (() => null) != await Task.Factory.StartNew<bool?> (() => true);
+               if (r != true)
+                       return 3;
+
+               return 0;
+       }
+       
+       async Task<int> BinaryTest_4 ()
+       {
+               var r1 = await Task.Factory.StartNew<short?> (() => 2) * await Task.Factory.StartNew<byte?> (() => null);
+               if (r1 != null)
+                       return 1;
+
+               var r2 = await Task.Factory.StartNew<decimal?> (() => 100) / await Task.Factory.StartNew<decimal?> (() => null);
+               if (r2 != null)
+                       return 2;
+               
+               return 0;
+       }
+       
        async Task<int> CallTest_1 ()
        {
                return Call (
@@ -298,12 +391,21 @@ class Tester : Base
                return t.CallS (await Task.Factory.StartNew (() => this)) == 400;
        }
        
+       async Task<bool> CoalescingTest_1 ()
+       {
+               var r = await Task.Factory.StartNew<string> (() => null)  ?? await Task.Factory.StartNew (() => "x");
+               return r == "x";
+       }
+       
+       async Task<bool> CoalescingTest_2 ()
+       {
+               var r = await Task.Factory.StartNew<short?> (() => null)  ?? await Task.Factory.StartNew<byte> (() => 2);
+               return r == 2;
+       }
+       
        async Task<int> ConditionalTest_1 ()
        {
-               // TODO: problem with Resumable point setup when the expression never emitted
-               //bool b = true;
-               //return true ? await Task.Factory.StartNew (() => 0) : await Task.Factory.StartNew (() => 1);
-               return 0;
+               return true ? await Task.Factory.StartNew (() => 0) : await Task.Factory.StartNew (() => 1);
        }
        
        async Task<int> ConditionalTest_2 ()
@@ -341,6 +443,23 @@ class Tester : Base
                CallEvent ();
                return value - 5;
        }
+       
+       async Task<int> FieldTest_1 ()
+       {
+               var s = new Base ();
+               s.field_int = 3;
+               s.field_int += await Task.Factory.StartNew (() => 6);
+               if (s.field_int != 9)
+                       return 1;
+               
+               var r = s.field_int -= await Task.Factory.StartNew (() => 5);
+               if (r != 4)
+                       return 2;
+               
+               if (s.field_int != 4)
+                       return 3;
+               return 0;
+       }
 
        async Task<bool> IndexerTest_1 ()
        {
@@ -409,6 +528,12 @@ class Tester : Base
                return true;
        }
 
+       async Task<bool> IsTest_2 ()
+       {
+               var r = await Task.Factory.StartNew<uint?> (() => 1) is uint;
+               return r;
+       }
+       
        async Task<bool> LogicalUserOperator_1 ()
        {
                var r = await Task.Factory.StartNew (() => new Base ()) && await Task.Factory.StartNew (() => new Base ());
@@ -525,7 +650,13 @@ class Tester : Base
                var a = new S[] { await Task.Factory.StartNew (() => new S () { Value = 4 }) };
                return a [0].Value - 4;
        }
-
+       
+       async Task<bool> NewArrayInitTest_6 ()
+       {
+               var a = new int[] { 2, 3, 2, 3, 5, 6, 7, 2, 4, await Task.Factory.StartNew (() => 5), 11, 23, 45 };
+               return a.Length == 13;
+       }
+       
        async Task<bool> PropertyTest_1 ()
        {
                PropertyInt = await Task.Factory.StartNew (() => 6);
@@ -572,6 +703,27 @@ class Tester : Base
                return (a + checked (-await Task.Factory.StartNew (() => 2))) == -1;
        }
 
+       async Task<bool> UnaryTest_2 ()
+       {
+               short? s = 2;
+               int value = 2;
+               return (value * ~await Task.Factory.StartNew (() => s)) == -6;
+       }
+
+       async Task<bool> UnaryTest_3 ()
+       {
+               var d = new decimal? [2];
+               d[1] = 4;
+               var r = ++d[await Task.Factory.StartNew (() => 1)];
+               return r == 5;
+       }
+       
+       async Task<bool> VariableInitializer_1 ()
+       {
+               int a = 2, b = await Task.Factory.StartNew (() => 1), c = await Task.Factory.StartNew (() => 1);
+               return a == (b + c);
+       }
+
        static bool RunTest (MethodInfo test)
        {
                Console.Write ("Running test {0, -25}", test.Name);