/*
* 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.
*/
/*
* @test
* @bug 5009601 5010455 5005748
* @summary enum constructors can be declared private
* @author Joseph D. Darcy
*/
import java.util.*;
import java.lang.reflect.*;
import java.lang.annotation.*;
/*
* Arguably, only the final and abstract should be held in
* ExpectedModifiers; whether or not an enum should be static could be
* inferred from getDeclaringClass and working versions of
* getEnclosingMethod and getEnclosingConstructor. I.e. if
* getDeclaringClass, getEnclosingMethod, and getEnclosingConstructor
* were all null, the enum is a top-level class and should not be
* static; otherwise, it should be static.
*/
@ExpectedModifiers(Modifier.FINAL)
public enum EnumImplicitPrivateConstructor {
RED(255, 0, 0),
GREEN(0, 255, 0),
BLUE(0, 0, 255);
private int r, g, b;
EnumImplicitPrivateConstructor(int r, int g, int b) {
this.r = r;
this.g = g;
this.b = b;
}
/*
* Using reflection, Verify that
* 1. all non-synthetic constructors of enum classes are marked as private.
* 2. top-level enum classes are marked as static
* 3. enum's are marked final and abstract as appropriate
* 4. enum constructors *cannot* be invoked reflectively
*/
public static void main(String argv[]) throws Exception {
boolean passed = true;
Collection<Class> classes = new LinkedHashSet<Class>();
classes.add(Class.forName("EnumImplicitPrivateConstructor"));
classes.add(Class.forName("EnumImplicitPrivateConstructor$AnotherEnum"));
classes.add(Class.forName("EnumImplicitPrivateConstructor$YetAnotherEnum"));
classes.add(Class.forName("EnumImplicitPrivateConstructor$OneMoreEnum"));
// Add classes of specialized enum constants
for(Enum e: YetAnotherEnum.values())
classes.add(e.getClass());
for(Class clazz: classes) {
System.out.println("Testing class " + clazz);
int classModifiers = clazz.getModifiers();
// Why is this cast needed?
ExpectedModifiers em = (ExpectedModifiers)clazz.getAnnotation(ExpectedModifiers.class);
if (em != null) {
System.out.println("\tTesting expected modifiers");
int expected = em.value();
if (expected != (classModifiers & (Modifier.ABSTRACT|Modifier.FINAL|Modifier.STATIC))) {
passed = false;
System.out.println("\tFAILED: Expected 0x" + Integer.toHexString(expected) +
" got 0x" +Integer.toHexString(classModifiers));
}
}
for(Constructor ctor: clazz.getDeclaredConstructors() ) {
System.out.println("\tTesting constructor " + ctor);
// We don't need no stinkin' access rules
try {
ctor.setAccessible(true);
} catch (java.security.AccessControlException ex) {
}
int modifiers = ctor.getModifiers();
/*
* If clazz is for a specialized enum constant, the
* class will have the ENUM bit set but clazz.isEnum()
* will be false. A constructor in such a class must
* be non-private to allow the parent class to call
* the constructor. Therefore, only impose the
* private constructor check for genuine isEnum
* classes.
*/
if (clazz.isEnum()) {
if ((modifiers & Modifier.PRIVATE) == 0 &&
! ctor.isSynthetic() ) {
passed = false;
System.out.println("\tFAILED: Constructor not marked private: modifiers 0x" +
Integer.toHexString(modifiers));
}
}
try {
// Should get exception trying to invoke
Object o = null;
try {
o = ctor.newInstance("abc", 123);
} catch (IllegalAccessException ex) {
}
/*
* A better test would query the number (and type)
* of parameters and create an appropriate
* argument list since IllegalArgumentException can be
* thrown for just using the wrong number of arguments.
*/
if (o != null) {
passed = false;
System.err.println("Error: Created new enum object!");
System.err.println(o.getClass());
System.err.println(o.toString());
}
} catch (IllegalArgumentException iae) {}
}
}
if (!passed)
throw new RuntimeException("Error during testing.");
}
/*
* Should be final and not abstract.
*/
@ExpectedModifiers(Modifier.FINAL|Modifier.STATIC)
enum AnotherEnum {
YELLOW,
CYAN,
MAGENTA;
}
/*
* Should be neither final nor abstract.
*/
@ExpectedModifiers(Modifier.STATIC)
enum YetAnotherEnum {
GREEN {
int value(){ return 1;}
},
ORANGE {
int value(){ return 2;}
},
VIOLET {
int value(){ return 3;}
};
int value(){ return 0;}
}
/*
* Should be abstract and not final.
*/
@ExpectedModifiers(Modifier.ABSTRACT|Modifier.STATIC)
enum OneMoreEnum {
SANGUINE {
int value(){ return 1;}
},
VERDANT {
int value(){ return 2;}
},
CERULEAN {
int value(){ return 3;}
};
abstract int value();
}
}
@Retention(RetentionPolicy.RUNTIME)
@interface ExpectedModifiers {
int value();
}