/* * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /** * @test * @bug 4359628 * @summary Test fix for JDI: methods Accessible.is...() lie about array types * @author Tim Bell * * @run build TestScaffold VMConnection TargetListener TargetAdapter * @run compile -g AccessSpecifierTest.java * @run driver AccessSpecifierTest */ import com.sun.jdi.*; import com.sun.jdi.event.*; import com.sun.jdi.request.*; import java.util.*; /********** target program **********/ /** Sample package-private interface. */ interface AccessSpecifierPackagePrivateInterface {} /** Sample package-private class. */ class AccessSpecifierPackagePrivateClass {} /** Sample package-private class. */ class AccessSpecifierPackagePrivateClassTwo implements AccessSpecifierPackagePrivateInterface {} class AccessSpecifierTarg { private boolean z0; boolean z1[]={z0}, z2[][]={z1}; public byte b0; byte b1[]={b0}, b2[][]={b1}; protected short s0; short s1[]={s0}, s2[][]={s1}; int i0; int i1[]={i0}, i2[][]={i1}; private long l0; long l1[]={l0}, l2[][]={l1}; public char c0; char c1[]={c0}, c2[][]={c1}; protected float f0; float f1[]={f0}, f2[][]={f1}; double d0; double d1[]={d0}, d2[][]={d1}; Boolean Z0 = Boolean.TRUE; Boolean Z1[]={Z0}, Z2[][]={Z1}; Byte B0 = new Byte ((byte)0x1f); Byte B1[]={B0}, B2[][]={B1}; Character C0 = new Character ('a'); Character C1[]={C0}, C2[][]={C1}; Double D0 = new Double (1.0d); Double D1[]={D0}, D2[][]={D1}; Float F0 = new Float (2.0f); Float F1[]={F0}, F2[][]={F1}; Integer I0 = new Integer (8675309); Integer I1[]={I0}, I2[][]={I1}; Long L0 = new Long (973230999L); Long L1[]={L0}, L2[][]={L1}; String S0 = "A String"; String S1[]={S0}, S2[][]={S1}; Object O0 = new Object(); Object O1[]={O0}, O2[][]={O1}; private static class U {} protected static class V {} public static class W {} static class P {} // package private U u0=new U(), u1[]={u0}, u2[][]={u1}; V v0=new V(), v1[]={v0}, v2[][]={v1}; W w0=new W(), w1[]={w0}, w2[][]={w1}; P p0=new P(), p1[]={p0}, p2[][]={p1}; private static interface StaticInterface {} private static class ClassUsingStaticInterface implements StaticInterface {} StaticInterface staticInterface_0 = new ClassUsingStaticInterface(); StaticInterface staticInterface_1[]={staticInterface_0}; StaticInterface staticInterface_2[][]={staticInterface_1}; AccessSpecifierTarg a0, a1[]={a0}, a2[][]={a1}; AccessSpecifierPackagePrivateClass ppc0=new AccessSpecifierPackagePrivateClass(); AccessSpecifierPackagePrivateClass ppc1[]={ppc0}; AccessSpecifierPackagePrivateClass ppc2[][]={ppc1}; AccessSpecifierPackagePrivateInterface ppi0 = new AccessSpecifierPackagePrivateClassTwo (); AccessSpecifierPackagePrivateInterface ppi1[]={ppi0}; AccessSpecifierPackagePrivateInterface ppi2[][]={ppi1}; public AccessSpecifierTarg() { super(); } public void ready(){ System.out.println("Ready!"); } public static void main(String[] args){ System.out.println("Howdy!"); AccessSpecifierTarg my = new AccessSpecifierTarg(); my.ready(); System.out.println("Goodbye from AccessSpecifierTarg!"); } } /********** test program **********/ public class AccessSpecifierTest extends TestScaffold { private final static String debugeeName = "AccessSpecifierTarg"; /** Known Accessible Information about the Debugee. */ private static final int NAME = 0; private static final int ACCESS = 1; private final static String primitives[][] = { {"z", "private", "public", "public"}, {"b", "public", "public", "public"}, {"s", "protected", "public", "public"}, {"i", "package private", "public", "public"}, {"l", "private", "public", "public"}, {"c", "public", "public", "public"}, {"f", "protected", "public", "public"}, {"d", "package private", "public", "public"}, }; private final static String references[][] = { {"java.lang.Boolean" , "public"}, {"java.lang.Character", "public"}, {"java.lang.Class" , "public"}, {"java.lang.Double" , "public"}, {"java.lang.Float" , "public"}, {"java.lang.Integer" , "public"}, {"java.lang.Long" , "public"}, {"java.lang.String" , "public"}, {"java.lang.Object" , "public"}, {"AccessSpecifierTarg", "package private"}, {"AccessSpecifierPackagePrivateClass", "package private"}, {"AccessSpecifierPackagePrivateInterface", "package private"}, {"AccessSpecifierTarg$StaticInterface", "private"}, {"AccessSpecifierTarg$U", "private"}, {"AccessSpecifierTarg$V", "protected"}, {"AccessSpecifierTarg$W", "public"}, {"AccessSpecifierTarg$P", "package private"} }; AccessSpecifierTest (String args[]) { super(args); } public static void main(String[] args) throws Exception { new AccessSpecifierTest (args).startTests(); } /********** test core **********/ private void testAccessible (String name, Accessible a, boolean isPublic, boolean isProtected, boolean isPrivate, boolean isPackagePrivate) { System.out.println (" Testing: " + name + " modifiers = " + Integer.toBinaryString(a.modifiers())); if (a.isPublic() != isPublic) { failure("**Name = " + name + " expecting: " + isPublic + " isPublic() was: " + a.isPublic()); } if (a.isPrivate() != isPrivate) { failure("**Name = " + name + " expecting: " + isPrivate + " isPrivate() was: " + a.isPrivate()); } if (a.isProtected() != isProtected) { failure("**Name = " + name + " expecting: " + isProtected + " isProtected() is: " + a.isProtected()); } if (a.isPackagePrivate() != isPackagePrivate) { failure("**Name = " + name + " expecting: " + isPackagePrivate + " isPackagePrivate() is: " + a.isPackagePrivate()); } } protected void runTests() throws Exception { /* * Get to the top of ready() */ startTo(debugeeName, "ready", "()V"); ReferenceType rt = findReferenceType(debugeeName); if (rt == null) { throw new Exception ("ReferenceType not found for: " + debugeeName); } for (int i = 0; i < primitives.length; i++) { for (int j = 0; j < 3; j++) { String suffix = Integer.toString(j); String fieldName = primitives[i][NAME] + suffix; Field field = rt.fieldByName(fieldName); if (field == null) { throw new Exception ("Field not found for: " + fieldName); } Type t = field.type(); if (t instanceof ReferenceType) { ReferenceType reft = (ReferenceType)t; if (primitives[i][ACCESS + j].equals("public")) { testAccessible(reft.name(), reft, true, false, false, false); } else if (primitives[i][ACCESS + j].equals("protected")) { testAccessible(reft.name(), reft, false, true, false, false); } else if (primitives[i][ACCESS + j].equals("private")) { testAccessible(reft.name(), reft, false, false, true, false); } else if (primitives[i][ACCESS + j].equals("package private")) { testAccessible(reft.name(), reft, false, false, false, true); } } else { System.out.println (" Skipping " + t + " (primitive scalar type)"); } } } String brackets[] = {"[][]", "[]", ""}; for (int i = 0; i < references.length; i++) { for (int j = 0; j < 3; j++) { String suffix = brackets[j]; String referenceName = references[i][NAME] + suffix; ReferenceType refType = findReferenceType(referenceName); if (refType == null) { System.out.println ("Skipping " + referenceName + " (not found)"); } else { if (references[i][ACCESS].equals("public")) { testAccessible(refType.name(), refType, true, false, false, false); } else if (references[i][ACCESS].equals("protected")) { testAccessible(refType.name(), refType, false, true, false, false); } else if (references[i][ACCESS].equals("private")) { testAccessible(refType.name(), refType, false, false, true, false); } else if (references[i][ACCESS].equals("package private")) { testAccessible(refType.name(), refType, false, false, false, true); } } } } /* * resume the target listening for events */ listenUntilVMDisconnect(); /* * deal with results of test * if anything has called failure("foo") testFailed will be true */ if (!testFailed) { println("AccessSpecifierTest: passed"); } else { throw new Exception("AccessSpecifierTest: failed"); } } }