Home | History | Annotate | Download | only in src 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 public class Main {
     18   public static boolean $inline$classTypeTest(Object o) {
     19     return ((SubMain)o) == o;
     20   }
     21 
     22   public static boolean $inline$interfaceTypeTest(Object o) {
     23     return ((Itf)o) == o;
     24   }
     25 
     26   public static SubMain subMain;
     27   public static Main mainField;
     28   public static Unrelated unrelatedField;
     29   public static FinalUnrelated finalUnrelatedField;
     30 
     31   /// CHECK-START: boolean Main.classTypeTestNull() register (after)
     32   /// CHECK-NOT: CheckCast
     33   public static boolean classTypeTestNull() {
     34     return $inline$classTypeTest(null);
     35   }
     36 
     37   /// CHECK-START: boolean Main.classTypeTestExactMain() register (after)
     38   /// CHECK: CheckCast
     39   public static boolean classTypeTestExactMain() {
     40     return $inline$classTypeTest(new Main());
     41   }
     42 
     43   /// CHECK-START: boolean Main.classTypeTestExactSubMain() register (after)
     44   /// CHECK-NOT: CheckCast
     45   public static boolean classTypeTestExactSubMain() {
     46     return $inline$classTypeTest(new SubMain());
     47   }
     48 
     49   /// CHECK-START: boolean Main.classTypeTestSubMainOrNull() register (after)
     50   /// CHECK-NOT: CheckCast
     51   public static boolean classTypeTestSubMainOrNull() {
     52     return $inline$classTypeTest(subMain);
     53   }
     54 
     55   /// CHECK-START: boolean Main.classTypeTestMainOrNull() register (after)
     56   /// CHECK: CheckCast
     57   public static boolean classTypeTestMainOrNull() {
     58     return $inline$classTypeTest(mainField);
     59   }
     60 
     61   /// CHECK-START: boolean Main.classTypeTestUnrelated() register (after)
     62   /// CHECK: CheckCast
     63   public static boolean classTypeTestUnrelated() {
     64     return $inline$classTypeTest(unrelatedField);
     65   }
     66 
     67   /// CHECK-START: boolean Main.classTypeTestFinalUnrelated() register (after)
     68   /// CHECK: CheckCast
     69   public static boolean classTypeTestFinalUnrelated() {
     70     return $inline$classTypeTest(finalUnrelatedField);
     71   }
     72 
     73   /// CHECK-START: boolean Main.interfaceTypeTestNull() register (after)
     74   /// CHECK-NOT: CheckCast
     75   public static boolean interfaceTypeTestNull() {
     76     return $inline$interfaceTypeTest(null);
     77   }
     78 
     79   /// CHECK-START: boolean Main.interfaceTypeTestExactMain() register (after)
     80   /// CHECK: CheckCast
     81   public static boolean interfaceTypeTestExactMain() {
     82     return $inline$interfaceTypeTest(new Main());
     83   }
     84 
     85   /// CHECK-START: boolean Main.interfaceTypeTestExactSubMain() register (after)
     86   /// CHECK-NOT: CheckCast
     87   public static boolean interfaceTypeTestExactSubMain() {
     88     return $inline$interfaceTypeTest(new SubMain());
     89   }
     90 
     91   /// CHECK-START: boolean Main.interfaceTypeTestSubMainOrNull() register (after)
     92   /// CHECK-NOT: CheckCast
     93   public static boolean interfaceTypeTestSubMainOrNull() {
     94     return $inline$interfaceTypeTest(subMain);
     95   }
     96 
     97   /// CHECK-START: boolean Main.interfaceTypeTestMainOrNull() register (after)
     98   /// CHECK: CheckCast
     99   public static boolean interfaceTypeTestMainOrNull() {
    100     return $inline$interfaceTypeTest(mainField);
    101   }
    102 
    103   /// CHECK-START: boolean Main.interfaceTypeTestUnrelated() register (after)
    104   /// CHECK: CheckCast
    105   public static boolean interfaceTypeTestUnrelated() {
    106     return $inline$interfaceTypeTest(unrelatedField);
    107   }
    108 
    109   /// CHECK-START: boolean Main.interfaceTypeTestFinalUnrelated() register (after)
    110   /// CHECK: CheckCast
    111   public static boolean interfaceTypeTestFinalUnrelated() {
    112     return $inline$interfaceTypeTest(finalUnrelatedField);
    113   }
    114 
    115   /// CHECK-START: java.lang.String Main.knownTestWithLoadedClass() register (after)
    116   /// CHECK-NOT: CheckCast
    117   public static String knownTestWithLoadedClass() {
    118     return (String)$inline$getString();
    119   }
    120 
    121   /// CHECK-START: Itf Main.knownTestWithUnloadedClass() register (after)
    122   /// CHECK: CheckCast
    123   public static Itf knownTestWithUnloadedClass() {
    124     return (Itf)$inline$getString();
    125   }
    126 
    127   public static Object $inline$getString() {
    128     return new String();
    129   }
    130 
    131   public static Object $inline$getMain() {
    132     return new Main();
    133   }
    134 
    135   /// CHECK-START: void Main.nonNullBoundType() register (after)
    136   /// CHECK-NOT: NullCheck
    137   public static void nonNullBoundType() {
    138     Main main = (Main)$inline$getMain();
    139     main.getClass();
    140   }
    141 
    142   public static void main(String[] args) {
    143     classTypeTestNull();
    144     try {
    145       classTypeTestExactMain();
    146       throw new Error("ClassCastException expected");
    147     } catch (ClassCastException e) {}
    148     classTypeTestExactSubMain();
    149 
    150     subMain = null;
    151     classTypeTestSubMainOrNull();
    152     subMain = new SubMain();
    153     classTypeTestSubMainOrNull();
    154 
    155     mainField = null;
    156     classTypeTestMainOrNull();
    157     mainField = new Main();
    158     try {
    159       classTypeTestMainOrNull();
    160       throw new Error("ClassCastException expected");
    161     } catch (ClassCastException e) {}
    162     mainField = new SubMain();
    163     classTypeTestMainOrNull();
    164 
    165     unrelatedField = null;
    166     classTypeTestUnrelated();
    167     unrelatedField = new Unrelated();
    168     try {
    169       classTypeTestUnrelated();
    170       throw new Error("ClassCastException expected");
    171     } catch (ClassCastException e) {}
    172 
    173     finalUnrelatedField = null;
    174     classTypeTestFinalUnrelated();
    175     finalUnrelatedField = new FinalUnrelated();
    176     try {
    177       classTypeTestFinalUnrelated();
    178       throw new Error("ClassCastException expected");
    179     } catch (ClassCastException e) {}
    180 
    181     interfaceTypeTestNull();
    182     try {
    183       interfaceTypeTestExactMain();
    184       throw new Error("ClassCastException expected");
    185     } catch (ClassCastException e) {}
    186     interfaceTypeTestExactSubMain();
    187 
    188     subMain = null;
    189     interfaceTypeTestSubMainOrNull();
    190     subMain = new SubMain();
    191     interfaceTypeTestSubMainOrNull();
    192 
    193     mainField = null;
    194     interfaceTypeTestMainOrNull();
    195     mainField = new Main();
    196     try {
    197       interfaceTypeTestMainOrNull();
    198       throw new Error("ClassCastException expected");
    199     } catch (ClassCastException e) {}
    200     mainField = new SubMain();
    201     interfaceTypeTestMainOrNull();
    202 
    203     unrelatedField = null;
    204     interfaceTypeTestUnrelated();
    205     unrelatedField = new Unrelated();
    206     try {
    207       interfaceTypeTestUnrelated();
    208       throw new Error("ClassCastException expected");
    209     } catch (ClassCastException e) {}
    210 
    211     finalUnrelatedField = null;
    212     interfaceTypeTestFinalUnrelated();
    213     finalUnrelatedField = new FinalUnrelated();
    214     try {
    215       interfaceTypeTestFinalUnrelated();
    216       throw new Error("ClassCastException expected");
    217     } catch (ClassCastException e) {}
    218   }
    219 }
    220 
    221 interface Itf {
    222 }
    223 
    224 class SubMain extends Main implements Itf {
    225 }
    226 
    227 class Unrelated {
    228 }
    229 
    230 final class FinalUnrelated {
    231 }
    232