mono/tests/verbose.cs

   1 using System;
   2 using System.Diagnostics;
   3 using System.Linq;
   4 using System.Reflection;
   5 using System.Text.RegularExpressions;
   6
   7 public class MainClass
   8 {
   9         class TestCase
  10         {
  11                 public string MethodSpec;
  12                 public string[] ExpectedMethods;
  13         }
  14
  15         public static int Main (string[] args)
  16         {
  17                 var testCase = new TestCase {
  18                         MethodSpec = "*:Method",
  19                         ExpectedMethods = new[] {
  20                                 "N1.Test:Method ()",
  21                                 "N2.Test:Method ()",
  22                                 "N2.Test:Method (int)",
  23                                 "N2.Test:Method (int,string[])",
  24                         },
  25                 };
  26                 if (!RunTest (testCase))
  27                         return 1;
  28
  29                 testCase = new TestCase {
  30                         MethodSpec = "*:Method (int)",
  31                         ExpectedMethods = new[] {
  32                                 "N2.Test:Method (int)",
  33                         },
  34                 };
  35                 if (!RunTest (testCase))
  36                         return 2;
  37
  38                 testCase = new TestCase
  39                 {
  40                         MethodSpec = "N1.Test:Method",
  41                         ExpectedMethods = new[] {
  42                                 "N1.Test:Method ()",
  43                         },
  44                 };
  45                 if (!RunTest (testCase))
  46                         return 3;
  47
  48                 testCase = new TestCase {
  49                         MethodSpec = "Test:Method",
  50                         ExpectedMethods = new[] {
  51                                 "N1.Test:Method ()",
  52                                 "N2.Test:Method ()",
  53                                 "N2.Test:Method (int)",
  54                                 "N2.Test:Method (int,string[])",
  55                         },
  56                 };
  57                 if (!RunTest (testCase))
  58                         return 4;
  59
  60                 testCase = new TestCase {
  61                         MethodSpec = "*:Method(int,string[])",
  62                         ExpectedMethods = new[] {
  63                                 "N2.Test:Method (int,string[])",
  64                         },
  65                 };
  66                 if (!RunTest (testCase))
  67                         return 5;
  68
  69                 testCase = new TestCase {
  70                         MethodSpec = "*:Method();N2.*:Method(int,string[])",
  71                         ExpectedMethods = new[] {
  72                                 "N1.Test:Method ()",
  73                                 "N2.Test:Method ()",
  74                                 "N2.Test:Method (int,string[])",
  75                         },
  76                 };
  77                 if (!RunTest (testCase))
  78                         return 6;
  79
  80                 return 0;
  81         }
  82
  83         static bool RunTest (TestCase testCase)
  84         {
  85                 var thisProcess = typeof (MainClass).Assembly.Location;
  86
  87                 var process = StartCompileAssemblyProcess (thisProcess, testCase.MethodSpec);
  88                 var output = process.StandardOutput.ReadToEnd ();
  89                 process.WaitForExit ();
  90
  91                 var lines = output.Split (new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
  92                 foreach (var expectedMethod in testCase.ExpectedMethods) {
  93                         var sortedExpectedMethods = testCase.ExpectedMethods.OrderBy (x => x).ToArray ();
  94
  95                         var regex = new Regex ("converting method void (?<methodName>.*)");
  96                         var matches = regex.Matches (output);
  97                         var sortedJittedMethods = matches.Cast<Match> ().Select (x => x.Groups["methodName"])
  98                                                    .SelectMany (x => x.Captures.Cast<Capture> ())
  99                                                    .Select (x => x.Value)
 100                                                    .OrderBy (x => x)
 101                                                    .ToArray ();
 102
 103                         if (sortedJittedMethods.Length != sortedExpectedMethods.Length)
 104                                 return false;
 105
 106                         for (int i = 0; i < sortedJittedMethods.Length; ++i) {
 107                                 if (sortedJittedMethods[i] != sortedExpectedMethods[i])
 108                                         return false;
 109                         }
 110
 111                 }
 112
 113                 return true;
 114         }
 115
 116         static Process StartCompileAssemblyProcess (string process, string methodSpec)
 117         {
 118                 var psi = new ProcessStartInfo (process) {
 119                         UseShellExecute = false,
 120                         RedirectStandardOutput = true,
 121                 };
 122                 psi.EnvironmentVariables["MONO_ENV_OPTIONS"] = "--compile-all";
 123                 psi.EnvironmentVariables["MONO_VERBOSE_METHOD"] = methodSpec;
 124
 125                 return Process.Start (psi);
 126         }
 127 }
 128
 129 namespace N1
 130 {
 131         public class Test
 132         {
 133                 public static void Method ()
 134                 {
 135                 }
 136         }
 137 }
 138
 139 namespace N2
 140 {
 141         public class Test
 142         {
 143                 public static void Method (int n)
 144                 {
 145                 }
 146
 147                 public static void Method ()
 148                 {
 149                 }
 150
 151                 public static void Method (int n, string[] args)
 152                 {
 153                 }
 154         }
 155 }
 156
 157