jdk/test/com/sun/jdi/AccessSpecifierTest.java - platform/libcore - Git at Google

 /*
  * 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");
         }
     }
 }
	/*
	* 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");
	}
	}
	}