[tests] Add random immediate division test

diff --git a/mono/tests/Makefile.am b/mono/tests/Makefile.am
index 1cfd4fdb897ecec92dd246cf7b6bc7452b68d09f..0ac6d87689963392f0f37e620a9e5bf1332fa64d 100644 (file)
--- a/mono/tests/Makefile.am
+++ b/mono/tests/Makefile.am
@@ -254,6 +254,7 @@ BASE_TEST_CS_SRC_UNIVERSAL=         \
        long.cs                 \
        jit-ulong.cs            \
        jit-float.cs            \
+       constant-division.cs    \
        pop.cs                  \
        time.cs                 \
        pointer.cs              \

diff --git a/mono/tests/constant-division.cs b/mono/tests/constant-division.cs
new file mode 100644 (file)
index 0000000..1e9941c
--- /dev/null
+++ b/mono/tests/constant-division.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Test {
+       public class T {
+               private delegate TReturn OneParameter<TReturn, TParameter0> (TParameter0 p0);
+
+               private static Type[] SDivisionArgs = {typeof(int)};
+               private static Type[] UDivisionArgs = {typeof(uint)};
+
+               public static int Main (string[] args) {
+                       if (TestSDivision (2000, 10) != 0)
+                               return -1;
+
+                       if (TestUDivision (2000, 10) != 0)
+                               return -1;
+
+                       return 0;
+               }
+
+               private static int TestSDivision (int divisions, int invokes)
+               {
+                       int i, j;
+                       Random rand = new Random ();
+                       for (i = 0; i < divisions; i++) {
+                               int divisor = rand.Next (Int32.MinValue, Int32.MaxValue);
+
+                               if (divisor == 0 || divisor == -1)
+                                       continue;
+
+                               DynamicMethod SDivision = new DynamicMethod(
+                                       String.Format ("SDivision{0}", i),
+                                       typeof(int),
+                                       SDivisionArgs,
+                                       typeof(T).Module);
+
+                               ILGenerator il = SDivision.GetILGenerator();
+                               il.Emit(OpCodes.Ldarg_0);
+                               il.Emit(OpCodes.Ldc_I4, divisor);
+                               il.Emit(OpCodes.Div);
+                               il.Emit(OpCodes.Ret);
+
+                               OneParameter<int, int> invokeSDivision =
+                                       (OneParameter<int, int>)
+                                       SDivision.CreateDelegate(typeof(OneParameter<int, int>));
+
+                               for (j = 0; j < invokes; j++) {
+                                       int dividend = rand.Next (Int32.MinValue, Int32.MaxValue);
+                                       int result, expected;
+
+                                       result = invokeSDivision (dividend);
+                                       expected = dividend / divisor;
+
+                                       if (result != expected) {
+                                               Console.WriteLine("{0} / {1} = {2} != {3})", dividend, divisor, expected, result);
+                                               return -1;
+                                       }
+                               }
+                       }
+
+                       return 0;
+               }
+
+               private static int TestUDivision (int divisions, int invokes)
+               {
+                       int i, j;
+                       Random rand = new Random ();
+                       for (i = 0; i < divisions; i++) {
+                               uint divisor = (uint)rand.Next (Int32.MinValue, Int32.MaxValue);
+
+                               if (divisor == 0)
+                                       continue;
+
+                               DynamicMethod UDivision = new DynamicMethod(
+                                       String.Format ("UDivision{0}", i),
+                                       typeof(uint),
+                                       UDivisionArgs,
+                                       typeof(T).Module);
+
+                               ILGenerator il = UDivision.GetILGenerator();
+                               il.Emit(OpCodes.Ldarg_0);
+                               il.Emit(OpCodes.Ldc_I4, divisor);
+                               il.Emit(OpCodes.Div_Un);
+                               il.Emit(OpCodes.Ret);
+
+                               OneParameter<uint, uint> invokeUDivision =
+                                       (OneParameter<uint, uint>)
+                                       UDivision.CreateDelegate(typeof(OneParameter<uint, uint>));
+
+                               for (j = 0; j < invokes; j++) {
+                                       uint dividend = (uint)rand.Next (Int32.MinValue, Int32.MaxValue);
+                                       uint result, expected;
+
+                                       result = invokeUDivision (dividend);
+                                       expected = dividend / divisor;
+
+                                       if (result != expected) {
+                                               Console.WriteLine("{0} / {1} = {2} != {3})", dividend, divisor, expected, result);
+                                               return -1;
+                                       }
+                               }
+                       }
+                       return 0;
+               }
+       }
+}