| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.netbeans.modules.junit; |
| |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.util.TreePath; |
| import com.sun.source.util.Trees; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.Name; |
| import javax.lang.model.element.TypeElement; |
| |
| /** |
| * Data structure that holds overview of class' members and their positions |
| * within the class. |
| * <p>To get an instance for a class, use static method |
| * {@link #forClass}.</p> |
| * |
| * @author Marian Petras |
| */ |
| final class ClassMap { |
| |
| private static final int SETUP_POS_INDEX = 0; |
| private static final int TEARDOWN_POS_INDEX = 1; |
| private static final int FIRST_METHOD_POS_INDEX = 2; |
| private static final int LAST_INIT_POS_INDEX = 3; |
| private static final int FIRST_NESTED_POS_INDEX = 4; |
| private static final int BEFORE_POS_INDEX = 5; |
| private static final int AFTER_POS_INDEX = 6; |
| private static final int BEFORE_CLASS_POS_INDEX = 7; |
| private static final int AFTER_CLASS_POS_INDEX = 8; |
| |
| private static final String JUNIT4_PKG_PREFIX = "org.junit."; //NOI18N |
| private static final String JUNIT5_PKG_PREFIX = "org.junit.jupiter.api."; //NOI18N |
| |
| private static final int[] EMPTY_INT_ARRAY = new int[0]; |
| |
| /** |
| */ |
| private final List<String> signatures; |
| /** */ |
| private final int[] positions; |
| |
| /** Creates a new instance of ClassMap */ |
| private ClassMap(List<String> signatures) { |
| this.signatures = signatures; |
| } |
| |
| { |
| positions = new int[9]; |
| for (int i = 0; i < positions.length; i++) { |
| positions[i] = -1; |
| } |
| } |
| |
| /** |
| * |
| * @exception java.lang.IllegalArgumentException |
| * if any of the arguments is {@code null} |
| * or if the specified {@code ClassTree} is not a leaf |
| * of the specified {@code TreePath} |
| */ |
| static ClassMap forClass(ClassTree cls, TreePath clsTreePath, |
| Trees trees) { |
| if (cls == null) { |
| throw new IllegalArgumentException("ClassTree: null"); //NOI18N |
| } |
| if (clsTreePath == null) { |
| throw new IllegalArgumentException("TreePath: null"); //NOI18N |
| } |
| if (clsTreePath.getLeaf() != cls) { |
| throw new IllegalArgumentException( |
| "given ClassTree is not leaf of the given TreePath"); //NOI18N |
| } |
| |
| List<? extends Tree> members = cls.getMembers(); |
| if (members.isEmpty()) { |
| return new ClassMap(new ArrayList<String>()); |
| } |
| |
| List<String> entries = new ArrayList<String>(members.size()); |
| ClassMap map = new ClassMap(entries); |
| |
| int index = 0; |
| for (Tree member : members) { |
| String signature; |
| switch (member.getKind()) { |
| case BLOCK: |
| signature = "* "; //NOI18N |
| map.setLastInitializerIndex(index); |
| break; |
| case VARIABLE: |
| signature = "- "; //NOI18N |
| break; |
| case ANNOTATION_TYPE: |
| case CLASS: |
| case ENUM: |
| case INTERFACE: |
| ClassTree clazz = (ClassTree) member; |
| signature = "[ " + clazz.getSimpleName(); //NOI18N |
| if (map.getFirstNestedClassIndex() == -1) { |
| map.setFirstNestedClassIndex(index); |
| } |
| break; |
| case METHOD: |
| MethodTree method = (MethodTree) member; |
| boolean hasParams = !method.getParameters().isEmpty(); |
| Name methodName = method.getName(); |
| if (methodName.contentEquals("<init>")) { //NOI18N |
| signature = hasParams ? "*+" : "* "; //NOI18N |
| map.setLastInitializerIndex(index); |
| } else { |
| if (!hasParams) { |
| if ((map.getSetUpIndex() == -1) |
| && methodName.contentEquals("setUp")) { //NOI18N |
| map.setSetUpIndex(index); |
| } |
| if ((map.getTearDownIndex() == -1) |
| && methodName.contentEquals("tearDown")) { //NOI18N |
| map.setTearDownIndex(index); |
| } |
| } |
| signature = (hasParams ? "!+" : "! ") //NOI18N |
| + methodName.toString(); |
| if (map.getFirstMethodIndex() == -1) { |
| map.setFirstMethodIndex(index); |
| } |
| |
| /* annotations: */ |
| if (!method.getModifiers().getAnnotations().isEmpty()) { |
| TreePath methodTreePath = new TreePath(clsTreePath, |
| method); |
| Element methodElement = trees.getElement(methodTreePath); |
| for (AnnotationMirror annMirror : methodElement.getAnnotationMirrors()) { |
| Element annElem = annMirror.getAnnotationType().asElement(); |
| String fullName = ((TypeElement) annElem).getQualifiedName().toString(); |
| if (fullName.startsWith(JUNIT5_PKG_PREFIX)) { |
| String shortName = fullName.substring(JUNIT5_PKG_PREFIX.length()); |
| int posIndex; |
| if (shortName.equals("BeforeEach")) { //NOI18N |
| posIndex = BEFORE_POS_INDEX; |
| } else if (shortName.equals("AfterEach")) { //NOI18N |
| posIndex = AFTER_POS_INDEX; |
| } else if (shortName.equals("BeforeAll")) { //NOI18N |
| posIndex = BEFORE_CLASS_POS_INDEX; |
| } else if (shortName.equals("AfterAll")) { //NOI18N |
| posIndex = AFTER_CLASS_POS_INDEX; |
| } else { |
| continue; //next annotation |
| } |
| |
| if (map.positions[posIndex] == -1) { |
| map.positions[posIndex] = index; |
| } |
| } else if (fullName.startsWith(JUNIT4_PKG_PREFIX)) { |
| String shortName = fullName.substring(JUNIT4_PKG_PREFIX.length()); |
| int posIndex; |
| if (shortName.equals("Before")) { //NOI18N |
| posIndex = BEFORE_POS_INDEX; |
| } else if (shortName.equals("After")) { //NOI18N |
| posIndex = AFTER_POS_INDEX; |
| } else if (shortName.equals("BeforeClass")) { //NOI18N |
| posIndex = BEFORE_CLASS_POS_INDEX; |
| } else if (shortName.equals("AfterClass")) { //NOI18N |
| posIndex = AFTER_CLASS_POS_INDEX; |
| } else { |
| continue; //next annotation |
| } |
| |
| if (map.positions[posIndex] == -1) { |
| map.positions[posIndex] = index; |
| } |
| } |
| } |
| } |
| } |
| break; |
| default: |
| signature = "x "; //NOI18N |
| } |
| entries.add(signature); |
| index++; |
| } |
| |
| return map; |
| } |
| |
| /** |
| */ |
| int getSetUpIndex() { |
| return positions[SETUP_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setSetUpIndex(int setUpIndex) { |
| positions[SETUP_POS_INDEX] = setUpIndex; |
| } |
| |
| /** |
| */ |
| int getTearDownIndex() { |
| return positions[TEARDOWN_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setTearDownIndex(int tearDownIndex) { |
| positions[TEARDOWN_POS_INDEX] = tearDownIndex; |
| } |
| |
| /** |
| * Returns an index of a method annotated with annotation |
| * {@code org.junit.Before}. If there are more such methods |
| * index of any of these methods may be returned. |
| * |
| * @return index of a {@code @Before}-annotated method, |
| * or {@code -1} if there is no such method |
| */ |
| int getBeforeIndex() { |
| return positions[BEFORE_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setBeforeIndex(int index) { |
| positions[BEFORE_POS_INDEX] = index; |
| } |
| |
| /** |
| * Returns an index of a method annotated with annotation |
| * {@code org.junit.After}. If there are more such methods |
| * index of any of these methods may be returned. |
| * |
| * @return index of a {@code @After}-annotated method, |
| * or {@code -1} if there is no such method |
| */ |
| int getAfterIndex() { |
| return positions[AFTER_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setAfterIndex(int index) { |
| positions[AFTER_POS_INDEX] = index; |
| } |
| |
| /** |
| * Returns an index of a method annotated with annotation |
| * {@code org.junit.BeforeClass}. If there are more such methods |
| * index of any of these methods may be returned. |
| * |
| * @return index of a {@code @BeforeClass}-annotated method, |
| * or {@code -1} if there is no such method |
| */ |
| int getBeforeClassIndex() { |
| return positions[BEFORE_CLASS_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setBeforeClassIndex(int index) { |
| positions[BEFORE_CLASS_POS_INDEX] = index; |
| } |
| |
| /** |
| * Returns an index of a method annotated with annotation |
| * {@code org.junit.AfterClass}. If there are more such methods |
| * index of any of these methods may be returned. |
| * |
| * @return index of a {@code @AfterClass}-annotated method, |
| * or {@code -1} if there is no such method |
| */ |
| int getAfterClassIndex() { |
| return positions[AFTER_CLASS_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setAfterClassIndex(int index) { |
| positions[AFTER_CLASS_POS_INDEX] = index; |
| } |
| |
| /** |
| */ |
| int getFirstMethodIndex() { |
| return positions[FIRST_METHOD_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setFirstMethodIndex(int firstMethodIndex) { |
| positions[FIRST_METHOD_POS_INDEX] = firstMethodIndex; |
| } |
| |
| /** |
| */ |
| int getFirstNestedClassIndex() { |
| return positions[FIRST_NESTED_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setFirstNestedClassIndex(int firstNestedClassIndex) { |
| positions[FIRST_NESTED_POS_INDEX] = firstNestedClassIndex; |
| } |
| |
| /** |
| */ |
| int getLastInitializerIndex() { |
| return positions[LAST_INIT_POS_INDEX]; |
| } |
| |
| /** |
| */ |
| private void setLastInitializerIndex(int lastInitializerIndex) { |
| positions[LAST_INIT_POS_INDEX] = lastInitializerIndex; |
| } |
| |
| /** |
| */ |
| boolean containsSetUp() { |
| return getSetUpIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsTearDown() { |
| return getTearDownIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsBefore() { |
| return getBeforeIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsAfter() { |
| return getAfterIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsBeforeClass() { |
| return getBeforeClassIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsAfterClass() { |
| return getAfterClassIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsNoArgMethod(String name) { |
| return findNoArgMethod(name) != -1; |
| } |
| |
| /** |
| */ |
| boolean containsMethods() { |
| return getFirstMethodIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsInitializers() { |
| return getLastInitializerIndex() != -1; |
| } |
| |
| /** |
| */ |
| boolean containsNestedClasses() { |
| return getFirstNestedClassIndex() != -1; |
| } |
| |
| /** |
| */ |
| int findNoArgMethod(String name) { |
| if (!containsMethods()) { |
| return -1; |
| } |
| if (name.equals("setUp")) { //NOI18N |
| return getSetUpIndex(); |
| } |
| if (name.equals("tearDown")) { //NOI18N |
| return getTearDownIndex(); |
| } |
| |
| return signatures.indexOf("! " + name); //NOI18N |
| } |
| |
| /** |
| */ |
| void addNoArgMethod(String name) { |
| addNoArgMethod(name, size()); |
| } |
| |
| /** |
| */ |
| void addNoArgMethod(String name, int index) { |
| int currSize = size(); |
| |
| if (index > currSize) { |
| throw new IndexOutOfBoundsException("index: " + index //NOI18N |
| + ", size: " + currSize);//NOI18N |
| } |
| |
| String signature = "! " + name; //NOI18N |
| if (index != currSize) { |
| signatures.add(index, signature); |
| shiftPositions(index, 1); |
| } else { |
| signatures.add(signature); //NOI18N |
| } |
| |
| if (name.equals("setUp")) { //NOI18N |
| setSetUpIndex(index); |
| } else if (name.equals("tearDown")) { //NOI18N |
| setTearDownIndex(index); |
| } |
| if (getFirstMethodIndex() == -1) { |
| setFirstMethodIndex(index); |
| } |
| } |
| |
| /** |
| */ |
| void addNoArgMethod(String name, String annotationName) { |
| addNoArgMethod(name, annotationName, size()); |
| } |
| |
| /** |
| */ |
| void addNoArgMethod(String name, String annotationName, int index) { |
| addNoArgMethod(name, index); |
| |
| if (annotationName.equals(JUnit4TestGenerator.ANN_BEFORE)) { |
| setBeforeIndex(index); |
| } else if (annotationName.equals(JUnit4TestGenerator.ANN_AFTER)) { |
| setAfterIndex(index); |
| } else if (annotationName.equals(JUnit4TestGenerator.ANN_BEFORE_CLASS)) { |
| setBeforeClassIndex(index); |
| } else if (annotationName.equals(JUnit4TestGenerator.ANN_AFTER_CLASS)) { |
| setAfterClassIndex(index); |
| } |
| } |
| |
| /** |
| */ |
| void removeNoArgMethod(int index) { |
| if (index < 0) { |
| throw new IndexOutOfBoundsException("negative index (" //NOI18N |
| + index + ')'); |
| } |
| if (index >= size()) { |
| throw new IndexOutOfBoundsException("index: " + index //NOI18N |
| + ", size: " + size()); //NOI18N |
| } |
| |
| String signature = signatures.get(index); |
| |
| if (!signature.startsWith("! ")) { //NOI18N |
| throw new IllegalArgumentException( |
| "not a no-arg method at the given index (" //NOI18N |
| + index + ')'); |
| } |
| |
| if (index == getSetUpIndex()) { |
| setSetUpIndex(-1); |
| } else if (index == getTearDownIndex()) { |
| setTearDownIndex(-1); |
| } |
| if (index == getFirstMethodIndex()) { |
| int currSize = size(); |
| if (index == (currSize - 1)) { |
| setFirstMethodIndex(-1); |
| } else { |
| int newFirstMethodIndex = -1; |
| int memberIndex = index + 1; |
| for (String sign : signatures.subList(index + 1, currSize)) { |
| if (sign.startsWith("! ")) { |
| newFirstMethodIndex = memberIndex; |
| break; |
| } |
| memberIndex++; |
| } |
| setFirstMethodIndex(newFirstMethodIndex); |
| } |
| } |
| shiftPositions(index + 1, -1); |
| } |
| |
| /** |
| * Returns names of all no-argument methods. |
| * |
| * @return list of names of no-argument methods |
| * in the order of the methods in the source code |
| */ |
| List<String> getNoArgMethods() { |
| if (!containsMethods()) { |
| return Collections.<String>emptyList(); |
| } |
| |
| List<String> result = new ArrayList<String>(signatures.size()); |
| for (String signature : signatures) { |
| if (signature.startsWith("! ")) { //NOI18N |
| result.add(signature.substring(2)); |
| } |
| } |
| return result.isEmpty() ? Collections.<String>emptyList() |
| : result; |
| } |
| |
| /** |
| */ |
| void addNestedClass(String name) { |
| int currSize = size(); |
| signatures.add("[ " + name); //NOI18N |
| |
| if (getFirstNestedClassIndex() == -1) { |
| setFirstNestedClassIndex(currSize); |
| } |
| } |
| |
| /** |
| * Returns names of classes contained in the class corresponding to this |
| * {@code ClassMap}. Both nested classes (static) and inner classes are |
| * taken into account. Anonymous inner classes are ignored. |
| * |
| * @return list of names of nested and inner classes in the order |
| * of the classes in the source code, |
| */ |
| List<String> getNestedClasses() { |
| int firstIndex = getFirstNestedClassIndex(); |
| if (firstIndex == -1) { |
| return Collections.<String>emptyList(); |
| } |
| |
| assert signatures.get(firstIndex).charAt(0) == '['; |
| |
| String firstNestedClass = signatures.get(firstIndex).substring(2); |
| |
| final int size = size(); |
| if (firstIndex == (size - 1)) { |
| return Collections.singletonList(firstNestedClass); |
| } |
| |
| List<String> result = null; |
| int startIndex = firstIndex + 1; |
| Iterator<String> it = signatures.subList(startIndex, size).iterator(); |
| for (int index = startIndex; it.hasNext(); index++) { |
| String signature = it.next(); |
| if (signature.charAt(0) == '[') { |
| if (result == null) { |
| int initialCapacity = Math.min(4, size - index + 1); |
| result = new ArrayList<String>(initialCapacity); |
| result.add(firstNestedClass); |
| } |
| result.add(signature.substring(2)); |
| } |
| } |
| |
| if (result == null) { |
| result = Collections.singletonList(firstNestedClass); |
| } |
| return result; |
| } |
| |
| /** |
| * Returns indexes (positions) of classes contained in the class |
| * corresponding to this {@code ClassMap}. Both nested classes (static) |
| * and inner classes are taken into account. Anonymous inner classes are |
| * ignored. |
| * |
| * @return an array of indexes ({@code 0}-based) of all nested classes |
| * in the corresponding class, or an empty array if there are |
| * no nested classes |
| */ |
| int[] getNestedClassIndexes() { |
| int firstIndex = getFirstNestedClassIndex(); |
| if (firstIndex == -1) { |
| return EMPTY_INT_ARRAY; |
| } |
| |
| assert signatures.get(firstIndex).charAt(0) == '['; |
| |
| final int size = size(); |
| if (firstIndex == (size - 1)) { |
| return new int[] {firstIndex}; |
| } |
| |
| int[] result = null; |
| int count = 1; |
| int startIndex = firstIndex + 1; |
| Iterator<String> it = signatures.subList(startIndex, size).iterator(); |
| for (int index = startIndex; it.hasNext(); index++) { |
| if (it.next().charAt(0) == '[') { |
| if (result == null) { |
| result = new int[size - index + 1]; |
| } |
| result[count++] = index; |
| } |
| } |
| assert (count == 1) == (result == null); |
| |
| if (result == null) { |
| result = new int[1]; |
| } else if (count < result.length) { |
| int[] oldResult = result; |
| result = new int[count]; |
| System.arraycopy(oldResult, 1, result, 1, count - 1); |
| } |
| result[0] = firstIndex; |
| return result; |
| } |
| |
| /** |
| */ |
| int size() { |
| return signatures.size(); |
| } |
| |
| /** |
| */ |
| private void shiftPositions(int fromIndex, |
| int shiftSize) { |
| for (int i = 0; i < positions.length; i++) { |
| int pos = positions[i]; |
| if ((pos != -1) && (pos >= fromIndex)) { |
| positions[i] = pos + shiftSize; |
| } |
| } |
| } |
| |
| } |