1/*
2 * Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/*
25 * @test
26 * @bug 4319507
27 * @summary Verify correct implementation of JLS2e 6.6.2.1
28 * @author maddox
29 *
30 * @run compile ProtectedMemberAccess1.java
31 */
32
33import pkg.SuperClass;
34
35class ProtectedMemberAccess1a extends SuperClass {
36
37  // Access to a protected member via its simple name
38  // is always legal in a subclass of the class in
39  // which the member is declared.
40
41  int i = pi;
42  int j = spi;
43
44  int x = pm();
45  int y = spm();
46
47  pC  obj1;
48  spC obj2;
49
50  pI  obj3;
51  spI obj4;
52
53  Object o1 = (pC) null;
54  Object o2 = (spC) null;
55
56  Object o3 = (pI) null;
57  Object o4 = (spI) null;
58
59  class C1 extends pC {}
60  class C2 extends spC {}
61
62  interface I1 extends pI {}
63  interface I2 extends spI {}
64
65  static {
66
67    spi = 2;
68
69    int y = spm();
70
71    pC  obj1;
72    spC obj2;
73
74    pI  obj3;
75    spI obj4;
76
77    Object o1 = (pC) null;
78    Object o2 = (spC) null;
79
80    Object o3 = (pI) null;
81    Object o4 = (spI) null;
82
83    //class C1 extends pC {}
84    class C2 extends spC {}
85
86    //interface I1 extends pI {}
87    //interface I2 extends spI {}
88
89  }
90
91  void m() {
92
93    pi  = 1;
94    spi = 2;
95
96    int x = pm();
97    int y = spm();
98
99    pC  obj1;
100    spC obj2;
101
102    pI  obj3;
103    spI obj4;
104
105    Object o1 = (pC) null;
106    Object o2 = (spC) null;
107
108    Object o3 = (pI) null;
109    Object o4 = (spI) null;
110
111    class C1 extends pC {}
112    class C2 extends spC {}
113
114    //interface I1 extends pI {}
115    //interface I2 extends spI {}
116
117  }
118
119  class Inner {
120
121    int i = pi;
122    int j = spi;
123
124    int x = pm();
125    int y = spm();
126
127    pC  obj1;
128    spC obj2;
129
130    pI  obj3;
131    spI obj4;
132
133    Object o1 = (pC) null;
134    Object o2 = (spC) null;
135
136    Object o3 = (pI) null;
137    Object o4 = (spI) null;
138
139    class C1 extends pC {}
140    class C2 extends spC {}
141
142    //interface I1 extends pI {}
143    //interface I2 extends spI {}
144
145    // Not allowed in inner classes.
146    // static { ... }
147
148    void m() {
149
150      pi  = 1;
151      spi = 2;
152
153      int x = pm();
154      int y = spm();
155
156      pC  obj1;
157      spC obj2;
158
159      pI  obj3;
160      spI obj4;
161
162      Object o1 = (pC) null;
163      Object o2 = (spC) null;
164
165      Object o3 = (pI) null;
166      Object o4 = (spI) null;
167
168      class C1 extends pC {}
169      class C2 extends spC {}
170
171      //interface I1 extends pI {}
172      //interface I2 extends spI {}
173    }
174  }
175
176}
177
178class ProtectedMemberAccess2a extends pkg.SuperClass {
179
180  // Access to a protected instance (non-static) field, instance method,
181  // or member type by a qualified name is always legal in a subclass of
182  // the class in which the member is declared.  Such access to a protected
183  // instance field or instance method is allowed if the qualifying type
184  // or the type of the qualifying expression is (a subclass of) the class
185  // in which the reference occurs.
186
187  ProtectedMemberAccess2a x =
188        new ProtectedMemberAccess2a();
189
190  static ProtectedMemberAccess2a sx =
191        new ProtectedMemberAccess2a();
192
193  int i = x.pi;
194  int j = x.spi;
195
196  int n = sx.pi;
197  int m = sx.spi;
198
199  static int sn = sx.pi;
200  static int sm = sx.spi;
201
202  int w = x.pm();
203  int y = x.spm();
204
205  int u = sx.pm();
206  int v = sx.spm();
207
208  ProtectedMemberAccess2a.pC  obj1;
209  ProtectedMemberAccess2a.spC obj2;
210
211  ProtectedMemberAccess2a.pI  obj3;
212  ProtectedMemberAccess2a.spI obj4;
213
214  Object o1 = (ProtectedMemberAccess2a.pC) null;
215  Object o2 = (ProtectedMemberAccess2a.spC) null;
216
217  Object o3 = (ProtectedMemberAccess2a.pI) null;
218  Object o4 = (ProtectedMemberAccess2a.spI) null;
219
220  class C1 extends ProtectedMemberAccess2a.pC {}
221  class C2 extends ProtectedMemberAccess2a.spC {}
222
223  interface I1 extends ProtectedMemberAccess2a.pI {}
224  interface I2 extends ProtectedMemberAccess2a.spI {}
225
226  static {
227
228    ProtectedMemberAccess2a lx =
229      new ProtectedMemberAccess2a();
230
231    sx.pi  = 1;
232    sx.spi = 2;
233
234    lx.pi  = 1;
235    lx.spi = 2;
236
237    int n = sx.pi;
238    int m = sx.spi;
239
240    int k = lx.pi;
241    int l = lx.spi;
242
243    int u = sx.pm();
244    int v = sx.spm();
245
246    int w = lx.pm();
247    int z = lx.spm();
248
249    ProtectedMemberAccess2a.pC  obj1;
250    ProtectedMemberAccess2a.spC obj2;
251
252    ProtectedMemberAccess2a.pI  obj3;
253    ProtectedMemberAccess2a.spI obj4;
254
255    Object o1 = (ProtectedMemberAccess2a.pC) null;
256    Object o2 = (ProtectedMemberAccess2a.spC) null;
257
258    Object o3 = (ProtectedMemberAccess2a.pI) null;
259    Object o4 = (ProtectedMemberAccess2a.spI) null;
260
261    //class C1 extends ProtectedMemberAccess2a.pC {}
262    class C2 extends ProtectedMemberAccess2a.spC {}
263
264    //interface I1 extends ProtectedMemberAccess2a.pI {}
265    //interface I2 extends ProtectedMemberAccess2a.spI {}
266
267  }
268
269  void m() {
270
271    ProtectedMemberAccess2a lx =
272        new ProtectedMemberAccess2a();
273
274    x.pi  = 1;
275    x.spi = 2;
276
277    sx.pi  = 1;
278    sx.spi = 2;
279
280    lx.pi  = 1;
281    lx.spi = 2;
282
283    int t = x.pm();
284    int y = x.spm();
285
286    int u = sx.pm();
287    int v = sx.spm();
288
289    int w = lx.pm();
290    int z = lx.spm();
291
292    int i = x.pi;
293    int j = x.spi;
294
295    int n = sx.pi;
296    int m = sx.spi;
297
298    int k = lx.pi;
299    int l = lx.spi;
300
301    ProtectedMemberAccess2a.pC  obj1;
302    ProtectedMemberAccess2a.spC obj2;
303
304    ProtectedMemberAccess2a.pI  obj3;
305    ProtectedMemberAccess2a.spI obj4;
306
307    Object o1 = (ProtectedMemberAccess2a.pC) null;
308    Object o2 = (ProtectedMemberAccess2a.spC) null;
309
310    Object o3 = (ProtectedMemberAccess2a.pI) null;
311    Object o4 = (ProtectedMemberAccess2a.spI) null;
312
313    class C1 extends ProtectedMemberAccess2a.pC {}
314    class C2 extends ProtectedMemberAccess2a.spC {}
315
316    //interface I1 extends ProtectedMemberAccess2a.pI {}
317    //interface I2 extends ProtectedMemberAccess2a.spI {}
318
319  }
320
321  class Inner {
322
323    int i = x.pi;
324    int j = x.spi;
325
326    int n = sx.pi;
327    int m = sx.spi;
328
329    //static int sn = sx.pi;
330    //static int sm = sx.spi;
331
332    int w = x.pm();
333    int y = x.spm();
334
335    int u = sx.pm();
336    int v = sx.spm();
337
338    ProtectedMemberAccess2a.pC  obj1;
339    ProtectedMemberAccess2a.spC obj2;
340
341    ProtectedMemberAccess2a.pI  obj3;
342    ProtectedMemberAccess2a.spI obj4;
343
344    Object o1 = (ProtectedMemberAccess2a.pC) null;
345    Object o2 = (ProtectedMemberAccess2a.spC) null;
346
347    Object o3 = (ProtectedMemberAccess2a.pI) null;
348    Object o4 = (ProtectedMemberAccess2a.spI) null;
349
350    class C1 extends ProtectedMemberAccess2a.pC {}
351    class C2 extends ProtectedMemberAccess2a.spC {}
352
353    //interface I1 extends ProtectedMemberAccess2a.pI {}
354    //interface I2 extends ProtectedMemberAccess2a.spI {}
355
356    // Not allowed in inner classes.
357    // static { ... }
358
359    void m() {
360
361      ProtectedMemberAccess2a lx =
362        new ProtectedMemberAccess2a();
363
364      x.pi  = 1;
365      x.spi = 2;
366
367      sx.pi  = 1;
368      sx.spi = 2;
369
370      lx.pi  = 1;
371      lx.spi = 2;
372
373      int t = x.pm();
374      int y = x.spm();
375
376      int u = sx.pm();
377      int v = sx.spm();
378
379      int w = lx.pm();
380      int z = lx.spm();
381
382      int i = x.pi;
383      int j = x.spi;
384
385      int n = sx.pi;
386      int m = sx.spi;
387
388      int k = lx.pi;
389      int l = lx.spi;
390
391      ProtectedMemberAccess2a.pC  obj1;
392      ProtectedMemberAccess2a.spC obj2;
393
394      ProtectedMemberAccess2a.pI  obj3;
395      ProtectedMemberAccess2a.spI obj4;
396
397      Object o1 = (ProtectedMemberAccess2a.pC) null;
398      Object o2 = (ProtectedMemberAccess2a.spC) null;
399
400      Object o3 = (ProtectedMemberAccess2a.pI) null;
401      Object o4 = (ProtectedMemberAccess2a.spI) null;
402
403      class C1 extends ProtectedMemberAccess2a.pC {}
404      class C2 extends ProtectedMemberAccess2a.spC {}
405
406      //interface I1 extends ProtectedMemberAccess2a.pI {}
407      //interface I2 extends ProtectedMemberAccess2a.spI {}
408
409    }
410
411  }
412
413}
414
415
416class SubClass extends ProtectedMemberAccess3a { }
417
418class ProtectedMemberAccess3a extends pkg.SuperClass {
419
420  // Access to a protected instance (non-static) field, instance method,
421  // or member type by a qualified name is always legal in a subclass of
422  // the class in which the member is declared.  Such access to a protected
423  // instance field or instance method is allowed if the qualifying type
424  // or the type of the qualifying expression is (a subclass of) the class
425  // in which the reference occurs.
426
427  SubClass x = new SubClass();
428
429  static SubClass sx = new SubClass();
430
431  int i = x.pi;
432  int j = x.spi;
433
434  int n = sx.pi;
435  int m = sx.spi;
436
437  static int sn = sx.pi;
438  static int sm = sx.spi;
439
440  int w = x.pm();
441  int y = x.spm();
442
443  int u = sx.pm();
444  int v = sx.spm();
445
446  SubClass.pC  obj1;
447  SubClass.spC obj2;
448
449  SubClass.pI  obj3;
450  SubClass.spI obj4;
451
452  Object o1 = (SubClass.pC) null;
453  Object o2 = (SubClass.spC) null;
454
455  Object o3 = (SubClass.pI) null;
456  Object o4 = (SubClass.spI) null;
457
458  class C1 extends SubClass.pC {}
459  class C2 extends SubClass.spC {}
460
461  interface I1 extends SubClass.pI {}
462  interface I2 extends SubClass.spI {}
463
464  static {
465
466    SubClass lx = new SubClass();
467
468    sx.pi  = 1;
469    sx.spi = 2;
470
471    lx.pi  = 1;
472    lx.spi = 2;
473
474    int n = sx.pi;
475    int m = sx.spi;
476
477    int k = lx.pi;
478    int l = lx.spi;
479
480    int u = sx.pm();
481    int v = sx.spm();
482
483    int w = lx.pm();
484    int z = lx.spm();
485
486    SubClass.pC  obj1;
487    SubClass.spC obj2;
488
489    SubClass.pI  obj3;
490    SubClass.spI obj4;
491
492    Object o1 = (SubClass.pC) null;
493    Object o2 = (SubClass.spC) null;
494
495    Object o3 = (SubClass.pI) null;
496    Object o4 = (SubClass.spI) null;
497
498    //class C1 extends SubClass.pC {}
499    class C2 extends SubClass.spC {}
500
501    //interface I1 extends SubClass.pI {}
502    //interface I2 extends SubClass.spI {}
503
504  }
505
506  void m() {
507
508    SubClass lx = new SubClass();
509
510    x.pi  = 1;
511    x.spi = 2;
512
513    sx.pi  = 1;
514    sx.spi = 2;
515
516    lx.pi  = 1;
517    lx.spi = 2;
518
519    int t = x.pm();
520    int y = x.spm();
521
522    int u = sx.pm();
523    int v = sx.spm();
524
525    int w = lx.pm();
526    int z = lx.spm();
527
528    int i = x.pi;
529    int j = x.spi;
530
531    int n = sx.pi;
532    int m = sx.spi;
533
534    int k = lx.pi;
535    int l = lx.spi;
536
537    SubClass.pC  obj1;
538    SubClass.spC obj2;
539
540    SubClass.pI  obj3;
541    SubClass.spI obj4;
542
543    Object o1 = (SubClass.pC) null;
544    Object o2 = (SubClass.spC) null;
545
546    Object o3 = (SubClass.pI) null;
547    Object o4 = (SubClass.spI) null;
548
549    class C1 extends SubClass.pC {}
550    class C2 extends SubClass.spC {}
551
552    //interface I1 extends SubClass.pI {}
553    //interface I2 extends SubClass.spI {}
554
555  }
556
557  class Inner {
558
559    int i = x.pi;
560    int j = x.spi;
561
562    int n = sx.pi;
563    int m = sx.spi;
564
565    //static int sn = sx.pi;
566    //static int sm = sx.spi;
567
568    int w = x.pm();
569    int y = x.spm();
570
571    int u = sx.pm();
572    int v = sx.spm();
573
574    SubClass.pC  obj1;
575    SubClass.spC obj2;
576
577    SubClass.pI  obj3;
578    SubClass.spI obj4;
579
580    Object o1 = (SubClass.pC) null;
581    Object o2 = (SubClass.spC) null;
582
583    Object o3 = (SubClass.pI) null;
584    Object o4 = (SubClass.spI) null;
585
586    class C1 extends SubClass.pC {}
587    class C2 extends SubClass.spC {}
588
589    //interface I1 extends SubClass.pI {}
590    //interface I2 extends SubClass.spI {}
591
592    // Not allowed in inner classes.
593    // static { ... }
594
595    void m() {
596
597      SubClass lx = new SubClass();
598
599      x.pi  = 1;
600      x.spi = 2;
601
602      sx.pi  = 1;
603      sx.spi = 2;
604
605      lx.pi  = 1;
606      lx.spi = 2;
607
608      int t = x.pm();
609      int y = x.spm();
610
611      int u = sx.pm();
612      int v = sx.spm();
613
614      int w = lx.pm();
615      int z = lx.spm();
616
617      int i = x.pi;
618      int j = x.spi;
619
620      int n = sx.pi;
621      int m = sx.spi;
622
623      int k = lx.pi;
624      int l = lx.spi;
625
626      SubClass.pC  obj1;
627      SubClass.spC obj2;
628
629      SubClass.pI  obj3;
630      SubClass.spI obj4;
631
632      Object o1 = (SubClass.pC) null;
633      Object o2 = (SubClass.spC) null;
634
635      Object o3 = (SubClass.pI) null;
636      Object o4 = (SubClass.spI) null;
637
638      class C1 extends SubClass.pC {}
639      class C2 extends SubClass.spC {}
640
641      //interface I1 extends SubClass.pI {}
642      //interface I2 extends SubClass.spI {}
643
644    }
645
646  }
647
648}
649