Merge pull request #1921 from mattzink/master

[mono.git] / mono / mini / aot-tests.cs

diff --git a/mono/mini/aot-tests.cs b/mono/mini/aot-tests.cs
index 13ef4ffcd7a9b280afa58fde8b0c7c48eef208fe..98bd905faf3550cfae9354d3c34360ba53cdebd9 100644 (file)
--- a/mono/mini/aot-tests.cs
+++ b/mono/mini/aot-tests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
@@ -106,6 +107,7 @@ class Tests
                return 0;
        }
 
+       [Category ("DYNCALL")]
        [Category ("GSHAREDVT")]
        static int test_0_arm64_dyncall_gsharedvt_out_hfa_double () {
                /* gsharedvt out trampoline with double hfa argument */
@@ -124,6 +126,7 @@ class Tests
                return 0;
        }
 
+       [Category ("DYNCALL")]
        [Category ("GSHAREDVT")]
        static int test_0_arm64_dyncall_gsharedvt_out_hfa_float () {
                /* gsharedvt out trampoline with double hfa argument */
@@ -200,10 +203,92 @@ class Tests
                return 0;
        }
 
+       class Foo6 {
+               public T reg_stack_split_inner<T> (int i, int j, T l) {
+                       return l;
+               }
+       }
+
+       [Category("DYNCALL")]
+       static int test_0_arm_dyncall_reg_stack_split () {
+               var m = typeof (Foo6).GetMethod ("reg_stack_split_inner").MakeGenericMethod (new Type[] { typeof (long) });
+               var o = new Foo6 ();
+               if ((long)m.Invoke (o, new object [] { 1, 2, 3 }) != 3)
+                       return 1;
+               if ((long)m.Invoke (o, new object [] { 1, 2, Int64.MaxValue }) != Int64.MaxValue)
+                       return 2;
+               return 0;
+       }
+
        static int test_0_partial_sharing_regress_30204 () {
                var t = typeof (System.Collections.Generic.Comparer<System.Collections.Generic.KeyValuePair<string, string>>);
                var d = new SortedDictionary<string, string> ();
                d.Add ("key1", "banana");
                return d ["key1"] == "banana" ? 0 : 1;
        }
+
+       class NullableMethods {
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public static bool GetHasValue<T>(Nullable<T> value) where T : struct {
+                       return value.HasValue;
+               }
+
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public static T GetValue<T>(Nullable<T> value) where T : struct {
+                       return value.Value;
+               }
+       }
+
+       [Category ("DYNCALL")]
+       public static int test_0_dyncall_nullable () {
+               int? v;
+
+               v = 42;
+               NullableMethods.GetHasValue (v);
+               bool b = (bool)typeof (NullableMethods).GetMethod ("GetHasValue").MakeGenericMethod (new Type [] { typeof (int) }).Invoke (null, new object [] { v });
+               if (!b)
+                       return 1;
+               v = null;
+               b = (bool)typeof (NullableMethods).GetMethod ("GetHasValue").MakeGenericMethod (new Type [] { typeof (int) }).Invoke (null, new object [] { v });
+               if (b)
+                       return 2;
+
+               v = 42;
+               NullableMethods.GetValue (v);
+               var res = (int)typeof (NullableMethods).GetMethod ("GetValue").MakeGenericMethod (new Type [] { typeof (int) }).Invoke (null, new object [] { v });
+               if (res != 42)
+                       return 3;
+               return 0;
+       }
+
+       enum AnEnum {
+               A = 0,
+               B = 1
+       }
+
+       public static int test_0_enum_eq_comparer () {
+               var c = EqualityComparer<AnEnum>.Default;
+               return (!c.Equals (AnEnum.A, AnEnum.B) && c.Equals (AnEnum.A, AnEnum.A)) ? 0 : 1;
+       }
+
+       public static int test_0_enum_comparer () {
+               var c = Comparer<AnEnum>.Default;
+               return c.Compare (AnEnum.A, AnEnum.A);
+       }
+
+       private static Dictionary<long, TValue> ConvertDictionary<TValue>(Dictionary<long, IList<TValue>> source) {
+               return source.ToDictionary(pair => pair.Key, pair => pair.Value[0]);
+       }
+
+       [Category ("GSHAREDVT")]
+       public static int test_0_gsharedvt_non_variable_arg () {
+               Dictionary<long, IList<int>> data = new Dictionary<long, IList<int>>
+            {
+                               {123L, new List<int> {2}}
+            };
+               Dictionary<long, int> newDict = ConvertDictionary(data);
+               if (newDict.Count != 1)
+                       return 1;
+               return 0;
+       }
 }