-// Compiler options: -langversion:future
-
using System;
using System.Threading.Tasks;
using System.Threading;
using System.Reflection;
using System.Linq;
+using System.Runtime.CompilerServices;
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
class Base
{
- public int field_int;
+ public volatile int field_int;
protected int field_this;
protected int property_this_counter;
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;
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 ()
{
field_int = await Task.Factory.StartNew (() => 0);
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; }) +
return 0;
}
+ async Task<int> BinaryTest_5 ()
+ {
+ var r1 = await Task.FromResult (1) == 9;
+ if (r1)
+ return 1;
+
+ var r2 = 1 == await Task.FromResult (1);
+ if (!r2)
+ return 2;
+
+ return 0;
+ }
+
+ async Task<bool> BinaryTest_6 ()
+ {
+ var t = Task.Delay (1);
+ if (t == await Task.WhenAny(new [] { t }))
+ return true;
+
+ return false;
+ }
+
async Task<int> CallTest_1 ()
{
return Call (
var t = new Tester ();
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);
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 ()
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 ()
{
this[2] = await Task.Factory.StartNew (() => 6);
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> NewArrayInitTest_7 ()
+ {
+ var res = new [] { "a", new [] { "1", await Task.FromResult ("2") } [1], "b" };
+ return res [1] == "2";
+ }
async Task<bool> PropertyTest_1 ()
{
long a = 1;
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];
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);
public static int Main ()
{
var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
- where test.GetParameters ().Length == 0
+ where test.GetParameters ().Length == 0 && !test.IsDefined (typeof (CompilerGeneratedAttribute), false)
orderby test.Name
select RunTest (test);
projects / mono.git / blobdiff