blob: df257d8182559654e00be43f13b7f495454e182c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
class A {}
interface G {}
class E extends A implements G {}
public class TriTestTypecheck {
public static void main(String[] args) {}
void byteCall(byte b) {}
void shortCall(short s) {}
void charCall(char c) {}
void intCall(int i) {}
void longCall(long l) {}
void floatCall(float f) {}
void doubleCall(double d) {}
void booleanCall(boolean t) {}
void aCall(A a) {}
void eCall(E e) {}
void gCall(G g) {}
void foo(boolean t, byte b, short s, char c, int i, long l, float f, double d, A a, E e, G g) {
byteCall(t ? 37 : b);
byteCall(t ? b : 37);
byteCall(t ? b : b);
shortCall(t ? 37 : s);
shortCall(t ? s : 37);
shortCall(t ? b : s);
shortCall(t ? s : b);
shortCall(t ? s : s);
charCall(t ? 37 : c);
charCall(t ? c : 37);
charCall(t ? c : c);
intCall(t ? 257 : b);
intCall(t ? b : 257);
intCall(t ? 65537 : s);
intCall(t ? s : 65537);
intCall(t ? -1 : c);
intCall(t ? c : -1);
intCall(t ? i : i);
longCall(t ? l : b);
longCall(t ? b : l);
longCall(t ? l : s);
longCall(t ? s : l);
longCall(t ? l : c);
longCall(t ? c : l);
longCall(t ? l : i);
longCall(t ? i : l);
longCall(t ? l : l);
floatCall(t ? f : b);
floatCall(t ? b : f);
floatCall(t ? f : s);
floatCall(t ? s : f);
floatCall(t ? f : c);
floatCall(t ? c : f);
floatCall(t ? f : i);
floatCall(t ? i : f);
floatCall(t ? f : l);
floatCall(t ? l : f);
floatCall(t ? f : f);
doubleCall(t ? d : b);
doubleCall(t ? b : d);
doubleCall(t ? d : s);
doubleCall(t ? s : d);
doubleCall(t ? d : c);
doubleCall(t ? c : d);
doubleCall(t ? d : i);
doubleCall(t ? i : d);
doubleCall(t ? d : l);
doubleCall(t ? l : d);
doubleCall(t ? d : f);
doubleCall(t ? f : d);
doubleCall(t ? d : d);
booleanCall(t ? t : t);
aCall(t ? a : null);
aCall(t ? null : a);
aCall(t ? a : e);
aCall(t ? e : a);
aCall(t ? a : a);
gCall(t ? g : null);
gCall(t ? null : g);
gCall(t ? g : e);
gCall(t ? e : g);
gCall(t ? g : g);
eCall(t ? e : e);
}
}
|
