mono/tests/constant-division.cs

   1 using System;
   2 using System.Reflection;
   3 using System.Reflection.Emit;
   4
   5 namespace Test {
   6         public class T {
   7                 private delegate TReturn OneParameter<TReturn, TParameter0> (TParameter0 p0);
   8
   9                 private static Type[] SDivisionArgs = {typeof(int)};
  10                 private static Type[] UDivisionArgs = {typeof(uint)};
  11
  12                 public static int Main (string[] args) {
  13                         if (TestSDivision (2000, 10) != 0)
  14                                 return -1;
  15
  16                         if (TestUDivision (2000, 10) != 0)
  17                                 return -1;
  18
  19                         return 0;
  20                 }
  21
  22                 private static int TestSDivision (int divisions, int invokes)
  23                 {
  24                         int i, j;
  25                         Random rand = new Random ();
  26                         for (i = 0; i < divisions; i++) {
  27                                 int divisor = rand.Next (Int32.MinValue, Int32.MaxValue);
  28
  29                                 if (divisor == 0 || divisor == -1)
  30                                         continue;
  31
  32                                 DynamicMethod SDivision = new DynamicMethod(
  33                                         String.Format ("SDivision{0}", i),
  34                                         typeof(int),
  35                                         SDivisionArgs,
  36                                         typeof(T).Module);
  37
  38                                 ILGenerator il = SDivision.GetILGenerator();
  39                                 il.Emit(OpCodes.Ldarg_0);
  40                                 il.Emit(OpCodes.Ldc_I4, divisor);
  41                                 il.Emit(OpCodes.Div);
  42                                 il.Emit(OpCodes.Ret);
  43
  44                                 OneParameter<int, int> invokeSDivision =
  45                                         (OneParameter<int, int>)
  46                                         SDivision.CreateDelegate(typeof(OneParameter<int, int>));
  47
  48                                 for (j = 0; j < invokes; j++) {
  49                                         int dividend = rand.Next (Int32.MinValue, Int32.MaxValue);
  50                                         int result, expected;
  51
  52                                         result = invokeSDivision (dividend);
  53                                         expected = dividend / divisor;
  54
  55                                         if (result != expected) {
  56                                                 Console.WriteLine("{0} / {1} = {2} != {3})", dividend, divisor, expected, result);
  57                                                 return -1;
  58                                         }
  59                                 }
  60                         }
  61
  62                         return 0;
  63                 }
  64
  65                 private static int TestUDivision (int divisions, int invokes)
  66                 {
  67                         int i, j;
  68                         Random rand = new Random ();
  69                         for (i = 0; i < divisions; i++) {
  70                                 uint divisor = (uint)rand.Next (Int32.MinValue, Int32.MaxValue);
  71
  72                                 if (divisor == 0)
  73                                         continue;
  74
  75                                 DynamicMethod UDivision = new DynamicMethod(
  76                                         String.Format ("UDivision{0}", i),
  77                                         typeof(uint),
  78                                         UDivisionArgs,
  79                                         typeof(T).Module);
  80
  81                                 ILGenerator il = UDivision.GetILGenerator();
  82                                 il.Emit(OpCodes.Ldarg_0);
  83                                 il.Emit(OpCodes.Ldc_I4, divisor);
  84                                 il.Emit(OpCodes.Div_Un);
  85                                 il.Emit(OpCodes.Ret);
  86
  87                                 OneParameter<uint, uint> invokeUDivision =
  88                                         (OneParameter<uint, uint>)
  89                                         UDivision.CreateDelegate(typeof(OneParameter<uint, uint>));
  90
  91                                 for (j = 0; j < invokes; j++) {
  92                                         uint dividend = (uint)rand.Next (Int32.MinValue, Int32.MaxValue);
  93                                         uint result, expected;
  94
  95                                         result = invokeUDivision (dividend);
  96                                         expected = dividend / divisor;
  97
  98                                         if (result != expected) {
  99                                                 Console.WriteLine("{0} / {1} = {2} != {3})", dividend, divisor, expected, result);
 100                                                 return -1;
 101                                         }
 102                                 }
 103                         }
 104                         return 0;
 105                 }
 106         }
 107 }