private static Method getBaselineMethod(JComponent component) { if (COMPONENT_BASELINE_METHOD != null) { return COMPONENT_BASELINE_METHOD; } Class klass = component.getClass(); while (klass != null) { if (BASELINE_MAP.containsKey(klass)) { Method method = (Method) BASELINE_MAP.get(klass); return method; } klass = klass.getSuperclass(); } klass = component.getClass(); Method[] methods = klass.getMethods(); for (int i = methods.length - 1; i >= 0; i--) { Method method = methods[i]; if ("getBaseline".equals(method.getName())) { Class[] params = method.getParameterTypes(); if (params.length == 2 && params[0] == int.class && params[1] == int.class) { BASELINE_MAP.put(klass, method); return method; } } } BASELINE_MAP.put(klass, null); return null; }
private boolean isSynthIcon(Icon icon) { if (_synthIconMap == null) { _synthIconMap = new HashMap<String, Boolean>(); } Class<?> aClass = icon.getClass(); java.util.List<String> classNamesToPut = new ArrayList<String>(); boolean isSynthIcon = false; while (aClass != null) { String name = aClass.getCanonicalName(); if (name != null) { Boolean value = _synthIconMap.get(name); if (value != null) { return value; } classNamesToPut.add(name); if (isSynthIconClassName(name)) { isSynthIcon = true; break; } } aClass = aClass.getSuperclass(); } for (String name : classNamesToPut) { _synthIconMap.put(name, isSynthIcon); } return isSynthIcon; }
/** * @param methodName getter method * @param clazz value object class * @return attribute name related to the specified getter method */ private String getAttributeName(String methodName, Class classType) { String attributeName = null; if (methodName.startsWith("is")) attributeName = methodName.substring(2, 3).toLowerCase() + (methodName.length() > 3 ? methodName.substring(3) : ""); else attributeName = methodName.substring(3, 4).toLowerCase() + (methodName.length() > 4 ? methodName.substring(4) : ""); // an attribute name "Xxxx" becomes "xxxx" and this is not correct! try { Class c = classType; boolean attributeFound = false; while (!c.equals(Object.class)) { try { c.getDeclaredField(attributeName); attributeFound = true; break; } catch (Throwable ex2) { c = c.getSuperclass(); } } if (!attributeFound) { // now trying to find an attribute having the first character in upper case (e.g. "Xxxx") String name = attributeName.substring(0, 1).toUpperCase() + attributeName.substring(1); c = classType; while (!c.equals(Object.class)) { try { c.getDeclaredField(name); attributeFound = true; break; } catch (Throwable ex2) { c = c.getSuperclass(); } } if (attributeFound) attributeName = name; } } catch (Throwable ex1) { } return attributeName; }
private void resetClassFields(final Class<?> aClass) { try { UsefulTestCase.clearDeclaredFields(this, aClass); } catch (IllegalAccessException e) { throw new RuntimeException(e); } if (aClass == LightPlatformTestCase.class) return; resetClassFields(aClass.getSuperclass()); }
private void resetClassFields(final Class<?> aClass) { try { clearDeclaredFields(this, aClass); } catch (IllegalAccessException e) { LOG.error(e); } if (aClass == PlatformTestCase.class) return; resetClassFields(aClass.getSuperclass()); }
/** * Helper method to lookup a cell renderer based on type. * * @param type the type for which a renderer should be found * @return a renderer for the given object type */ private TableCellRenderer getCellRenderer(Class type) { // try to create one from the factory TableCellRenderer renderer = getRendererFactory().createTableCellRenderer(type); // if that fails, recursively try again with the superclass if (renderer == null && type != null) renderer = getCellRenderer(type.getSuperclass()); // if that fails, just use the default Object renderer if (renderer == null) renderer = super.getDefaultRenderer(Object.class); return renderer; }
private static Method findMethod( Class<? extends Object> aClass, String methodName, Class[] params) { try { final Method method = aClass.getDeclaredMethod(methodName, params); method.setAccessible(true); return method; } catch (NoSuchMethodException ignored) { } final Class<?> parent = aClass.getSuperclass(); if (parent == null) { return null; } return findMethod(parent, methodName, params); }
public static boolean canRunTest(@NotNull Class testCaseClass) { if (GraphicsEnvironment.isHeadless()) { for (Class<?> clazz = testCaseClass; clazz != null; clazz = clazz.getSuperclass()) { if (clazz.getAnnotation(SkipInHeadlessEnvironment.class) != null) { System.out.println( "Class '" + testCaseClass.getName() + "' is skipped because it requires working UI environment"); return false; } } } return true; }
private static void fixPopupSize(final Popup popup, final Component contents) { if (!UIUtil.isUnderGTKLookAndFeel() || !(contents instanceof JPopupMenu)) return; for (Class<?> aClass = popup.getClass(); aClass != null && Popup.class.isAssignableFrom(aClass); aClass = aClass.getSuperclass()) { try { final Method getComponent = aClass.getDeclaredMethod("getComponent"); getComponent.setAccessible(true); final Object component = getComponent.invoke(popup); if (component instanceof JWindow) { ((JWindow) component).setSize(new Dimension(0, 0)); } break; } catch (Exception ignored) { } } }
public static void get(Class clazz) { // // Gets array of direct interface of clazz object // Class[] interfaces = clazz.getInterfaces(); System.out.format("Direct Interfaces of %s:%n", clazz.getName()); for (Class clz : interfaces) { System.out.println(clz.getName()); } // // Gets direct superclass of clazz object // Class superclz = clazz.getSuperclass(); System.out.format("Direct Superclass of %s: is %s %n", clazz.getName(), superclz.getName()); System.out.println("===================================="); }
/** * Construct a variable * * @param aType the type * @param aName the name * @param aValue the value */ public Variable(Class<?> aType, String aName, Object aValue) { type = aType; name = aName; value = aValue; fields = new ArrayList<Field>(); // find all fields if we have a class type except we don't expand strings and null values if (!type.isPrimitive() && !type.isArray() && !type.equals(String.class) && value != null) { // get fields from the class and all superclasses for (Class<?> c = value.getClass(); c != null; c = c.getSuperclass()) { Field[] fs = c.getDeclaredFields(); AccessibleObject.setAccessible(fs, true); // get all nonstatic fields for (Field f : fs) if ((f.getModifiers() & Modifier.STATIC) == 0) fields.add(f); } } }
private static Method getBRBIMethod(Component component) { Class klass = component.getClass(); while (klass != null) { if (BRB_I_MAP.containsKey(klass)) { Method method = (Method) BRB_I_MAP.get(klass); return method; } klass = klass.getSuperclass(); } klass = component.getClass(); Method[] methods = klass.getMethods(); for (int i = methods.length - 1; i >= 0; i--) { Method method = methods[i]; if ("getBaselineResizeBehaviorInt".equals(method.getName())) { Class[] params = method.getParameterTypes(); if (params.length == 0) { BRB_I_MAP.put(klass, method); return method; } } } BRB_I_MAP.put(klass, null); return null; }