mono/tests/tailcall/coreclr/JIT/Methodical/nonvirtualcall/tailcall.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.IO;
   7 using System.Runtime.CompilerServices;
   8
   9 class ApplicationException : Exception
  10 {
  11     public ApplicationException(string message) : base(message) { }
  12 }
  13
  14 namespace Test
  15 {
  16     public abstract class Base
  17     {
  18         public abstract string AbstractFinal();
  19         public abstract string AbstractOverrideFinal();
  20         public abstract string AbstractOverrideOverride();
  21         public abstract string AbstractOverrideNil();
  22
  23         public virtual string VirtualFinal()
  24         {
  25             return "Base.VirtualFinal";
  26         }
  27
  28         public virtual string VirtualNilFinal()
  29         {
  30             return "Base.VirtualNilFinal";
  31         }
  32
  33         public virtual string VirtualOverrideFinal()
  34         {
  35             return "Base.VirtualOverrideFinal";
  36         }
  37         public virtual string VirtualNilOverride()
  38         {
  39             return "Base.VirtualNilOverride";
  40         }
  41         public virtual string VirtualNilNil()
  42         {
  43             return "Base.VirtualNilNil";
  44         }
  45         public virtual string VirtualOverrideOverride()
  46         {
  47             return "Base.VirtualOverrideOverride";
  48         }
  49         public virtual string VirtualOverrideNil()
  50         {
  51             return "Base.VirtualOverrideNil";
  52         }
  53     }
  54
  55     public class Child : Base
  56     {
  57         public sealed override string AbstractFinal()
  58         {
  59             return "Child.AbstractFinal";
  60         }
  61         public string CallAbstractFinal()
  62         {
  63             return AbstractFinal();
  64         }
  65         public override string AbstractOverrideFinal()
  66         {
  67             return "Child.AbstractOverrideFinal";
  68         }
  69         public override string AbstractOverrideOverride()
  70         {
  71             return "Child.AbstractOverrideOverride";
  72         }
  73         public override string AbstractOverrideNil()
  74         {
  75             return "Child.AbstractOverrideNil";
  76         }
  77         public string CallAbstractOverrideNil()
  78         {
  79             return AbstractOverrideNil();
  80         }
  81         public sealed override string VirtualFinal()
  82         {
  83             return "Child.VirtualFinal";
  84         }
  85         public string CallVirtualFinal()
  86         {
  87             return VirtualFinal();
  88         }
  89         public override string VirtualOverrideFinal()
  90         {
  91             return "Child.VirtualOverrideFinal";
  92         }
  93         public override string VirtualOverrideOverride()
  94         {
  95             return "Child.VirtualOverrideOverride";
  96         }
  97         public override string VirtualOverrideNil()
  98         {
  99             return "Child.VirtualOverrideNil";
 100         }
 101         public string CallVirtualOverrideNil()
 102         {
 103             return VirtualOverrideNil();
 104         }
 105     }
 106
 107     public class GrandChild : Child
 108     {
 109         public sealed override string AbstractOverrideFinal()
 110         {
 111             return "GrandChild.AbstractOverrideFinal";
 112         }
 113
 114         public string CallAbstractOverrideFinal()
 115         {
 116             return AbstractOverrideFinal();
 117         }
 118
 119         public override string AbstractOverrideOverride()
 120         {
 121             return "GrandChild.AbstractOverrideOverride";
 122         }
 123
 124         public string CallAbstractOverrideOverride()
 125         {
 126             return AbstractOverrideOverride();
 127         }
 128
 129         public sealed override string VirtualNilFinal()
 130         {
 131             return "GrandChild.VirtualNilFinal";
 132         }
 133
 134         public string CallVirtualNilFinal()
 135         {
 136             return VirtualNilFinal();
 137         }
 138
 139         public sealed override string VirtualOverrideFinal()
 140         {
 141             return "GrandChild.VirtualOverrideFinal";
 142         }
 143
 144         public string CallVirtualOverrideFinal()
 145         {
 146             return VirtualOverrideFinal();
 147         }
 148
 149         public override string VirtualOverrideOverride()
 150         {
 151             return "GrandChild.VirtualOverrideOverride";
 152         }
 153
 154         public string CallVirtualOverrideOverride()
 155         {
 156             return VirtualOverrideOverride();
 157         }
 158
 159         public override string VirtualNilOverride()
 160         {
 161             return "GrandChild.VirtualNilOverride";
 162         }
 163
 164         public string CallVirtualNilOverride()
 165         {
 166             return VirtualNilOverride();
 167         }
 168
 169         public void TestGrandChild()
 170         {
 171             Console.WriteLine("Call from inside GrandChild");
 172             Assert.AreEqual("Child.AbstractFinal", CallAbstractFinal());
 173             Assert.AreEqual("GrandChild.AbstractOverrideFinal", CallAbstractOverrideFinal());
 174             Assert.AreEqual("GrandChild.AbstractOverrideOverride", CallAbstractOverrideOverride());
 175             Assert.AreEqual("Child.AbstractOverrideNil", CallAbstractOverrideNil());
 176             Assert.AreEqual("Child.VirtualFinal", CallVirtualFinal());
 177             Assert.AreEqual("GrandChild.VirtualOverrideFinal", CallVirtualOverrideFinal());
 178             Assert.AreEqual("GrandChild.VirtualOverrideOverride", CallVirtualOverrideOverride());
 179             Assert.AreEqual("Child.VirtualOverrideNil", CallVirtualOverrideNil());
 180         }
 181     }
 182
 183     public static class Program
 184     {
 185         public static void CallFromInsideGrandChild()
 186         {
 187             GrandChild child = new GrandChild();
 188             child.TestGrandChild();
 189         }
 190
 191         public static int Main(string[] args)
 192         {
 193             try
 194             {
 195                 CallFromInsideGrandChild();
 196
 197                 Console.WriteLine("Test SUCCESS");
 198                 return 100;
 199             }
 200             catch (Exception ex)
 201             {
 202                 Console.WriteLine(ex);
 203                 Console.WriteLine("Test FAILED");
 204                 return 101;
 205             }
 206         }
 207     }
 208
 209     public static class Assert
 210     {
 211         public static void AreEqual(string left, string right)
 212         {
 213             if (String.IsNullOrEmpty(left))
 214                 throw new ArgumentNullException("left");
 215             if (string.IsNullOrEmpty(right))
 216                 throw new ArgumentNullException("right");
 217             if (left != right)
 218             {
 219                 string message = String.Format("[[{0}]] != [[{1}]]", left, right);
 220                 throw new ApplicationException(message);
 221             }
 222         }
 223     }
 224 }