using System;
using System.Collections.Generic;
+using System.Collections.ObjectModel;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
}
struct GFoo2<T> {
- public T t, t2;
+ public T t, t2, t3;
}
class GFoo3<T> {
public static int test_0_unbox_any_enum () {
IFaceUnbox iface = new ClassUnbox ();
AnEnum res = iface.Unbox<AnEnum, int> (AnEnum.One, 0, 1);
- return res == AnEnum.Two ? 0 : 1;
+ if (res != AnEnum.Two)
+ return 1;
+ res = iface.Unbox<AnEnum, int> (AnEnum.One, 0, AnEnum.Two);
+ if (res != AnEnum.Two)
+ return 2;
+ return 0;
}
[MethodImplAttribute (MethodImplOptions.NoInlining)]
return t;
}
+ interface IFaceGSharedVtIn {
+ T return_t<T> (T t);
+ }
+
+ class ClassGSharedVtIn : IFaceGSharedVtIn {
+ public T return_t<T> (T t) {
+ return t;
+ }
+ }
+
public static int test_0_gsharedvt_in () {
// Check that the non-generic argument is passed at the correct stack position
int r = args_simple<bool> (true, 42);
var v2 = return_t<GFoo2<int>> (v);
if (v2.t != 55 || v2.t2 != 32)
return 6;
+ IFaceGSharedVtIn o = new ClassGSharedVtIn ();
+ var v3 = new GFoo2<long> () { t = 55, t2 = 32 };
+ var v4 = o.return_t<GFoo2<long>> (v3);
+ if (v4.t != 55 || v4.t2 != 32)
+ return 7;
i = new GSharedTests ().return_this_t<int> (42);
if (i != 42)
- return 7;
+ return 8;
return 0;
}
return 0;
}
+ interface IGetType {
+ Type gettype<T, T2>(T t, T2 t2);
+ }
+
+ public class CGetType : IGetType {
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public Type gettype<T, T2>(T t, T2 t2) {
+ return t.GetType ();
+ }
+ }
+
+ public static int test_0_constrained_gettype () {
+ IGetType c = new CGetType ();
+ if (c.gettype<int, int> (1, 1) != typeof (int))
+ return 1;
+ if (c.gettype<string, int> ("A", 1) != typeof (string))
+ return 2;
+ return 0;
+ }
+
struct Pair<T1, T2> {
public T1 First;
public T2 Second;
interface IConstrained<T3> {
void foo_gsharedvt_arg (T3 s);
+ T3 foo_gsharedvt_ret (T3 s);
}
static object constrained_res;
public void foo_gsharedvt_arg (T s) {
constrained_res = s;
}
+
+ public T foo_gsharedvt_ret (T s) {
+ return s;
+ }
+ }
+
+ struct ConsStructThrow : IConstrained {
+ public void foo () {
+ throw new Exception ();
+ }
+
+ public void foo_ref_arg (string s) {
+ }
}
interface IFaceConstrained {
void constrained_void_iface_call<T, T2>(T t, T2 t2) where T2 : IConstrained;
void constrained_void_iface_call_ref_arg<T, T2>(T t, T2 t2) where T2 : IConstrained;
void constrained_void_iface_call_gsharedvt_arg<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T>;
+ T constrained_iface_call_gsharedvt_ret<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T>;
+ T2 constrained_normal_call<T, T2>(T t, T2 t2) where T2 : VClass;
}
class ClassConstrained : IFaceConstrained {
public void constrained_void_iface_call_gsharedvt_arg<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T> {
t2.foo_gsharedvt_arg (t);
}
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public T constrained_iface_call_gsharedvt_ret<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T> {
+ return t2.foo_gsharedvt_ret (t);
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public T2 constrained_normal_call<T, T2>(T t, T2 t2) where T2 : VClass {
+ /* This becomes a constrained call even through 't2' is forced to be a reference type by the constraint */
+ return (T2)t2.foo (5);
+ }
+ }
+
+ class VClass {
+ public virtual VClass foo (int i) {
+ return this;
+ }
}
public static int test_0_constrained_void_iface_call () {
return 0;
}
- public static int test_0_constraine_void_iface_call_gsharedvt_arg () {
+ public static int test_0_constrained_eh () {
+ var s2 = new ConsStructThrow () { };
+ try {
+ IFaceConstrained c = new ClassConstrained ();
+ c.constrained_void_iface_call<int, ConsStructThrow> (1, s2);
+ return 1;
+ } catch (Exception) {
+ return 0;
+ }
+ }
+
+ public static int test_0_constrained_void_iface_call_gsharedvt_arg () {
// This tests constrained calls through interfaces with one gsharedvt arg, like IComparable<T>.CompareTo ()
IFaceConstrained c = new ClassConstrained ();
return 0;
}
+ public static int test_0_constrained_iface_call_gsharedvt_ret () {
+ IFaceConstrained c = new ClassConstrained ();
+
+ var s = new ConsStruct<int> ();
+ int ires = c.constrained_iface_call_gsharedvt_ret<int, ConsStruct<int>, int> (42, s, 55);
+ if (ires != 42)
+ return 1;
+
+ var s2 = new ConsStruct<string> ();
+ string sres = c.constrained_iface_call_gsharedvt_ret<string, ConsStruct<string>, int> ("A", s2, 55);
+ if (sres != "A")
+ return 2;
+
+ return 0;
+ }
+
+ public static int test_0_constrained_normal_call () {
+ IFaceConstrained c = new ClassConstrained ();
+
+ var o = new VClass ();
+ var res = c.constrained_normal_call<int, VClass> (1, o);
+ return res == o ? 0 : 1;
+ }
+
public static async Task<T> FooAsync<T> (int i, int j) {
Task<int> t = new Task<int> (delegate () { return 42; });
var response = await t;
[MethodImplAttribute (MethodImplOptions.NoInlining)]
public static void call_async<T> (int i, int j) {
Task<T> t = FooAsync<T> (1, 2);
- t.RunSynchronously ();
+ // FIXME: This doesn't work
+ //t.RunSynchronously ();
}
// In AOT mode, the async infrastructure depends on gsharedvt methods
call_async<string> (1, 2);
return 0;
}
+
+ public static int test_0_array_helper_gsharedvt () {
+ var arr = new AnEnum [16];
+ var c = new ReadOnlyCollection<AnEnum> (arr);
+ return c.Contains (AnEnum.Two) == false ? 0 : 1;
+ }
+}
+
+// #13191
+public class MobileServiceCollection<TTable, TCol>
+{
+ public async Task<int> LoadMoreItemsAsync(int count = 0) {
+ await Task.Delay (1000);
+ int results = await ProcessQueryAsync ();
+ return results;
+ }
+
+ protected async virtual Task<int> ProcessQueryAsync() {
+ await Task.Delay (1000);
+ throw new Exception ();
+ }
}
#if !MOBILE
projects / mono.git / blobdiff