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
17public 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
221interface Itf {
222}
223
224class SubMain extends Main implements Itf {
225}
226
227class Unrelated {
228}
229
230final class FinalUnrelated {
231}
232