364 lines
12 KiB
Java
364 lines
12 KiB
Java
/*
|
|
* Copyright (c) 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.
|
|
*/
|
|
|
|
/*
|
|
*
|
|
* @summary Check getEnclosingClass and other methods
|
|
* @author Peter von der Ah\u00e9
|
|
*
|
|
* a) Top level classes
|
|
* b) Nested classes (static member classes)
|
|
* c) Inner classes (non-static member classes)
|
|
* d) Local classes (named classes declared within a method)
|
|
* e) Anonymous classes
|
|
*/
|
|
|
|
/*
|
|
* TODO:
|
|
* Test annotations
|
|
* Test Locals in static initializers
|
|
* Test Locals in methods
|
|
* Test Locals in constructors
|
|
* Test interfaces
|
|
* Test enums
|
|
* Test method with a String[] argument
|
|
*/
|
|
|
|
//package
|
|
|
|
import common.TestMe;
|
|
|
|
interface MakeClass {
|
|
Class<?> make();
|
|
}
|
|
|
|
public class EnclosingClass {
|
|
public EnclosingClass() {
|
|
aec = (new Object() {}).getClass();
|
|
}
|
|
static class Nested {
|
|
static class NestedNested {
|
|
}
|
|
class NestedInner {
|
|
}
|
|
Class<?> nestedLocal0;
|
|
Class<?> nestedLocal1;
|
|
Class<?> nestedLocal2;
|
|
{
|
|
class NestedLocal0 {};
|
|
nestedLocal0 = NestedLocal0.class;
|
|
nestedMethod1();
|
|
nestedMethod2(null);
|
|
}
|
|
void nestedMethod1() {
|
|
class NestedLocal1 {}
|
|
nestedLocal1 = NestedLocal1.class;
|
|
}
|
|
void nestedMethod2(String[] args) {
|
|
class NestedLocal2 {}
|
|
nestedLocal2 = NestedLocal2.class;
|
|
}
|
|
Class<?> nestedAnonymous = (new Object() {}).getClass();
|
|
static enum NestedNestedEnum {
|
|
}
|
|
enum NestedInnerEnum {
|
|
}
|
|
}
|
|
|
|
class Inner {
|
|
class InnerInner {
|
|
}
|
|
Class<?> innerLocal0;
|
|
Class<?> innerLocal1;
|
|
Class<?> innerLocal2;
|
|
{
|
|
class InnerLocal0 {
|
|
};
|
|
innerLocal0 = InnerLocal0.class;
|
|
innerMethod1();
|
|
innerMethod2(null);
|
|
}
|
|
void innerMethod1() {
|
|
class InnerLocal1 {}
|
|
innerLocal1 = InnerLocal1.class;
|
|
}
|
|
void innerMethod2(String[] args) {
|
|
class InnerLocal2 {}
|
|
innerLocal2 = InnerLocal2.class;
|
|
}
|
|
Class<?> innerAnonymous = (new Object() {}).getClass();
|
|
}
|
|
|
|
@TestMe(desc="top level class",
|
|
encl="null",
|
|
simple="EnclosingClass",
|
|
canonical="EnclosingClass")
|
|
public Class<?> a = EnclosingClass.class;
|
|
|
|
@TestMe(desc="nested class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="Nested",
|
|
canonical="EnclosingClass.Nested")
|
|
public Class<?> ab = Nested.class;
|
|
@TestMe(desc="inner class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="Inner",
|
|
canonical="EnclosingClass.Inner")
|
|
public Class<?> ac = Inner.class;
|
|
@TestMe(desc="local class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="Local0",
|
|
hasCanonical=false)
|
|
public Class<?> ad0;
|
|
@TestMe(desc="local class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="Local1",
|
|
hasCanonical=false)
|
|
public Class<?> ad1;
|
|
@TestMe(desc="local class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="Local2",
|
|
hasCanonical=false)
|
|
public Class<?> ad2;
|
|
@TestMe(desc="local class within a top level class static initializer" ,
|
|
encl="class EnclosingClass",
|
|
simple="StaticLocal0",
|
|
hasCanonical=false)
|
|
public Class<?> sad0;
|
|
@TestMe(desc="local class within a top level class static method" ,
|
|
encl="class EnclosingClass",
|
|
simple="StaticLocal1",
|
|
hasCanonical=false)
|
|
public Class<?> sad1;
|
|
@TestMe(desc="local class within a top level class static method",
|
|
encl="class EnclosingClass",
|
|
simple="StaticLocal2",
|
|
hasCanonical=false)
|
|
public Class<?> sad2;
|
|
{
|
|
class Local0 {
|
|
class LocalInner {}
|
|
{
|
|
class LocalLocal {};
|
|
dd = LocalLocal.class;
|
|
de = (new Object() {}).getClass();
|
|
}
|
|
};
|
|
ad0 = Local0.class;
|
|
dc = Local0.LocalInner.class;
|
|
new Local0();
|
|
method1();
|
|
method2(null);
|
|
sad0 = staticLocal0;
|
|
sad1 = staticMethod1();
|
|
sad2 = staticMethod2(null);
|
|
}
|
|
static Class<?> staticLocal0;
|
|
static {
|
|
class StaticLocal0 {};
|
|
staticLocal0 = StaticLocal0.class;
|
|
}
|
|
static Class<?> staticMethod1() {
|
|
class StaticLocal1 {};
|
|
return StaticLocal1.class;
|
|
}
|
|
static Class<?> staticMethod2(String[] args) {
|
|
class StaticLocal2 {};
|
|
return StaticLocal2.class;
|
|
}
|
|
void method1() {
|
|
class Local1 {};
|
|
ad1 = Local1.class;
|
|
}
|
|
void method2(String[] args) {
|
|
class Local2 {};
|
|
ad2 = Local2.class;
|
|
}
|
|
@TestMe(desc="anonymous class within top level class",
|
|
encl="class EnclosingClass",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> ae = (new Object() {}).getClass();
|
|
@TestMe(desc="anonymous class within top level class constructor",
|
|
encl="class EnclosingClass",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> aec;
|
|
|
|
@TestMe(desc="nested class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="NestedNested",
|
|
canonical="EnclosingClass.Nested.NestedNested")
|
|
public Class<?> bb = Nested.NestedNested.class;
|
|
@TestMe(desc="inner class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="NestedInner",
|
|
canonical="EnclosingClass.Nested.NestedInner")
|
|
public Class<?> bc = Nested.NestedInner.class;
|
|
@TestMe(desc="local class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="NestedLocal0",
|
|
hasCanonical=false)
|
|
public Class<?> bd0 = (new Nested()).nestedLocal0;
|
|
@TestMe(desc="local class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="NestedLocal1",
|
|
hasCanonical=false)
|
|
public Class<?> bd1 = (new Nested()).nestedLocal1;
|
|
@TestMe(desc="local class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="NestedLocal2",
|
|
hasCanonical=false)
|
|
public Class<?> bd2 = (new Nested()).nestedLocal2;
|
|
@TestMe(desc="anonymous class within nested class",
|
|
encl="class EnclosingClass$Nested",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> be = (new Nested()).nestedAnonymous;
|
|
|
|
@TestMe(desc="nested class within an inner class", encl="", simple="")
|
|
public Class<?> cb = Void.class; // not legal
|
|
@TestMe(desc="inner class within an inner class",
|
|
encl="class EnclosingClass$Inner",
|
|
simple="InnerInner",
|
|
canonical="EnclosingClass.Inner.InnerInner")
|
|
public Class<?> cc = ((new Inner()).new InnerInner()).getClass();
|
|
@TestMe(desc="local class within an inner class",
|
|
encl="class EnclosingClass$Inner",
|
|
simple="InnerLocal0",
|
|
hasCanonical=false)
|
|
public Class<?> cd = (new Inner()).innerLocal0;
|
|
@TestMe(desc="anonymous class within an inner class",
|
|
encl="class EnclosingClass$Inner",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> ce = (new Inner()).innerAnonymous;
|
|
|
|
@TestMe(desc="nested class within a local class", encl="", simple="")
|
|
public Class<?> db = Void.class; // not legal
|
|
@TestMe(desc="inner class within a local class",
|
|
encl="class EnclosingClass$1Local0",
|
|
simple="LocalInner",
|
|
hasCanonical=false)
|
|
public Class<?> dc; // initialized above
|
|
@TestMe(desc="local class within a local class",
|
|
encl="class EnclosingClass$1Local0",
|
|
simple="LocalLocal",
|
|
hasCanonical=false)
|
|
public Class<?> dd; // initialized above
|
|
@TestMe(desc="anonymous class within a local class",
|
|
encl="class EnclosingClass$1Local0",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> de; // initialized above
|
|
|
|
@TestMe(desc="nested class within an anonymous class", encl="", simple="")
|
|
public Class<?> eb = Void.class; // not legal
|
|
@TestMe(desc="inner class within an anonymous class",
|
|
encl="class EnclosingClass$3",
|
|
simple="AnonymousInner",
|
|
hasCanonical=false)
|
|
public Class<?> ec = new MakeClass() {
|
|
class AnonymousInner {}
|
|
public Class<?> make() { return AnonymousInner.class; }
|
|
}.make();
|
|
@TestMe(desc="local class within an anonymous class",
|
|
encl="class EnclosingClass$4",
|
|
simple="AnonymousLocal",
|
|
hasCanonical=false)
|
|
public Class<?> ed = new MakeClass() {
|
|
Class<?> c;
|
|
{
|
|
class AnonymousLocal {}
|
|
c = AnonymousLocal.class;
|
|
}
|
|
public Class<?> make() { return c; }
|
|
}.make();
|
|
@TestMe(desc="anonymous class within an anonymous class",
|
|
encl="class EnclosingClass$5",
|
|
simple="",
|
|
hasCanonical=false)
|
|
public Class<?> ee = new MakeClass() {
|
|
Class<?> c;
|
|
{
|
|
c = new Object() {}.getClass();
|
|
}
|
|
public Class<?> make() { return c; }
|
|
}.make();
|
|
|
|
@TestMe(desc="the primitive boolean type",
|
|
encl="null",
|
|
simple="boolean",
|
|
canonical="boolean")
|
|
public Class<?> booleanClass = boolean.class;
|
|
|
|
@TestMe(desc="the primitive char type",
|
|
encl="null",
|
|
simple="char",
|
|
canonical="char")
|
|
public Class<?> charClass = char.class;
|
|
|
|
@TestMe(desc="the primitive byte type",
|
|
encl="null",
|
|
simple="byte",
|
|
canonical="byte")
|
|
public Class<?> byteClass = byte.class;
|
|
|
|
@TestMe(desc="the primitive short type",
|
|
encl="null",
|
|
simple="short",
|
|
canonical="short")
|
|
public Class<?> shortClass = short.class;
|
|
|
|
@TestMe(desc="the primitive int type",
|
|
encl="null",
|
|
simple="int",
|
|
canonical="int")
|
|
public Class<?> intClass = int.class;
|
|
|
|
@TestMe(desc="the primitive long type",
|
|
encl="null",
|
|
simple="long",
|
|
canonical="long")
|
|
public Class<?> longClass = long.class;
|
|
|
|
@TestMe(desc="the primitive float type",
|
|
encl="null",
|
|
simple="float",
|
|
canonical="float")
|
|
public Class<?> floatClass = float.class;
|
|
|
|
@TestMe(desc="the primitive double type",
|
|
encl="null",
|
|
simple="double",
|
|
canonical="double")
|
|
public Class<?> doubleClass = double.class;
|
|
|
|
@TestMe(desc="the primitive void type",
|
|
encl="null",
|
|
simple="void",
|
|
canonical="void")
|
|
public Class<?> voidClass = void.class;
|
|
|
|
}
|