T8168480.java revision 3722:aacff1ac75a2 
1/*
2 * @test
3 * @bug 8168480
4 * @summary Speculative attribution of lambda causes NPE in Flow
5 * @compile T8168480.java
6 */
7
8import java.util.function.Supplier;
9
10class T8168480 {
11    void f(Runnable r) { }
12    void s(Supplier<Runnable> r) { }
13
14    private void testVoid(boolean cond) {
15        f(() ->
16                new Runnable() {
17                    public void run() {
18                        switch (42) {
19                            default:
20                                break;
21                        }
22                    }
23                }.run());
24
25        f(() ->
26                f(() -> {
27                    switch (42) {
28                        default:
29                            break;
30                    }
31                }));
32
33        f(() -> {
34            if (cond) {
35                new Runnable() {
36                    public void run() {
37                        switch (42) {
38                            default:
39                                break;
40                        }
41                    }
42                }.run();
43            } else {
44                f(() -> {
45                    switch (42) {
46                        default:
47                            break;
48                    }
49                });
50            }
51        });
52    }
53
54    private void testReturn(boolean cond) {
55        s(() ->
56                new Runnable() {
57                    public void run() {
58                        switch (42) {
59                            default:
60                                break;
61                        }
62                    }
63                });
64
65        s(() ->
66                () -> {
67                    switch (42) {
68                        default:
69                            break;
70                    }
71                });
72
73        s(() -> {
74            if (cond) {
75                return new Runnable() {
76                    public void run() {
77                        switch (42) {
78                            default:
79                                break;
80                        }
81                    }
82                };
83            } else {
84                return () -> {
85                    switch (42) {
86                        default:
87                            break;
88                    }
89                };
90            }
91        });
92
93        s(() -> {
94            return cond ?
95                new Runnable() {
96                    public void run() {
97                        switch (42) {
98                            default:
99                                break;
100                        }
101                    }
102                } : () -> {
103                    switch (42) {
104                        default:
105                            break;
106                    }
107                };
108        });
109
110        s(() -> cond ?
111                new Runnable() {
112                    public void run() {
113                        switch (42) {
114                            default:
115                                break;
116                        }
117                    }
118                } : () -> {
119                    switch (42) {
120                        default:
121                            break;
122                    }
123                });
124    }
125}
126