| /* | |
| * Copyright (c) 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.lang.annotation.RetentionPolicy; | |
| import java.util.*; | |
| import java.util.stream.Collectors; | |
| public class TestCase { | |
| /** | |
| * The top-level classes of the test case. | |
| */ | |
| public final Map<String, TestClassInfo> classes = new LinkedHashMap<>(); | |
| /** | |
| * Constructs a test class info with {@code classType} as top-level class, | |
| * with {@code outerClassName} as name and {@code mods} as modifiers. | |
| * | |
| * @param classType a class type | |
| * @param outerClassName a name | |
| * @param mods an array of modifiers | |
| */ | |
| public TestClassInfo addClassInfo(ClassType classType, String outerClassName, String...mods) { | |
| return addClassInfo(null, classType, outerClassName, mods); | |
| } | |
| /** | |
| * Constructs a test class info with {@code classType} as top-level class, | |
| * with {@code outerClassName} as name, {@code parent} class name | |
| * as parent class and {@code mods} as modifiers. | |
| * | |
| * @param classType a class type | |
| * @param outerClassName a name | |
| * @param mods an array of modifiers | |
| */ | |
| public TestClassInfo addClassInfo(String parent, ClassType classType, String outerClassName, String...mods) { | |
| TestClassInfo clazz = new TestClassInfo(classType, outerClassName, parent, mods); | |
| if (classes.put(outerClassName, clazz) != null) { | |
| throw new IllegalArgumentException("Duplicate class name: " + outerClassName); | |
| } | |
| return clazz; | |
| } | |
| public String generateSource() { | |
| return classes.values().stream() | |
| .map(TestMemberInfo::generateSource) | |
| .collect(Collectors.joining("\n")); | |
| } | |
| /** | |
| * Returns {@code TestClassInfo} by class signature. | |
| * Example, {@code getTestClassInfo("Test$1Local")} | |
| * returns local inner class of class {@code Test}. | |
| * | |
| * @param classSignature a class signature | |
| * @return {@code TestClassInfo} by class signature | |
| */ | |
| public TestClassInfo getTestClassInfo(String classSignature) { | |
| String[] cs = classSignature.split("\\$"); | |
| if (cs.length > 0 && classes.containsKey(cs[0])) { | |
| // check signature corresponds to top level class | |
| if (cs.length == 1) { | |
| return classes.get(cs[0]); | |
| } | |
| } else { | |
| throw new IllegalArgumentException("Cannot find class : " + classSignature); | |
| } | |
| TestClassInfo current = classes.get(cs[0]); | |
| // find class info in the inner classes | |
| for (int i = 1; i < cs.length; ++i) { | |
| Map<String, TestClassInfo> innerClasses = current.innerClasses; | |
| Map<String, TestMethodInfo> methods = current.methods; | |
| current = innerClasses.get(cs[i]); | |
| // if current is null then class info does not exist or the class is local | |
| if (current == null) { | |
| if (!cs[i].isEmpty()) { | |
| // the class is local, remove leading digit | |
| String className = cs[i].substring(1); | |
| Optional<TestClassInfo> opt = methods.values().stream() | |
| .flatMap(c -> c.localClasses.values().stream()) | |
| .filter(c -> c.name.equals(className)).findAny(); | |
| if (opt.isPresent()) { | |
| current = opt.get(); | |
| // continue analysis of local class | |
| continue; | |
| } | |
| } | |
| throw new IllegalArgumentException("Cannot find class : " + classSignature); | |
| } | |
| } | |
| return current; | |
| } | |
| /** | |
| * Class represents a program member. | |
| */ | |
| public static abstract class TestMemberInfo { | |
| // next two fields are used for formatting | |
| protected final int indention; | |
| protected final ClassType containerType; | |
| public final List<String> mods; | |
| public final String name; | |
| public final Map<String, TestAnnotationInfo> annotations; | |
| TestMemberInfo(int indention, ClassType containerType, String name, String... mods) { | |
| this.indention = indention; | |
| this.containerType = containerType; | |
| this.mods = Arrays.asList(mods); | |
| this.name = name; | |
| this.annotations = new HashMap<>(); | |
| } | |
| public abstract String generateSource(); | |
| public boolean isAnnotated(RetentionPolicy policy) { | |
| return annotations.values().stream() | |
| .filter(a -> a.policy == policy) | |
| .findAny().isPresent(); | |
| } | |
| public Set<String> getRuntimeVisibleAnnotations() { | |
| return getRuntimeAnnotations(RetentionPolicy.RUNTIME); | |
| } | |
| public Set<String> getRuntimeInvisibleAnnotations() { | |
| return getRuntimeAnnotations(RetentionPolicy.CLASS); | |
| } | |
| private Set<String> getRuntimeAnnotations(RetentionPolicy policy) { | |
| return annotations.values().stream() | |
| .filter(e -> e.policy == policy) | |
| .map(a -> a.annotationName) | |
| .distinct() | |
| .collect(Collectors.toSet()); | |
| } | |
| /** | |
| * Generates source for annotations. | |
| * | |
| * @param prefix a leading text | |
| * @param suffix a trailing text | |
| * @param joining a text between annotations | |
| * @return source for annotations | |
| */ | |
| protected String generateSourceForAnnotations(String prefix, String suffix, String joining) { | |
| StringBuilder sb = new StringBuilder(); | |
| for (TestAnnotationInfo annotation : annotations.values()) { | |
| sb.append(prefix); | |
| if (annotation.isContainer) { | |
| // the annotation is repeatable | |
| // container consists of an array of annotations | |
| TestAnnotationInfo.TestArrayElementValue containerElementValue = | |
| (TestAnnotationInfo.TestArrayElementValue) annotation.elementValues.get(0).elementValue; | |
| // concatenate sources of repeatable annotations | |
| sb.append(containerElementValue.values.stream() | |
| .map(TestAnnotationInfo.TestElementValue::toString) | |
| .collect(Collectors.joining(joining))); | |
| } else { | |
| sb.append(annotation); | |
| } | |
| sb.append(suffix); | |
| } | |
| String src = sb.toString(); | |
| return src.trim().isEmpty() ? "" : src; | |
| } | |
| /** | |
| * Generates source for annotations. | |
| * | |
| * @return source for annotations | |
| */ | |
| public String generateSourceForAnnotations() { | |
| return generateSourceForAnnotations(indention(), "\n", "\n" + indention()); | |
| } | |
| /** | |
| * Adds annotation info to the member. | |
| * | |
| * @param anno an annotation info | |
| */ | |
| public void addAnnotation(TestAnnotationInfo anno) { | |
| String containerName = anno.annotationName + "Container"; | |
| TestAnnotationInfo annotation = annotations.get(anno.annotationName); | |
| TestAnnotationInfo containerAnnotation = annotations.get(containerName); | |
| if (annotation == null) { | |
| // if annotation is null then either it is first adding of the annotation to the member | |
| // or there is the container of the annotation. | |
| if (containerAnnotation == null) { | |
| // first adding to the member | |
| annotations.put(anno.annotationName, anno); | |
| } else { | |
| // add annotation to container | |
| TestAnnotationInfo.TestArrayElementValue containerElementValue = | |
| ((TestAnnotationInfo.TestArrayElementValue) containerAnnotation.elementValues.get(0).elementValue); | |
| containerElementValue.values.add(new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, anno)); | |
| } | |
| } else { | |
| // remove previously added annotation and add new container of repeatable annotation | |
| // which contains previously added and new annotation | |
| annotations.remove(anno.annotationName); | |
| containerAnnotation = new TestAnnotationInfo( | |
| containerName, | |
| anno.policy, | |
| true, | |
| new TestAnnotationInfo.Pair("value", | |
| new TestAnnotationInfo.TestArrayElementValue( | |
| new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, annotation), | |
| new TestAnnotationInfo.TestAnnotationElementValue(anno.annotationName, anno)))); | |
| annotations.put(containerName, containerAnnotation); | |
| } | |
| } | |
| public String indention() { | |
| char[] a = new char[4 * indention]; | |
| Arrays.fill(a, ' '); | |
| return new String(a); | |
| } | |
| public String getName() { | |
| return name; | |
| } | |
| } | |
| /** | |
| * The class represents a class. | |
| */ | |
| public static class TestClassInfo extends TestMemberInfo { | |
| public final ClassType classType; | |
| public final String parent; | |
| public final Map<String, TestClassInfo> innerClasses; | |
| public final Map<String, TestMethodInfo> methods; | |
| public final Map<String, TestFieldInfo> fields; | |
| TestClassInfo(int indention, ClassType classType, String className, String... mods) { | |
| this(indention, classType, className, null, mods); | |
| } | |
| TestClassInfo(ClassType classType, String className, String parent, String... mods) { | |
| this(0, classType, className, parent, mods); | |
| } | |
| TestClassInfo(int indention, ClassType classType, String className, String parent, String... mods) { | |
| super(indention, null, className, mods); | |
| this.classType = classType; | |
| this.parent = parent; | |
| innerClasses = new LinkedHashMap<>(); | |
| methods = new LinkedHashMap<>(); | |
| fields = new LinkedHashMap<>(); | |
| } | |
| /** | |
| * Generates source which represents the class. | |
| * | |
| * @return source which represents the class | |
| */ | |
| @Override | |
| public String generateSource() { | |
| String sourceForAnnotations = generateSourceForAnnotations(); | |
| String classModifiers = mods.stream().collect(Collectors.joining(" ")); | |
| return sourceForAnnotations | |
| + String.format("%s%s %s %s %s {%n", | |
| indention(), | |
| classModifiers, | |
| classType.getDescription(), | |
| name, | |
| parent == null ? "" : "extends " + parent) | |
| + classType.collectFields(fields.values()) | |
| + classType.collectMethods(methods.values()) | |
| + classType.collectInnerClasses(innerClasses.values()) | |
| + indention() + "}"; | |
| } | |
| /** | |
| * Adds a new inner class to the class. | |
| * | |
| * @param classType a class type | |
| * @param className a class name | |
| * @param mods modifiers | |
| * @return a new added inner class to the class | |
| */ | |
| public TestClassInfo addInnerClassInfo(ClassType classType, String className, String... mods) { | |
| TestClassInfo testClass = new TestClassInfo(indention + 1, classType, className, mods); | |
| if (innerClasses.put(className, testClass) != null) { | |
| throw new IllegalArgumentException("Duplicated class : " + className); | |
| } | |
| return testClass; | |
| } | |
| /** | |
| * Adds a new method to the class. | |
| * | |
| * @param methodName a method name | |
| * @param mods modifiers | |
| * @return a new inner class to the class | |
| */ | |
| public TestMethodInfo addMethodInfo(String methodName, String... mods) { | |
| return addMethodInfo(methodName, false, mods); | |
| } | |
| /** | |
| * Adds a new method to the class. | |
| * | |
| * @param methodName a method name | |
| * @param isSynthetic if {@code true} the method is synthetic | |
| * @param mods modifiers | |
| * @return a new method added to the class | |
| */ | |
| public TestMethodInfo addMethodInfo(String methodName, boolean isSynthetic, String... mods) { | |
| boolean isConstructor = methodName.contains("<init>"); | |
| if (isConstructor) { | |
| methodName = methodName.replace("<init>", name); | |
| } | |
| TestMethodInfo testMethod = new TestMethodInfo(indention + 1, classType, methodName, isConstructor, isSynthetic, mods); | |
| if (methods.put(methodName, testMethod) != null) { | |
| throw new IllegalArgumentException("Duplicated method : " + methodName); | |
| } | |
| return testMethod; | |
| } | |
| /** | |
| * Adds a new field to the class. | |
| * | |
| * @param fieldName a method name | |
| * @param mods modifiers | |
| * @return a new field added to the class | |
| */ | |
| public TestFieldInfo addFieldInfo(String fieldName, String... mods) { | |
| TestFieldInfo field = new TestFieldInfo(indention + 1, classType, fieldName, mods); | |
| if (fields.put(fieldName, field) != null) { | |
| throw new IllegalArgumentException("Duplicated field : " + fieldName); | |
| } | |
| return field; | |
| } | |
| public TestMethodInfo getTestMethodInfo(String methodName) { | |
| return methods.get(methodName); | |
| } | |
| public TestFieldInfo getTestFieldInfo(String fieldName) { | |
| return fields.get(fieldName); | |
| } | |
| } | |
| public static class TestMethodInfo extends TestMemberInfo { | |
| public final boolean isConstructor; | |
| public final boolean isSynthetic; | |
| public final Map<String, TestClassInfo> localClasses; | |
| public final List<TestParameterInfo> parameters; | |
| TestMethodInfo(int indention, ClassType containerType, String methodName, | |
| boolean isConstructor, boolean isSynthetic, String... mods) { | |
| super(indention, containerType, methodName, mods); | |
| this.isSynthetic = isSynthetic; | |
| this.localClasses = new LinkedHashMap<>(); | |
| this.parameters = new ArrayList<>(); | |
| this.isConstructor = isConstructor; | |
| } | |
| public boolean isParameterAnnotated(RetentionPolicy policy) { | |
| return parameters.stream() | |
| .filter(p -> p.isAnnotated(policy)) | |
| .findFirst().isPresent(); | |
| } | |
| public TestParameterInfo addParameter(String type, String name) { | |
| TestParameterInfo testParameter = new TestParameterInfo(type, name); | |
| parameters.add(testParameter); | |
| return testParameter; | |
| } | |
| /** | |
| * Adds a local class to the method. | |
| * | |
| * @param className a class name | |
| * @param mods modifiers | |
| * @return a local class added to the method | |
| */ | |
| public TestClassInfo addLocalClassInfo(String className, String... mods) { | |
| TestClassInfo testClass = new TestClassInfo(indention + 1, ClassType.CLASS, className, mods); | |
| if (localClasses.put(className, testClass) != null) { | |
| throw new IllegalArgumentException("Duplicated class : " + className); | |
| } | |
| return testClass; | |
| } | |
| @Override | |
| public String generateSource() { | |
| if (isSynthetic) { | |
| return ""; | |
| } | |
| return generateSourceForAnnotations() + | |
| containerType.methodToString(this); | |
| } | |
| @Override | |
| public String getName() { | |
| return name.replaceAll("\\(.*\\)", ""); | |
| } | |
| } | |
| /** | |
| * The class represents a method parameter. | |
| */ | |
| public static class TestParameterInfo extends TestMemberInfo { | |
| public final String type; | |
| TestParameterInfo(String type, String name) { | |
| super(0, null, name); | |
| this.type = type; | |
| } | |
| @Override | |
| public String generateSource() { | |
| return generateSourceForAnnotations() + type + " " + name; | |
| } | |
| public String generateSourceForAnnotations() { | |
| return generateSourceForAnnotations("", " ", " "); | |
| } | |
| } | |
| /** | |
| * The class represents a field. | |
| */ | |
| public static class TestFieldInfo extends TestMemberInfo { | |
| TestFieldInfo(int indention, ClassType containerType, String fieldName, String... mods) { | |
| super(indention, containerType, fieldName, mods); | |
| } | |
| @Override | |
| public String generateSource() { | |
| return generateSourceForAnnotations() + | |
| containerType.fieldToString(this); | |
| } | |
| } | |
| } |