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