|
Java example source code file (GenericsTest.java)
This example Java source code file (GenericsTest.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The GenericsTest.java Java example source code
/*
* Copyright (c) 2003, 2004, 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 4421040
* @summary JPDA: Add support for JSR-014 Generics
*
* @author jjh
*
* @run build TestScaffold VMConnection TargetListener TargetAdapter
* @run compile -g GenericsTest.java
* @run main GenericsTest
*/
import com.sun.jdi.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;
import java.util.*;
/********** target program **********/
class GenericsTarg {
static Gen1<String> genField = new Gen1();;
static Sub1 sub1Field = new Sub1();
String[] strArray = null;
int intField = 0;
Object objField;
public static void main(String[] args){
//genField.print();
System.out.println("Goodbye from GenericsTarg!");
}
}
class Gen1<tt> {
tt field1;
Gen1() {
System.out.println("Gen1<tt> ctor called");
}
tt method1(tt p1) {
Gen1<String> xxx = null;
System.out.println("method1: param is " + p1);
return p1;
}
String method2() {
String str = "This local variable is not generic";
return str;
}
}
class Sub1 extends Gen1<String> {
String method1(String p1) {
System.out.println("method1 has been overridden: param is " + p1);
return "hi";
}
}
/********** test program **********/
public class GenericsTest extends TestScaffold {
ReferenceType targetClass;
ThreadReference mainThread;
static boolean useOld;
GenericsTest (String args[]) {
super(args);
}
public static void main(String[] args) throws Exception {
/*
* The 1.5 FE must be able to talk to a 1.4 BE, ie, JDWP version <= 1.4.
* This is hard to test since this test file must be compiled with
* -source 1.5 which will cause its class file to be version 49 which
* won't run on a pre 1.5 JDK. We can simulate this though
* by passing
* -xjdk <pathname>
* to this test which causes the debuggee to be run on that JDK.
* This should be a version of 1.5 that accepts classfile version 49,
* but which still contains the 1.4 version of JDWP.
* This trick verifies that the calls to genericSignature() methods
* in the test do not cause the generic JDWP commands to be issued.
* The value to use for this is currently:
* /java/re/jdk/1.5/promoted/all/b17/binaries/solaris-sparc
*/
if (args.length > 1 && args[0].equals("-xjdk")) {
System.setProperty("java.home", args[1]);
useOld = true;
// Delete this arg
String[] args1 = new String[args.length - 2];
for (int ii = 0; ii < args.length -2; ii++) {
args1[ii] = args[ii + 2];
}
args = args1;
}
new GenericsTest(args).startTests();
}
/********** test core **********/
protected void runTests() throws Exception {
/*
* Get to the top of main()
* to determine targetClass and mainThread
*/
BreakpointEvent bpe = startToMain("GenericsTarg");
targetClass = bpe.location().declaringType();
{
/*
* Prove that arrays aren't broken and that
* null is returned if there is no generic signature
*/
Field strArray = targetClass.fieldByName("strArray");
ReferenceType fieldType = (ReferenceType)(strArray.type());
String genSig = fieldType.genericSignature();
System.out.println("strArray name = " + strArray);
System.out.println(" type = " + fieldType);
System.out.println(" sig = " + fieldType.signature());
System.out.println(" genSig = " + genSig);
if (!useOld && genSig != null) {
failure("FAILED: Expected generic signature = null for "
+ fieldType.name() + ", received: " + genSig);
}
}
{
// prove that primitives aren't broken.
Field intField = targetClass.fieldByName("intField");
Type fieldType = (Type)(intField.type());
System.out.println("intField name = " + intField);
System.out.println(" type = " + fieldType);
System.out.println(" sig = " + fieldType.signature());
}
Field genField = targetClass.fieldByName("genField");
ReferenceType gen1Class = (ReferenceType)(genField.type());
String genSig;
String expected;
{
// Verify genericSignature for a class
expected = "<tt:Ljava/lang/Object;>Ljava/lang/Object;";
genSig = gen1Class.genericSignature();
System.out.println("genField name = " + genField);
System.out.println(" type = " + gen1Class);
System.out.println(" sig = " + gen1Class.signature());
System.out.println(" genSig = " + genSig);
if (!useOld && !expected.equals(genSig)) {
failure("FAILED: Expected generic signature for gen1: " +
expected + ", received: " + genSig);
}
}
{
// Verify genericSignature() for a field
List genFields = gen1Class.fields();
Field field1 = (Field)genFields.get(0);
// there is only one field
expected = "Ttt;";
genSig = field1.genericSignature();
System.out.println("field1 name = " + field1);
System.out.println(" type = " + gen1Class.signature());
System.out.println(" sig = " + field1.signature());
System.out.println(" gen sig = " + genSig);
if (!useOld && !expected.equals(genSig)) {
failure("FAILED: Expected generic signature for field1: " +
expected + ", received: " + genSig);
}
}
{
// Verify genericSignature() for a method
List genMethods = gen1Class.methodsByName("method1");
// There is only uno
Method method1 = (Method)genMethods.get(0);
expected = "(Ttt;)Ttt;";
genSig = method1.genericSignature();
System.out.println("method1 name = " + method1);
System.out.println(" type = " + gen1Class.signature());
System.out.println(" sig = " + method1.signature());
System.out.println(" gen sig = " + genSig);
System.out.println(" bridge = " + method1.isBridge());
if (!useOld && !expected.equals(genSig)) {
failure("FAILED: Expected generic signature for method1: " +
expected + ", received: " + genSig);
}
// Verify this is not a bridge method
if (method1.isBridge()) {
failure("FAILED: Expected gen1.method1 to not be a bridge"
+ " method but it is");
}
// Verify genericSignature for a local var
List localVars = method1.variables();
String[] expectedGenSigs = { "Ttt", "Gen1<String>" };
for ( int ii = 0 ; ii < localVars.size(); ii++) {
expected = expectedGenSigs[ii];
LocalVariable pp = (LocalVariable)localVars.get(ii);
genSig = pp.genericSignature();
System.out.println(" local var " + ii + " = " + pp.name());
System.out.println(" sig = " + pp.signature());
System.out.println(" gen sig = " + genSig);
//jjh Uncomment when generics for local vars are available from
//jjh javac and hotspot. See:
//jjh 4914602 LVT entries for classfile version > 49 must be converted
//jjh if (!useOld && !expected.equals(genSig)) {
//jjh failure("FAILED: Expected generic signature for local var: " +
//jjh expected + ", received: " + genSig);
//jjh }
}
}
{
// Verify genericSignature() for a method2
List genMethods = gen1Class.methodsByName("method2");
// There is only uno
Method method2 = (Method)genMethods.get(0);
expected = "null";
genSig = method2.genericSignature();
genSig = (genSig == null) ? "null" : genSig;
System.out.println("method2 name = " + method2);
System.out.println(" type = " + gen1Class.signature());
System.out.println(" sig = " + method2.signature());
System.out.println(" gen sig = " + genSig);
System.out.println(" bridge = " + method2.isBridge());
if (!useOld && !expected.equals(genSig)) {
failure("FAILED: Expected generic signature for method2: " +
expected + ", received: " + genSig);
}
// Verify this is not a bridge method
if (method2.isBridge()) {
failure("FAILED: Expected gen1.method2 to not be a bridge"
+ " method but it is");
}
// Verify genericSignature for a local var
List localVars = method2.variables();
expected = "null";
for ( int ii = 0 ; ii < localVars.size(); ii++) {
LocalVariable pp = (LocalVariable)localVars.get(ii);
genSig = pp.genericSignature();
genSig = (genSig == null) ? "null" : genSig;
System.out.println(" local var " + ii + " = " + pp.name());
System.out.println(" sig = " + pp.signature());
System.out.println(" gen sig = " + genSig);
if (!useOld && !expected.equals(genSig)) {
failure("FAILED: Expected generic signature for local var: " +
expected + ", received: " + genSig);
}
}
}
{
Field sub1Field = targetClass.fieldByName("sub1Field");
ReferenceType sub1Class = (ReferenceType)(sub1Field.type());
List<Method> sub1Methods = sub1Class.methodsByName("method1");
for (Method mm: sub1Methods) {
System.out.println("method is: " + mm);
}
/*
* There should be two methods - the first is the
* method1 defined in Sub1, and the 2nd is a javac generated
* bridge method.
*/
Method method1 = (Method)sub1Methods.get(1);
System.out.println("\nmethod1 name = " + method1);
System.out.println(" sig = " + method1.signature());
System.out.println(" bridge = " + method1.isBridge());
if (!useOld && !method1.isBridge()) {
failure("FAILED: Expected Sub1.method1 to be a bridge method"
+ " but it isn't");
}
}
{
// Verify genericSignature for a non generic class
genSig = targetClass.genericSignature();
if (genSig != null) {
failure("FAILED: Expected generic signature = null for "
+ targetClass.name() + ", received: " + genSig);
}
}
{
// Verify genericSignature for a non generic field
Field objField = targetClass.fieldByName("objField");
genSig = objField.genericSignature();
if (genSig != null) {
failure("FAILED: Expected generic signature = null for "
+ objField.name() + ", received: " + genSig);
}
}
{
// Verify genericSignature for a non generic method
List methods = targetClass.methodsByName("main");
Method main = (Method)methods.get(0);
genSig = main.genericSignature();
if (genSig != null) {
failure("FAILED: Expected generic signature = null for "
+ main.name() + ", received: " + genSig);
}
}
if (0 == 1) {
mainThread = bpe.thread();
EventRequestManager erm = vm().eventRequestManager();
StepRequest request = erm.createStepRequest(mainThread,
StepRequest.STEP_LINE,
StepRequest.STEP_INTO);
request.enable();
}
/*
* 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("GenericsTest: passed");
} else {
throw new Exception("GenericsTest: failed");
}
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java GenericsTest.java source code file:
|