262 lines
11 KiB
Java
262 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2014, 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.
|
|
*/
|
|
|
|
import java.awt.Image;
|
|
import java.beans.BeanDescriptor;
|
|
import java.beans.BeanInfo;
|
|
import java.beans.EventSetDescriptor;
|
|
import java.beans.FeatureDescriptor;
|
|
import java.beans.IndexedPropertyDescriptor;
|
|
import java.beans.Introspector;
|
|
import java.beans.MethodDescriptor;
|
|
import java.beans.ParameterDescriptor;
|
|
import java.beans.PropertyDescriptor;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.Method;
|
|
import java.net.URI;
|
|
import java.nio.file.FileSystem;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.FileVisitResult;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.SimpleFileVisitor;
|
|
import java.nio.file.attribute.BasicFileAttributes;
|
|
import java.util.Arrays;
|
|
import java.util.Comparator;
|
|
import java.util.Enumeration;
|
|
import java.util.Map.Entry;
|
|
import java.util.Objects;
|
|
import java.util.TreeMap;
|
|
import java.util.TreeSet;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 4058433
|
|
* @summary Generates BeanInfo for public classes in AWT, Accessibility, and Swing
|
|
* @author Sergey Malenkov
|
|
*/
|
|
public class Test4058433 implements Comparator<Object> {
|
|
@Override
|
|
public int compare(Object one, Object two) {
|
|
if (one instanceof Method && two instanceof Method) {
|
|
Method oneMethod = (Method) one;
|
|
Method twoMethod = (Method) two;
|
|
int result = oneMethod.getName().compareTo(twoMethod.getName());
|
|
if (result != 0) {
|
|
return result;
|
|
}
|
|
}
|
|
if (one instanceof FeatureDescriptor && two instanceof FeatureDescriptor) {
|
|
FeatureDescriptor oneFD = (FeatureDescriptor) one;
|
|
FeatureDescriptor twoFD = (FeatureDescriptor) two;
|
|
int result = oneFD.getName().compareTo(twoFD.getName());
|
|
if (result != 0) {
|
|
return result;
|
|
}
|
|
}
|
|
return one.toString().compareTo(two.toString());
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
|
|
fs.getFileStores();
|
|
|
|
TreeSet<Class<?>> types = new TreeSet<>(new Test4058433());
|
|
Files.walkFileTree(fs.getPath("/modules/java.desktop"), new SimpleFileVisitor<Path>() {
|
|
@Override
|
|
public FileVisitResult visitFile(Path file,
|
|
BasicFileAttributes attrs) {
|
|
file = file.subpath(2, file.getNameCount());
|
|
if (file.startsWith("java/awt/")
|
|
|| file.startsWith("javax/accessibility/")
|
|
|| file.startsWith("javax/swing/")) {
|
|
String name =file.toString();
|
|
if (name.endsWith(".class")) {
|
|
name = name.substring(0, name.indexOf(".")).replace('/', '.');
|
|
|
|
final Class<?> type;
|
|
try {
|
|
type = Class.forName(name);
|
|
} catch (ClassNotFoundException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
if (!BeanInfo.class.isAssignableFrom(type) && !type.isInterface()
|
|
&& !type.isEnum() && !type.isAnnotation()
|
|
&& !type.isAnonymousClass()) {
|
|
if (null == type.getDeclaringClass()) {
|
|
types.add(type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FileVisitResult.CONTINUE;
|
|
}
|
|
});
|
|
|
|
System.out.println("found " + types.size() + " classes");
|
|
long time = -System.currentTimeMillis();
|
|
for (Class<?> type : types) {
|
|
System.out.println("========================================");
|
|
BeanInfo info = Introspector.getBeanInfo(type);
|
|
|
|
BeanDescriptor bd = info.getBeanDescriptor();
|
|
System.out.println(bd.getBeanClass());
|
|
print("customizer", bd.getCustomizerClass());
|
|
print(bd);
|
|
print("mono 16x16", info.getIcon(BeanInfo.ICON_MONO_16x16));
|
|
print("mono 32x32", info.getIcon(BeanInfo.ICON_MONO_32x32));
|
|
print("color 16x16", info.getIcon(BeanInfo.ICON_COLOR_16x16));
|
|
print("color 32x32", info.getIcon(BeanInfo.ICON_COLOR_32x32));
|
|
|
|
PropertyDescriptor[] pds = info.getPropertyDescriptors();
|
|
PropertyDescriptor dpd = getDefault(pds, info.getDefaultPropertyIndex());
|
|
System.out.println(pds.length + " property descriptors");
|
|
Arrays.sort(pds, new Test4058433());
|
|
for (PropertyDescriptor pd : pds) {
|
|
print(pd);
|
|
if (dpd == pd) {
|
|
System.out.println("default property");
|
|
}
|
|
print("bound", pd.isBound());
|
|
print("constrained", pd.isConstrained());
|
|
print("property editor", pd.getPropertyEditorClass());
|
|
print("property type", pd.getPropertyType());
|
|
print("read method", pd.getReadMethod());
|
|
print("write method", pd.getWriteMethod());
|
|
if (pd instanceof IndexedPropertyDescriptor) {
|
|
IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
|
|
print("indexed property type", ipd.getIndexedPropertyType());
|
|
print("indexed read method", ipd.getIndexedReadMethod());
|
|
print("indexed write method", ipd.getIndexedWriteMethod());
|
|
}
|
|
}
|
|
EventSetDescriptor[] esds = info.getEventSetDescriptors();
|
|
EventSetDescriptor desd = getDefault(esds, info.getDefaultEventIndex());
|
|
System.out.println(esds.length + " event set descriptors");
|
|
Arrays.sort(esds, new Test4058433());
|
|
for (EventSetDescriptor esd : esds) {
|
|
print(esd);
|
|
if (desd == esd) {
|
|
System.out.println("default event set");
|
|
}
|
|
print("in default", esd.isInDefaultEventSet());
|
|
print("unicast", esd.isUnicast());
|
|
print("listener type", esd.getListenerType());
|
|
print("get listener method", esd.getGetListenerMethod());
|
|
print("add listener method", esd.getAddListenerMethod());
|
|
print("remove listener method", esd.getRemoveListenerMethod());
|
|
Method[] methods = esd.getListenerMethods();
|
|
Arrays.sort(methods, new Test4058433());
|
|
for (Method method : methods) {
|
|
print("listener method", method);
|
|
}
|
|
print(esd.getListenerMethodDescriptors());
|
|
}
|
|
print(info.getMethodDescriptors());
|
|
}
|
|
time += System.currentTimeMillis();
|
|
System.out.println("DONE IN " + time + " MS");
|
|
}
|
|
|
|
private static <T> T getDefault(T[] array, int index) {
|
|
return (index == -1) ? null : array[index];
|
|
}
|
|
|
|
private static void print(MethodDescriptor[] mds) {
|
|
System.out.println(mds.length + " method descriptors");
|
|
Arrays.sort(mds, new Test4058433());
|
|
for (MethodDescriptor md : mds) {
|
|
print(md);
|
|
print("method", md.getMethod());
|
|
ParameterDescriptor[] pds = md.getParameterDescriptors();
|
|
if (pds != null) {
|
|
System.out.println(pds.length + " parameter descriptors");
|
|
for (ParameterDescriptor pd : pds) {
|
|
print(pd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void print(FeatureDescriptor descriptor) {
|
|
String name = descriptor.getName();
|
|
String display = descriptor.getDisplayName();
|
|
String description = descriptor.getShortDescription();
|
|
System.out.println("name: " + name);
|
|
if (!Objects.equals(name, display)) {
|
|
System.out.println("display name: " + display);
|
|
}
|
|
if (!Objects.equals(display, description)) {
|
|
System.out.println("description: " + description.trim());
|
|
}
|
|
print("expert", descriptor.isExpert());
|
|
print("hidden", descriptor.isHidden());
|
|
print("preferred", descriptor.isPreferred());
|
|
TreeMap<String,Object> map = new TreeMap<>();
|
|
Enumeration<String> enumeration = descriptor.attributeNames();
|
|
while (enumeration.hasMoreElements()) {
|
|
String id = enumeration.nextElement();
|
|
Object value = descriptor.getValue(id);
|
|
if (value.getClass().isArray()) {
|
|
TreeSet<String> set = new TreeSet<>();
|
|
int index = 0;
|
|
int length = Array.getLength(value);
|
|
while (index < length) {
|
|
set.add(Array.get(value, index++) + ", " +
|
|
Array.get(value, index++) + ", " +
|
|
Array.get(value, index++));
|
|
}
|
|
value = set.toString();
|
|
}
|
|
map.put(id, value);
|
|
}
|
|
for (Entry<String,Object> entry : map.entrySet()) {
|
|
System.out.println(entry.getKey() + ": " + entry.getValue());
|
|
}
|
|
}
|
|
|
|
private static void print(String id, boolean flag) {
|
|
if (flag) {
|
|
System.out.println(id + " is set");
|
|
}
|
|
}
|
|
|
|
private static void print(String id, Class<?> type) {
|
|
if (type != null) {
|
|
System.out.println(id + ": " + type.getName());
|
|
}
|
|
}
|
|
|
|
private static void print(String id, Method method) {
|
|
if (method != null) {
|
|
System.out.println(id + ": " + method);
|
|
}
|
|
}
|
|
|
|
private static void print(String name, Image image) {
|
|
if (image != null) {
|
|
System.out.println(name + " icon is exist");
|
|
}
|
|
}
|
|
}
|