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 { $inline$classTypeTest(Object o)18 public static boolean $inline$classTypeTest(Object o) { 19 return ((SubMain)o) == o; 20 } 21 $inline$interfaceTypeTest(Object o)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 classTypeTestNull()33 public static boolean classTypeTestNull() { 34 return $inline$classTypeTest(null); 35 } 36 37 /// CHECK-START: boolean Main.classTypeTestExactMain() register (after) 38 /// CHECK: CheckCast classTypeTestExactMain()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 classTypeTestExactSubMain()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 classTypeTestSubMainOrNull()51 public static boolean classTypeTestSubMainOrNull() { 52 return $inline$classTypeTest(subMain); 53 } 54 55 /// CHECK-START: boolean Main.classTypeTestMainOrNull() register (after) 56 /// CHECK: CheckCast classTypeTestMainOrNull()57 public static boolean classTypeTestMainOrNull() { 58 return $inline$classTypeTest(mainField); 59 } 60 61 /// CHECK-START: boolean Main.classTypeTestUnrelated() register (after) 62 /// CHECK: CheckCast classTypeTestUnrelated()63 public static boolean classTypeTestUnrelated() { 64 return $inline$classTypeTest(unrelatedField); 65 } 66 67 /// CHECK-START: boolean Main.classTypeTestFinalUnrelated() register (after) 68 /// CHECK: CheckCast classTypeTestFinalUnrelated()69 public static boolean classTypeTestFinalUnrelated() { 70 return $inline$classTypeTest(finalUnrelatedField); 71 } 72 73 /// CHECK-START: boolean Main.interfaceTypeTestNull() register (after) 74 /// CHECK-NOT: CheckCast interfaceTypeTestNull()75 public static boolean interfaceTypeTestNull() { 76 return $inline$interfaceTypeTest(null); 77 } 78 79 /// CHECK-START: boolean Main.interfaceTypeTestExactMain() register (after) 80 /// CHECK: CheckCast interfaceTypeTestExactMain()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 interfaceTypeTestExactSubMain()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 interfaceTypeTestSubMainOrNull()93 public static boolean interfaceTypeTestSubMainOrNull() { 94 return $inline$interfaceTypeTest(subMain); 95 } 96 97 /// CHECK-START: boolean Main.interfaceTypeTestMainOrNull() register (after) 98 /// CHECK: CheckCast interfaceTypeTestMainOrNull()99 public static boolean interfaceTypeTestMainOrNull() { 100 return $inline$interfaceTypeTest(mainField); 101 } 102 103 /// CHECK-START: boolean Main.interfaceTypeTestUnrelated() register (after) 104 /// CHECK: CheckCast interfaceTypeTestUnrelated()105 public static boolean interfaceTypeTestUnrelated() { 106 return $inline$interfaceTypeTest(unrelatedField); 107 } 108 109 /// CHECK-START: boolean Main.interfaceTypeTestFinalUnrelated() register (after) 110 /// CHECK: CheckCast interfaceTypeTestFinalUnrelated()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 knownTestWithLoadedClass()117 public static String knownTestWithLoadedClass() { 118 return (String)$inline$getString(); 119 } 120 121 /// CHECK-START: Itf Main.knownTestWithUnloadedClass() register (after) 122 /// CHECK: CheckCast knownTestWithUnloadedClass()123 public static Itf knownTestWithUnloadedClass() { 124 return (Itf)$inline$getString(); 125 } 126 $inline$getString()127 public static Object $inline$getString() { 128 return new String(); 129 } 130 $inline$getMain()131 public static Object $inline$getMain() { 132 return new Main(); 133 } 134 135 /// CHECK-START: void Main.nonNullBoundType() register (after) 136 /// CHECK-NOT: NullCheck nonNullBoundType()137 public static void nonNullBoundType() { 138 Main main = (Main)$inline$getMain(); 139 main.getClass(); 140 } 141 main(String[] args)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