org.netbeans.modules.junit.DefaultPlugin Maven / Gradle / Ivy
/*
* 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 org.netbeans.modules.junit.api.JUnitSettings;
import org.netbeans.modules.junit.api.JUnitTestUtil;
import java.awt.GridLayout;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.lang.model.element.TypeElement;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.project.classpath.ProjectClassPathModifier;
import org.netbeans.api.java.queries.UnitTestForSourceQuery;
import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.java.source.ClasspathInfo.PathKind;
import org.netbeans.api.java.source.ElementHandle;
import org.netbeans.api.java.source.JavaSource;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.SourceGroupModifier;
import org.netbeans.api.project.Sources;
import org.netbeans.api.project.libraries.Library;
import org.netbeans.api.project.libraries.LibraryManager;
import org.netbeans.api.queries.VisibilityQuery;
import org.netbeans.modules.junit.TestabilityResult.SkippedClass;
import org.netbeans.modules.junit.plugin.JUnitPlugin;
import org.netbeans.modules.gsf.testrunner.api.SelfResizingPanel;
import org.netbeans.modules.gsf.testrunner.plugin.CommonPlugin.CreateTestParam;
import org.netbeans.modules.gsf.testrunner.plugin.CommonPlugin.Location;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;
import org.openide.ErrorManager;
import org.openide.NotifyDescriptor;
import org.openide.awt.Mnemonics;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.HelpCtx;
import org.openide.util.Mutex;
import org.openide.util.NbBundle;
import static java.util.logging.Level.FINER;
import static java.util.logging.Level.FINEST;
import org.netbeans.api.actions.Savable;
import static org.netbeans.api.java.classpath.ClassPath.SOURCE;
import static org.netbeans.api.java.classpath.ClassPath.COMPILE;
import static org.netbeans.api.java.project.JavaProjectConstants.SOURCES_TYPE_JAVA;
import org.netbeans.modules.gsf.testrunner.api.UnitTestsUsage;
import org.netbeans.modules.java.testrunner.GuiUtils;
import static org.netbeans.modules.java.testrunner.JavaUtils.PROP_JUNIT_SELECTED_VERSION;
import org.netbeans.modules.junit.api.JUnitUtils;
import org.netbeans.modules.junit.api.JUnitVersion;
import static org.openide.ErrorManager.ERROR;
import static org.openide.ErrorManager.WARNING;
import static org.openide.NotifyDescriptor.CANCEL_OPTION;
import static org.openide.NotifyDescriptor.WARNING_MESSAGE;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.util.Exceptions;
import org.openide.util.Utilities;
/**
* Default JUnit plugin.
*
* @author Marian Petras
*/
public final class DefaultPlugin extends JUnitPlugin {
/** logger for logging management of JUnit libraries */
private static final Logger LOG_JUNIT_VER
= Logger.getLogger(DefaultPlugin.class.getName()
+ "_JUnit_version_handling"); //NOI18N
/** full name of a file specific for the JUnit 3.8.x library */
private static final String JUNIT3_SPECIFIC
= "junit/awtui/TestRunner.class"; //NOI18N
/** full name of a file specific for the JUnit 4.x library */
private static final String JUNIT4_SPECIFIC
= "org/junit/Test.class"; //NOI18N
/** full name of a file specific for the JUnit 5.x library */
private static final String JUNIT5_SPECIFIC
= "org/junit/platform/commons/annotation/Testable.class"; //NOI18N
/** */
private final JUnitVersion generateVersion;
private JUnitVersion junitVer;
/** name of FreeMarker template property - generate {@literal @BeforeClass} method? */
private static final String templatePropBeforeClass = "classSetUp"; //NOI18N
/** name of FreeMarker template property - generate {@literal @AfterClass} method? */
private static final String templatePropAfterClass = "classTearDown";//NOI18N
/** name of FreeMarker template property - generate {@literal @Before} method? */
private static final String templatePropBefore = "methodSetUp"; //NOI18N
/** name of FreeMarker template property - generate {@literal @After} method? */
private static final String templatePropAfter = "methodTearDown"; //NOI18N
/** name of FreeMarker template property - generate in-method source code hints? */
private static final String templatePropCodeHints = "sourceCodeHint"; //NOI18N
/** name of FreeMarker template property - generate hints - method placeholders? */
private static final String templatePropMethodPH = "testMethodsPlaceholder"; //NOI18N
/** name of FreeMarker template property - use Java annotations? */
private static final String templatePropUseAnnotations = "useAnnotations"; //NOI18N
/** name of FreeMarker template property - list of class names */
private static final String templatePropClassNames = "classNames"; //NOI18N
/**
* name of FreeMarker template property - list of class names,
* each with a suffix ".class"
*/
private static final String templatePropClasses = "classes"; //NOI18N
/** */
private static java.util.ResourceBundle bundle = org.openide.util.NbBundle.getBundle(
DefaultPlugin.class);
private static boolean generatingIntegrationTest = false;
private static final String PROJECT_PROPERTIES_PATH = "nbproject/project.properties";
public DefaultPlugin(JUnitVersion v) {
generateVersion = v;
}
public static void logJUnitUsage(URI projectURI) {
String version = "";
Project project = FileOwnerQuery.getOwner(projectURI);
final ClassPath classPath = getTestClassPath(project);
if (classPath != null) {
if (classPath.findResource(JUNIT5_SPECIFIC) != null) {
version = JUnitVersion.JUNIT5.toString();
} else if (classPath.findResource(JUNIT4_SPECIFIC) != null) {
version = JUnitVersion.JUNIT4.toString();
} else if (classPath.findResource(JUNIT3_SPECIFIC) != null) {
version = JUnitVersion.JUNIT3.toString();
}
}
UnitTestsUsage.getInstance().logUnitTestUsage(projectURI, version);
}
/**
*
*/
@Override
protected boolean canCreateTests(FileObject... fileObjects) {
if (fileObjects.length == 0) {
return false;
}
final FileObject firstFile = fileObjects[0];
final SourceGroup sourceGroup = findSourceGroup(firstFile);
if (sourceGroup == null) {
return false;
}
final FileObject rootFolder = sourceGroup.getRootFolder();
if (UnitTestForSourceQuery.findUnitTests(rootFolder).length == 0) {
return false;
}
/*
* Now we know that source folder of the first file has a corresponding
* test folder (possible non-existent).
*/
if (fileObjects.length == 1) {
/* ... if there is just one file selected, it is all we need: */
return true;
}
/*
* ...for multiple files, we just check that all the selected files
* have the same root folder:
*/
for (int i = 1; i < fileObjects.length; i++) {
FileObject fileObj = fileObjects[i];
if (!FileUtil.isParentOf(rootFolder, fileObj)
|| !sourceGroup.contains(fileObj)) {
return false;
}
}
return true;
}
/**
* Finds a Java source group the given file belongs to.
*
* @param file {@literal FileObject} to find a {@literal SourceGroup} for
* @return the found {@literal SourceGroup}, or {@literal null} if the given
* file does not belong to any Java source group
*/
private static SourceGroup findSourceGroup(FileObject file) {
final Project project = FileOwnerQuery.getOwner(file);
if (project == null) {
return null;
}
Sources src = ProjectUtils.getSources(project);
SourceGroup[] srcGrps = src.getSourceGroups(SOURCES_TYPE_JAVA);
for (SourceGroup srcGrp : srcGrps) {
FileObject rootFolder = srcGrp.getRootFolder();
if (((file == rootFolder) || FileUtil.isParentOf(rootFolder, file))
&& srcGrp.contains(file)) {
return srcGrp;
}
}
return null;
}
/**
*
*/
protected Location getTestLocation(Location sourceLocation) {
FileObject fileObj = sourceLocation.getFileObject();
ClassPath srcCp;
if ((srcCp = ClassPath.getClassPath(fileObj, SOURCE)) == null) {
return null;
}
String baseResName = srcCp.getResourceName(fileObj, '/', false);
if(baseResName == null) {
return null;
}
String testResName = !fileObj.isFolder()
? getTestResName(baseResName, fileObj.getExt())
: getSuiteResName(baseResName);
assert testResName != null;
return getOppositeLocation(sourceLocation,
srcCp,
testResName,
true);
}
/**
*
*/
protected Location getTestedLocation(Location testLocation) {
FileObject fileObj = testLocation.getFileObject();
ClassPath srcCp;
if (fileObj.isFolder()
|| ((srcCp = ClassPath.getClassPath(fileObj, SOURCE)) == null)) {
return null;
}
String baseResName = srcCp.getResourceName(fileObj, '/', false);
if (baseResName == null) {
return null; //if the selectedFO is not within the classpath
}
String srcResName = getSrcResName(baseResName, fileObj.getExt());
if (srcResName == null) {
return null; //if the selectedFO is not a test class (by name)
}
return getOppositeLocation(testLocation,
srcCp,
srcResName,
false);
}
/**
*
*/
private static Location getOppositeLocation(
final Location sourceLocation,
final ClassPath fileObjCp,
final String oppoResourceName,
final boolean sourceToTest) {
FileObject fileObj = sourceLocation.getFileObject();
FileObject fileObjRoot;
if ((fileObjRoot = fileObjCp.findOwnerRoot(fileObj)) == null) {
return null;
}
URL[] oppoRootsURLs = sourceToTest
? UnitTestForSourceQuery.findUnitTests(fileObjRoot)
: UnitTestForSourceQuery.findSources(fileObjRoot);
//if (sourceToTest && (oppoRootsURLs.length == 0)) {
// PENDING - offer creation of new unit tests root
//}
if ((oppoRootsURLs == null) || (oppoRootsURLs.length == 0)) {
return null;
}
ClassPath oppoRootsClassPath = ClassPathSupport
.createClassPath(oppoRootsURLs);
final List oppoFiles = oppoRootsClassPath
.findAllResources(oppoResourceName);
if (oppoFiles.isEmpty()) {
//if (sourceToTest) {
// PENDING - offer creation of new test class
//}
return null;
}
// final ElementHandle elementHandle = sourceLocation.getElementHandle();
// if (elementHandle == null) {
return new Location(oppoFiles.get(0)/*, null*/);
// }
// /* Build SOURCE classpath: */
// ClassPath[] srcCpDelegates = new ClassPath[2];
// if (sourceToTest) {
// srcCpDelegates[0] = fileObjCp;
// srcCpDelegates[1] = oppoRootsClassPath;
// } else {
// srcCpDelegates[0] = oppoRootsClassPath;
// srcCpDelegates[1] = fileObjCp;
// }
// ClassPath srcClassPath
// = ClassPathSupport.createProxyClassPath(srcCpDelegates);
//
// /* Build COMPILE classpath: */
// FileObject[] oppoRoots = oppoRootsClassPath.getRoots();
// ClassPath[] compCpDelegates = new ClassPath[oppoRoots.length + 1];
// int delegateIndex = 0;
// if (sourceToTest) {
// compCpDelegates[delegateIndex++]
// = ClassPath.getClassPath(fileObjRoot, COMPILE);
// }
// for (FileObject oppoRoot : oppoRoots) {
// compCpDelegates[delegateIndex++]
// = ClassPath.getClassPath(oppoRoot, COMPILE);
// }
// if (!sourceToTest) {
// compCpDelegates[delegateIndex++]
// = ClassPath.getClassPath(fileObjRoot, COMPILE);
// }
// ClassPath compClassPath
// = ClassPathSupport.createProxyClassPath(compCpDelegates);
//
// /* Obtain the BOOT classpath: */
// ClassPath bootClassPath = ClassPath.getClassPath(fileObj, BOOT);
//
// ClasspathInfo cpInfo = ClasspathInfo.create(bootClassPath,
// compClassPath,
// srcClassPath);
// List files = new ArrayList(oppoFiles.size() + 1);
// files.add(fileObj);
// files.addAll(oppoFiles);
// JavaSource javaSource = JavaSource.create(cpInfo, files);
//
// try {
// MatchFinder matchFinder = new MatchFinder(sourceLocation,
// oppoFiles,
// sourceToTest);
// javaSource.runUserActionTask(matchFinder, true);
// return matchFinder.getResult();
// } catch (IOException ex) {
// Logger.getLogger("global").log(Level.SEVERE, null, ex); //NOI18N
// return null;
// }
}
// /**
// *
// */
// private static final class MatchFinder
// implements CancellableTask {
// private final FileObject currFile;
// private final ElementHandle currElemHandle;
// private final List oppoFiles;
// private final boolean sourceToTest;
//
// private String currFilePkgPrefix;
// private Element currElement;
//
// private volatile boolean cancelled;
//
// private String[] oppoClassNames;
// private String oppoMethodName;
// private int bestCandidateClassNamesCount;
// private FileObject bestCandidateFile;
// private Element bestCandidateElement;
//
// /** */
// private FileObject oppoFile = null;
// /** storage for the result */
// private Element oppoElement = null;
//
// /**
// *
// */
// private MatchFinder(Location currLocation,
// List oppoFiles,
// boolean sourceToTest) {
// this.currFile = currLocation.getFileObject();
// this.currElemHandle = currLocation.getElementHandle();
// this.oppoFiles = oppoFiles;
// this.sourceToTest = sourceToTest;
// }
//
// /**
// * This method is run once for the file referred by
// * {@link #currLocation} and then once for each file contained
// * in {@link #oppoFiles}.
// *
// * @param controller controller for the current run of this method
// */
// public void run(CompilationController controller) throws IOException {
// if (oppoFile != null) {
// /* We already have the result. */
//
// /*
// * This should be only possible if there are multiple oppoFiles.
// */
// assert oppoFiles.size() > 1;
// return;
// }
//
// final FileObject runFile = controller.getFileObject();
// if (runFile == currFile) {
// resolveCurrentElement(controller); //--> currElement
// return;
// }
//
// if (currElement == null) {
// /*
// * The element for 'currLocation' was not resolved during
// * the first run of this method on this instance.
// */
// return;
// }
// if ((oppoClassNames == null) || (oppoClassNames.length == 0)) {
// return;
// }
//
// controller.toPhase(Phase.PARSED);
//
// final Elements elements = controller.getElements();
// TypeElement topClass = elements.getTypeElement(getCanonicalClassName(oppoClassNames[0]));
// if ((topClass != null)
// && !CLASS_LIKE_ELEM_TYPES.contains(topClass.getKind())) {
// topClass = null;
// }
// if (cancelled || (topClass == null)) {
// return;
// }
//
// int classNamesCount = 0;
// TypeElement bestClass = null;
// TypeElement theSubClass = topClass;
// while ((theSubClass != null) && (++classNamesCount < oppoClassNames.length)) {
// bestClass = theSubClass;
//
// String oppoClassName = oppoClassNames[classNamesCount];
// if (oppoClassName == null) {
// break;
// }
//
// theSubClass = null;
// for (TypeElement subClass : typesIn(bestClass.getEnclosedElements())) {
// if (cancelled) {
// return;
// }
//
// if (CLASS_LIKE_ELEM_TYPES.contains(subClass.getKind())
// && subClass.getSimpleName().toString().equals(oppoClassName)) {
// theSubClass = subClass;
// break;
// }
// }
// }
// if (cancelled) {
// return;
// }
// if (classNamesCount == oppoClassNames.length) {
// bestClass = theSubClass; //this does not get called in the above while (...) cycle
//
// if (oppoMethodName == null) {
// oppoFile = runFile;
// oppoElement = bestClass;
// } else {
// ExecutableElement testMethod = findOppoMethod(bestClass);
// if (testMethod != null) {
// /* We found the test method! */
// oppoFile = runFile;
// oppoElement = testMethod;
// }
// }
// if (oppoFile != null) {
// return;
// }
// }
//
// if (classNamesCount > bestCandidateClassNamesCount) {
// bestCandidateFile = runFile;
// bestCandidateElement = bestClass;
// bestCandidateClassNamesCount = classNamesCount;
// }
// }
//
// /**
// */
// private ExecutableElement findOppoMethod(TypeElement classElem) {
// for (ExecutableElement elem : methodsIn(classElem.getEnclosedElements())) {
// if (elem.getSimpleName().toString().equals(oppoMethodName)) {
// if (!sourceToTest) {
// return elem;
// }
// if (elem.getParameters().isEmpty()) {
// Set modifiers = elem.getModifiers();
// if (modifiers.contains(Modifier.PUBLIC)
// && !modifiers.contains(Modifier.STATIC)) {
// return elem;
// }
// }
// break;
// }
// }
// return null;
// }
//
// public void cancel() {
// cancelled = true;
// }
//
// /**
// */
// private Location getResult() {
// assert (oppoFile == null) == (oppoElement == null);
//
// return (oppoFile != null)
// ? new Location(oppoFile, oppoElement)
// : new Location(bestCandidateFile, bestCandidateElement);
// }
//
// /**
// * Resolves 'currElementHandle' and stores the result to 'currElement'.
// */
// private void resolveCurrentElement(CompilationController controller)
// throws IOException {
// String canonicalFileName
// = controller.getClasspathInfo().getClassPath(PathKind.SOURCE)
// .getResourceName(currFile, '.', false);
// int lastDotIndex = canonicalFileName.lastIndexOf('.');
// currFilePkgPrefix = (lastDotIndex != -1)
// ? canonicalFileName.substring(0, lastDotIndex + 1)
// : null;
//
// controller.toPhase(Phase.PARSED);
// if (cancelled) {
// return;
// }
// currElement = currElemHandle.resolve(controller);
// if (currElement == null) {
// Logger.getLogger(getClass().getName()).log(
// Level.INFO,
// "Could not resolve element " + currElemHandle); //NOI18N
// return;
// }
//
// if (cancelled) {
// return;
// }
//
// Element clsElement;
// ElementKind currElemKind = currElement.getKind();
// if (CLASS_LIKE_ELEM_TYPES.contains(currElement.getKind())) {
// clsElement = currElement;
// oppoMethodName = null;
// } else {
// clsElement = currElement.getEnclosingElement();
// oppoMethodName = (currElemKind == ElementKind.METHOD)
// ? getOppoMethodName(currElement.getSimpleName().toString())
// : null; //no rule for finding tests for initializers
// }
// assert CLASS_LIKE_ELEM_TYPES.contains(clsElement.getKind());
//
// if (cancelled) {
// return;
// }
//
// oppoClassNames = buildOppoClassNames(clsElement);
// if (oppoClassNames == null) {
// oppoMethodName = null;
// } else {
// for (int i = 0; i < oppoClassNames.length; i++) {
// if (oppoClassNames[i] == null) {
// if (i == 0) {
// oppoClassNames = null;
// } else {
// String[] newArray = new String[i];
// System.arraycopy(oppoClassNames, 0, newArray, 0, i);
// oppoClassNames = newArray;
// }
// oppoMethodName = null;
// break;
// }
// }
//
// }
// }
//
// /**
// *
// * @return may return {@code null} if this task has been cancelled
// */
// private String[] buildOppoClassNames(Element clsElement) {
// String[] oppoClsNames;
// String oppoClsName;
//
// Element clsParent = clsElement.getEnclosingElement();
// if ((clsParent == null)
// || !CLASS_LIKE_ELEM_TYPES.contains(clsParent.getKind())) {
// oppoClsName = getOppoClassName(clsElement.getSimpleName().toString());
// oppoClsNames = (oppoClsName != null)
// ? new String[] {oppoClsName}
// : null;
// } else {
// List clsNames = new ArrayList();
// clsNames.add(clsElement.getSimpleName().toString());
// do {
// if (cancelled) {
// return null;
// }
//
// clsNames.add(clsParent.getSimpleName().toString());
// clsParent = clsParent.getEnclosingElement();
// } while ((clsParent != null)
// && CLASS_LIKE_ELEM_TYPES.contains(clsParent.getKind()));
//
// if (cancelled) {
// return null;
// }
//
// final int size = clsNames.size();
// oppoClsNames = new String[size];
// for (int i = 0; i < size; i++) {
// oppoClsName = getOppoClassName(clsNames.get(size - i - 1));
// if (oppoClsName == null) {
// break;
// }
// oppoClsNames[i] = oppoClsName;
// }
// }
// return oppoClsNames;
// }
//
// /**
// */
// private String getCanonicalClassName(String shortClassName) {
// return (currFilePkgPrefix != null)
// ? currFilePkgPrefix + shortClassName
// : shortClassName;
// }
//
// /**
// */
// private String getOppoClassName(String name) {
// return sourceToTest ? getTestClassName(name)
// : getSourceClassName(name);
// }
//
// /**
// */
// private String getOppoMethodName(String name) {
// return sourceToTest ? getTestMethodName(name)
// : getSourceMethodName(name);
// }
//
// }
/**
*/
private static String getTestResName(String baseResName, String ext) {
StringBuilder buf
= new StringBuilder(baseResName.length() + ext.length() + 10);
buf.append(baseResName).append("Test"); //NOI18N
if (ext.length() != 0) {
buf.append('.').append(ext);
}
return buf.toString();
}
/**
*/
private static String getSuiteResName(String baseResName) {
if (baseResName.length() == 0) {
return JUnitSettings.getDefault().getRootSuiteClassName();
}
final String suiteSuffix = "Suite"; //NOI18N
String lastNamePart
= baseResName.substring(baseResName.lastIndexOf('/') + 1);
StringBuilder buf = new StringBuilder(baseResName.length()
+ lastNamePart.length()
+ suiteSuffix.length()
+ 6);
buf.append(baseResName).append('/');
buf.append(Character.toUpperCase(lastNamePart.charAt(0)))
.append(lastNamePart.substring(1));
buf.append(suiteSuffix);
buf.append(".java"); //NOI18N
return buf.toString();
}
/**
*/
private static String getSrcResName(String testResName, String ext) {
if (!testResName.endsWith("Test")) { //NOI18N
return null;
}
StringBuilder buf
= new StringBuilder(testResName.length() + ext.length());
buf.append(testResName.substring(0, testResName.length() - 4));
if (ext.length() != 0) {
buf.append('.').append(ext);
}
return buf.toString();
}
/**
*/
private static String getTestClassName(String baseClassName) {
return baseClassName + "Test"; //NOI18N
}
private static String getIntegrationTestClassName(String baseClassName) {
return baseClassName + "IT"; //NOI18N
}
/**
*/
private static String getSourceClassName(String testClassName) {
final String suffix = "Test"; //NOI18N
final int suffixLen = suffix.length();
return ((testClassName.length() > suffixLen)
&& testClassName.endsWith(suffix))
? testClassName.substring(0, testClassName.length() - suffixLen)
: null;
}
/**
*/
private static String getTestMethodName(String baseMethodName) {
final String prefix = "test"; //NOI18N
final int prefixLen = prefix.length();
StringBuffer buf = new StringBuffer(prefixLen
+ baseMethodName.length());
buf.append(prefix).append(baseMethodName);
buf.setCharAt(prefixLen,
Character.toUpperCase(baseMethodName.charAt(0)));
return buf.toString();
}
/**
*/
private static String getSourceMethodName(String testMethodName) {
final String prefix = "test"; //NOI18N
final int prefixLen = prefix.length();
return ((testMethodName.length() > prefixLen)
&& testMethodName.startsWith(prefix))
? new StringBuilder(testMethodName.length() - prefixLen)
.append(Character.toLowerCase(testMethodName.charAt(prefixLen)))
.append(testMethodName.substring(prefixLen + 1))
.toString()
: null;
}
/**
* Creates test classes for given source classes.
*
* @param filesToTest source files for which test classes should be
* created
* @param targetRoot root folder of the target source root
* @param params parameters of creating test class
* @return created test files
*/
@Override
protected FileObject[] createTests(
final FileObject[] filesToTest,
final FileObject targetRoot,
final Map params) {
//XXX: not documented that in case that if filesToTest is ,
//the target root param works as a target folder
Project project = FileOwnerQuery.getOwner(targetRoot);
if (project != null) {
File projectFile = FileUtil.toFile(project.getProjectDirectory());
if (projectFile != null) {
logJUnitUsage(Utilities.toURI(projectFile));
}
}
ProgressIndicator progress = new ProgressIndicator();
progress.show();
String msg = NbBundle.getMessage(
DefaultPlugin.class,
"MSG_StatusBar_CreateTest_Begin"); //NOI18N
progress.displayStatusText(msg);
generatingIntegrationTest = Boolean.TRUE.equals(params.get(CreateTestParam.INC_GENERATE_INTEGRATION_TEST));
final TestCreator testCreator = new TestCreator(params, useVersion());
CreationResults results;
try {
final String templateId;
final String suiteTemplateId;
boolean forTestSuite
= (filesToTest != null)
&& (filesToTest.length != 0)
&& ((filesToTest.length > 1) || !filesToTest[0].isData());
switch (junitVer) {
case JUNIT3:
templateId = "PROP_junit3_testClassTemplate"; //NOI18N
suiteTemplateId = forTestSuite
? "PROP_junit3_testSuiteTemplate" //NOI18N
: null;
break;
case JUNIT4:
templateId = "PROP_junit4_testClassTemplate"; //NOI18N
suiteTemplateId = forTestSuite
? "PROP_junit4_testSuiteTemplate" //NOI18N
: null;
break;
case JUNIT5:
templateId = "PROP_junit5_testClassTemplate"; //NOI18N
suiteTemplateId = null;
break;
default:
assert false;
templateId = null;
suiteTemplateId = null;
break;
}
DataObject doTestTempl = (templateId != null)
? loadTestTemplate(templateId)
: null;
if (doTestTempl == null) {
return null;
}
DataObject doSuiteTempl = (suiteTemplateId != null)
? loadTestTemplate(suiteTemplateId)
: null;
if (forTestSuite && (doSuiteTempl == null)) {
return null;
}
Map templateParams = createTemplateParams(params);
setAnnotationsSupport(targetRoot, junitVer, templateParams);
if ((filesToTest == null) || (filesToTest.length == 0)) {
//XXX: Not documented that filesToTest may be
addTemplateParamEntry(params, CreateTestParam.INC_CODE_HINT,
templateParams, templatePropMethodPH);
String testClassName = (String) params.get(CreateTestParam.CLASS_NAME);
assert testClassName != null;
results = new CreationResults(1);
DataObject testDataObj = createEmptyTest(targetRoot,
testClassName,
testCreator,
templateParams,
doTestTempl);
if (testDataObj != null) {
results.addCreated(testDataObj);
}
} else {
ClassPath testClassPath = ClassPathSupport.createClassPath(
new FileObject[] {targetRoot});
if (!forTestSuite) {
String testClassName = (String) params.get(CreateTestParam.CLASS_NAME);
if (testClassName == null) {
String srcClassName
= ClassPath.getClassPath(filesToTest[0], SOURCE)
.getResourceName(filesToTest[0], '.', false);
if(generatingIntegrationTest) {
testClassName = getIntegrationTestClassName(srcClassName);
} else {
testClassName = getTestClassName(srcClassName);
}
}
try {
results = createSingleTest(
filesToTest[0],
testClassName,
testCreator,
templateParams,
doTestTempl,
testClassPath,
TestabilityResult.NO_TESTEABLE_METHODS.getReasonValue(),
null, //parent suite
progress);
} catch (CreationError ex) {
ErrorManager.getDefault().notify(ex);
results = new CreationResults(1);
}
} else {
results = new CreationResults();
// go through all nodes
for (FileObject fileToTest : filesToTest) {
try {
results.combine(createTests(fileToTest,
testCreator,
templateParams,
doTestTempl,
doSuiteTempl,
testClassPath,
null,
progress));
} catch (CreationError e) {
ErrorManager.getDefault().notify(e);
}
}
}
}
} finally {
progress.hide();
}
final Set skipped = results.getSkipped();
final Set created = results.getCreated();
if (!skipped.isEmpty() || created.isEmpty()) {
// something was skipped
String message = "";
if (skipped.size() == 1) {
// one class? report it
SkippedClass skippedClass = skipped.iterator().next();
message = NbBundle.getMessage(
DefaultPlugin.class,
"MSG_skipped_class", //NOI18N
skippedClass.clsName,
strReason(skippedClass.reason, "COMMA", "AND"));//NOI18N
} else {
// more classes, report a general error
// combine the results
TestabilityResult reason = TestabilityResult.OK;
for (SkippedClass sc : skipped) {
reason = TestabilityResult.combine(reason, sc.reason);
}
message = NbBundle.getMessage(
DefaultPlugin.class,
"MSG_skipped_classes", //NOI18N
strReason(reason, "COMMA", "OR")); //NOI18N
}
String noMessage = "";
if (created.isEmpty()) {
// nothing was created
noMessage = NbBundle.getMessage(
DefaultPlugin.class,
"MSG_No_test_created"); //NOI18N
}
final String finalMessage = (message.isEmpty()) ? noMessage : message.concat("\n\n").concat(noMessage); //NOI18N
if (!finalMessage.isEmpty()) {
Mutex.EVENT.writeAccess(new Runnable() {
public void run() {
JUnitTestUtil.notifyUser(finalMessage, NotifyDescriptor.INFORMATION_MESSAGE);
}
});
}
}
FileObject[] createdFiles;
if (created.isEmpty()) {
createdFiles = new FileObject[0];
} else {
createdFiles = new FileObject[created.size()];
int i = 0;
for (DataObject dObj : created) {
createdFiles[i++] = dObj.getPrimaryFile();
}
}
return createdFiles;
}
/**
* Create a map of FreeMaker template parameters from a map
* of {@literal CreateTestParam}s.
*/
public static final Map createTemplateParams(
Map params) {
Map result = new HashMap(7);
addTemplateParamEntry(params, CreateTestParam.INC_CLASS_SETUP,
result, templatePropBeforeClass);
addTemplateParamEntry(params, CreateTestParam.INC_CLASS_TEAR_DOWN,
result, templatePropAfterClass);
addTemplateParamEntry(params, CreateTestParam.INC_SETUP,
result, templatePropBefore);
addTemplateParamEntry(params, CreateTestParam.INC_TEAR_DOWN,
result, templatePropAfter);
addTemplateParamEntry(params, CreateTestParam.INC_CODE_HINT,
result, templatePropCodeHints);
return result;
}
private static void addTemplateParamEntry(Map srcParams,
CreateTestParam srcParamKey,
Map templParams,
String templParamKey) {
Object value = srcParams.get(srcParamKey);
if (value instanceof Boolean) {
templParams.put(templParamKey, Boolean.class.cast(value));
}
}
/**
*/
public boolean setupJUnitVersionByProject(FileObject targetFolder) {
return createTestActionCalled(new FileObject[] {targetFolder});
}
/**
*/
@Override
protected boolean createTestActionCalled(FileObject[] selectedFiles) {
// assert EventQueue.isDispatchThread(); #170707
LOG_JUNIT_VER.finer("createTestActionCalled(...)"); //NOI18N
Project project = FileOwnerQuery.getOwner(selectedFiles[0]);
assert project != null; //PENDING
boolean storeSettings;
try {
try {
storeSettings = readProjectSettingsJUnitVer(project);
} catch (IllegalStateException ex) {
if (SourceGroupModifier.createSourceGroup(project, JavaProjectConstants.SOURCES_TYPE_JAVA, JavaProjectConstants.SOURCES_HINT_TEST) != null) {
//repeat if the folder/Sourcegroup was created.
storeSettings = readProjectSettingsJUnitVer(project);
} else {
throw ex;
}
}
if (!storeSettings) {
LOG_JUNIT_VER.finest(
" - will not be able to store JUnit version settings"); //NOI18N
}
} catch (IllegalStateException ex) {
String projectName = ProjectUtils.getInformation(project)
.getDisplayName();
DialogDisplayer.getDefault().notify(
new NotifyDescriptor.Message(
NbBundle.getMessage(
getClass(),
"MSG_NoTestFolderFoundInProject",//NOI18N
projectName),
NotifyDescriptor.WARNING_MESSAGE));
return false;
}
GO_ON: if (junitVer != null) {
if (generateVersion != null && junitVer != generateVersion) {
break GO_ON;
}
switch (junitVer) {
case JUNIT3:
return true;
case JUNIT4:
String sourceLevel = JUnitTestUtil.getSourceLevel(selectedFiles[0]);
if (sourceLevel == null) { //could not get source level
return true;
}
if (sourceLevel.compareTo("1.5") >= 0) { //NOI18N
return true;
} else if (askUserLastWasJUnit4NowSource14(sourceLevel)) {
junitVer = JUnitVersion.JUNIT3;
if (storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return true;
}
return false;
case JUNIT5:
{
sourceLevel = JUnitTestUtil.getSourceLevel(selectedFiles[0]);
if (sourceLevel == null) { //could not get source level
return true;
}
if (sourceLevel.compareTo("1.8") >= 0) { //NOI18N
return true;
}
return false;
}
default:
assert false;
return false;
}
}
readSystemSettingsJUnitVer();
if (junitVer != null) {
switch (junitVer) {
case JUNIT3:
if (storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return true;
case JUNIT4:
String sourceLevel = JUnitTestUtil.getSourceLevel(selectedFiles[0]);
if ((sourceLevel != null)
&& (sourceLevel.compareTo("1.5")) >= 0) { //NOI18N
if (storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return true;
} else if (sourceLevel == null) {
String msgKey
= "MSG_select_junit_version_srclvl_unknown";//NOI18N
loadJUnitToUseFromPropertiesFile(project);
if ((junitVer != null) && storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return (junitVer != null);
} else if (informUserOnlyJUnit3Applicable(sourceLevel)) {
junitVer = JUnitVersion.JUNIT3;
if (storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return true;
}
return false;
case JUNIT5:
{
sourceLevel = JUnitTestUtil.getSourceLevel(selectedFiles[0]);
if ((sourceLevel != null)
&& (sourceLevel.compareTo("1.8")) >= 0) { //NOI18N
if (storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return true;
}
return false;
}
default:
assert false;
return false;
}
}
if (generateVersion != null) {
junitVer = generateVersion;
} else {
boolean offerJUnit4;
boolean defaultToJUnit5 = false;
String sourceLevel = JUnitTestUtil.getSourceLevel(selectedFiles[0]);
if (sourceLevel == null) {
offerJUnit4 = true;
} else {
defaultToJUnit5 = generateVersion == null && (sourceLevel.compareTo("1.8") >= 0); //NOI18N
offerJUnit4 = (sourceLevel.compareTo("1.5") >= 0); //NOI18N
}
loadJUnitToUseFromPropertiesFile(project);
if(junitVer == null) {
if (defaultToJUnit5) {
// Java 8 and above should default to JUnit 5
junitVer = JUnitVersion.JUNIT5;
} else {
// probably new project after 8.1, since determining junitVer failed
// sofar, so as last resort default to 4.x
junitVer = JUnitVersion.JUNIT4;
}
}
}
if ((junitVer != null) && storeSettings) {
return storeProjectSettingsJUnitVer(project);
}
return (junitVer != null);
}
/**
*/
private boolean askUserLastWasJUnit4NowSource14(String sourceLevel) {
// assert EventQueue.isDispatchThread(); #170707
JComponent msg
= createMessageComponent("MSG_last_was_junit4_what_now", //NOI18N
sourceLevel);
Object selectOption = NbBundle.getMessage(
getClass(),
"LBL_create_junit3_tests"); //NOI18N
Object answer = DialogDisplayer.getDefault().notify(
new DialogDescriptor(
wrapDialogContent(msg),
NbBundle.getMessage(
getClass(),
"LBL_title_cannot_use_junit4"), //NOI18N
true,
new Object[] {selectOption, CANCEL_OPTION},
selectOption,
DialogDescriptor.DEFAULT_ALIGN,
(HelpCtx) null,
(ActionListener) null));
return answer == selectOption;
}
/**
*/
private boolean informUserOnlyJUnit3Applicable(String sourceLevel) {
// assert EventQueue.isDispatchThread(); #170707
JComponent msg
= createMessageComponent("MSG_cannot_use_default_junit4", //NOI18N
sourceLevel);
// Object selectOption = NbBundle.getMessage(
// getClass(),
// "LBL_create_junit3_tests"); //NOI18N
JButton button = new JButton();
Mnemonics.setLocalizedText(button, bundle.getString("LBL_Select"));
button.getAccessibleContext().setAccessibleName("AN_create_junit3_tests");
button.getAccessibleContext().setAccessibleDescription("AD_create_junit3_tests");
Object answer = DialogDisplayer.getDefault().notify(
new DialogDescriptor(
wrapDialogContent(msg),
NbBundle.getMessage(
getClass(),
"LBL_title_cannot_use_junit4"), //NOI18N
true, //modal
new Object[] {button, CANCEL_OPTION},
button,
DialogDescriptor.DEFAULT_ALIGN,
(HelpCtx) null,
(ActionListener) null));
return answer == button;
}
// private String getText(String bundleKey) {
// return NbBundle.getMessage(getClass(), bundleKey);
// }
private Properties getProjectProperties(FileObject projectDir) throws IOException {
FileObject projectProperties = FileUtil.createData(projectDir, PROJECT_PROPERTIES_PATH);
InputStream propertiesIS = projectProperties.getInputStream();
Properties props = new Properties();
props.load(propertiesIS);
propertiesIS.close();
return props;
}
private void loadJUnitToUseFromPropertiesFile(Project project) {
final FileObject projectDir = project.getProjectDirectory();
ProjectManager.mutex().postReadRequest(new Runnable() {
@Override
public void run() {
try {
Properties props = getProjectProperties(projectDir);
String property = props.getProperty(PROP_JUNIT_SELECTED_VERSION);
junitVer = property == null ? null : (property.equals("3") ? JUnitVersion.JUNIT3 : property.equals("4") ? JUnitVersion.JUNIT4 : JUnitVersion.JUNIT5);
} catch (IOException ex) {
Exceptions.printStackTrace(ex);
}
}
});
}
// /**
// */
// private JUnitVersion askUserWhichJUnitToUse(String msgKey,
// boolean offerJUnit4,
// boolean showSourceLevelCondition) {
// // assert EventQueue.isDispatchThread(); #170707
//
// JRadioButton rbtnJUnit3 = new JRadioButton();
// Mnemonics.setLocalizedText(rbtnJUnit3, bundle.getString("LBL_JUnit3_generator"));
// rbtnJUnit3.getAccessibleContext().setAccessibleDescription(bundle.getString("AD_JUnit3_generator"));
//
// JRadioButton rbtnJUnit4 = new JRadioButton();
// Mnemonics.setLocalizedText(
// rbtnJUnit4,
// showSourceLevelCondition
// ? bundle.getString("LBL_JUnit4_generator_reqs") //NOI18N
// : bundle.getString("LBL_JUnit4_generator")); //NOI18N
// rbtnJUnit4.getAccessibleContext().setAccessibleDescription(bundle.getString("AD_JUnit4_generator"));
//
// ButtonGroup group = new ButtonGroup();
// group.add(rbtnJUnit3);
// group.add(rbtnJUnit4);
//
// if (offerJUnit4) {
// rbtnJUnit4.setSelected(true);
// } else {
// rbtnJUnit3.setSelected(true);
// rbtnJUnit4.setEnabled(false);
// }
//
// JComponent msg
// = createMessageComponent(msgKey);
//
// JPanel choicePanel = new JPanel(new GridLayout(0, 1, 0, 3));
// choicePanel.add(rbtnJUnit3);
// choicePanel.add(rbtnJUnit4);
//
// JPanel panel = new JPanel(new BorderLayout(0, 12));
// panel.add(msg, BorderLayout.NORTH);
// panel.add(choicePanel, BorderLayout.CENTER);
//
// JButton button = new JButton();
// Mnemonics.setLocalizedText(button, bundle.getString("LBL_Select"));
// button.getAccessibleContext().setAccessibleName("AN_Select");
// button.getAccessibleContext().setAccessibleDescription("AD_Select");
//
//// Object selectOption = bundle.getString("LBL_Select"); //NOI18N
// Object answer = DialogDisplayer.getDefault().notify(
// new DialogDescriptor(
// wrapDialogContent(panel),
// bundle.getString("LBL_title_select_generator"),//NOI18N
// true,
// new Object[] {button, CANCEL_OPTION},
// button,
// DialogDescriptor.DEFAULT_ALIGN,
// new HelpCtx(
// "org.netbeans.modules.junit.select_junit_version"),//NOI18N
// (ActionListener) null));
//
// if (answer == button) {
// JUnitVersion ver;
// if (rbtnJUnit3.isSelected()) {
// ver = JUnitVersion.JUNIT3;
// } else if (rbtnJUnit4.isSelected()) {
// ver = JUnitVersion.JUNIT4;
// } else {
// assert false;
// ver = null;
// }
// return ver;
// } else {
// return null;
// }
// }
/**
*/
private JComponent createMessageComponent(String msgKey,
String... args) {
String message = NbBundle.getMessage(getClass(), msgKey, args);
return GuiUtils.createMultilineLabel(message);
}
/**
*/
private static JComponent wrapDialogContent(JComponent comp) {
return wrapDialogContent(comp, true);
}
/**
*/
private static JComponent wrapDialogContent(JComponent comp,
boolean selfResizing) {
JComponent result;
if ((comp.getBorder() != null) || selfResizing) {
result = selfResizing ? new SelfResizingPanel() : new JPanel();
result.setLayout(new GridLayout());
result.add(comp);
} else {
result = comp;
}
result.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
result.getAccessibleContext().setAccessibleDescription(bundle.getString("AD_title_select_generator"));
return result;
}
/**
* Gets JUnit version info from the project and stores it
* into field {@link #junitVer}.
* If the "junit version" info is not available,
* {@literal null} is stored.
*
* @param project project from which the information is to be obtained
* @return {@literal true} of the set of project's libraries could be
* determined, {@literal false} if it could not be determined
* @throws java.lang.IllegalStateException if the project does not contain any test folders
* @see #junitVer
*/
private boolean readProjectSettingsJUnitVer(Project project)
throws IllegalStateException {
assert project != null;
if (LOG_JUNIT_VER.isLoggable(FINER)) {
LOG_JUNIT_VER.finer("readProjectSettingsJUnitVer(" //NOI18N
+ ProjectUtils.getInformation(project).getDisplayName()
+ ')');
}
junitVer = null;
final boolean hasJUnit3;
final boolean hasJUnit4;
final boolean hasJUnit5;
final ClassPath classPath = getTestClassPath(project); //may throw ISE
loadJUnitToUseFromPropertiesFile(project);
if (junitVer == null) {
if (classPath != null) {
hasJUnit3 = (classPath.findResource(JUNIT3_SPECIFIC) != null);
hasJUnit4 = (classPath.findResource(JUNIT4_SPECIFIC) != null);
hasJUnit5 = (classPath.findResource(JUNIT5_SPECIFIC) != null);
} else {
hasJUnit3 = false;
hasJUnit4 = false;
hasJUnit5 = false;
}
if (hasJUnit3 || hasJUnit4 || hasJUnit5) {
junitVer = hasJUnit3 ? JUnitVersion.JUNIT3
: hasJUnit4 ? JUnitVersion.JUNIT4 : JUnitVersion.JUNIT5;
if (LOG_JUNIT_VER.isLoggable(FINEST)) {
LOG_JUNIT_VER.finest(" - detected version " + junitVer);//NOI18N
}
} else {
LOG_JUNIT_VER.finest(" - no version detected"); //NOI18N
}
} else {
if (LOG_JUNIT_VER.isLoggable(FINEST)) {
LOG_JUNIT_VER.finest(" - detected version " + junitVer);//NOI18N
}
}
return (classPath != null);
}
/**
* Finds classpath used for compilation of tests.
*
* @param project project whose classpath should be found
* @return test classpath of the given project, or {@literal null} if it could
* not be determined
* @throws java.lang.IllegalStateException if no test folders were found in the project
*/
private static ClassPath getTestClassPath(final Project project)
throws IllegalStateException {
assert project != null;
if (LOG_JUNIT_VER.isLoggable(FINER)) {
LOG_JUNIT_VER.finer("getTestClassPath(" //NOI18N
+ ProjectUtils.getInformation(project).getDisplayName()
+ ')');
}
final Collection testFolders = JUnitUtils.getTestFolders(project);
if (testFolders.isEmpty()) {
LOG_JUNIT_VER.finest(" - no unit test folders found"); //NOI18N
}
final ClassPathProvider cpProvider
= project.getLookup().lookup(ClassPathProvider.class);
if (cpProvider == null) {
LOG_JUNIT_VER.finest(" - ClassPathProvider not found"); //NOI18N
return null;
}
for (FileObject testRoot : testFolders) {
ClassPath testClassPath = cpProvider.findClassPath(testRoot,
COMPILE);
if (testClassPath != null) {
if (LOG_JUNIT_VER.isLoggable(FINEST)) {
LOG_JUNIT_VER.finest(" - returning: " //NOI18N
+ testClassPath);
}
return testClassPath;
}
}
LOG_JUNIT_VER.finest(" - no compile classpath for unit tests found");//NOI18N
return null;
}
/**
* Stores JUnit version to the project's configuration file.
*
* @param project project whose configuration file is to be checked
* @see #junitVer
*/
private boolean storeProjectSettingsJUnitVer(final Project project) {
assert junitVer != null;
if (LOG_JUNIT_VER.isLoggable(FINER)) {
LOG_JUNIT_VER.finer("storeProjectSettignsJUnitVer(" //NOI18N
+ ProjectUtils.getInformation(project).getDisplayName()
+ ')');
}
final boolean hasJUnit3;
final boolean hasJUnit4;
final boolean hasJUnit5;
final ClassPath classPath = getTestClassPath(project);
if (classPath != null) {
hasJUnit3 = (classPath.findResource(JUNIT3_SPECIFIC) != null);
hasJUnit4 = (classPath.findResource(JUNIT4_SPECIFIC) != null);
hasJUnit5 = (classPath.findResource(JUNIT5_SPECIFIC) != null);
} else {
hasJUnit3 = false;
hasJUnit4 = false;
hasJUnit5 = false;
}
final Pattern pattern = Pattern.compile(
"^junit(?:_|\\W)+([345])(?:\\b|_).*"); //NOI18N
JUnitLibraryComparator libraryComparator = null;
Library libraryToAdd = null;
Collection librariesToRemove = null;
Library libraryHamcrest = null;
LOG_JUNIT_VER.finest(" - checking libraries:"); //NOI18N
Library[] libraries = LibraryManager.getDefault().getLibraries();
for (Library library : libraries) {
String name = library.getName().toLowerCase();
if (LOG_JUNIT_VER.isLoggable(FINEST)) {
LOG_JUNIT_VER.finest(" " + name);
}
if (name.equals("hamcrest")) { //NOI18N
libraryHamcrest = library;
continue;
}
if (!name.startsWith("junit")) { //NOI18N
LOG_JUNIT_VER.finest(" - not a JUnit library"); //NOI18N
continue;
}
boolean add = false;
boolean remove = false;
Matcher matcher;
final String verNumToAdd;
if ((junitVer == JUnitVersion.JUNIT3) && !hasJUnit3) {
verNumToAdd = "3"; //NOI18N
} else if ((junitVer == JUnitVersion.JUNIT4) && !hasJUnit4) {
verNumToAdd = "4"; //NOI18N
} else if ((junitVer == JUnitVersion.JUNIT5) && !hasJUnit5) {
verNumToAdd = "5"; //NOI18N
} else {
verNumToAdd = null;
}
// junit-3.8.2 binaries were removed from standard build. User can
// open legacy project with or create new testcases using junit 3.x
// style. This means only junit-3.x can be removed no matter what.
String verNumToRemove = "3"; //NOI18N
if (name.equals("junit")) { //NOI18N
add = (verNumToAdd == "3"); //NOI18N
remove = (verNumToRemove == "3"); //NOI18N
} else if ((matcher = pattern.matcher(name)).matches()) {
String verNum = matcher.group(1);
add = verNum.equals(verNumToAdd );
remove = verNum.equals(verNumToRemove);
}
if (add) {
LOG_JUNIT_VER.finest(" - to be added"); //NOI18N
if (libraryToAdd == null) {
libraryToAdd = library;
} else {
/*
* If there are multiple conforming libraries, we only want
* to add one - the most recent one (i.e. having the highest
* version number).
*/
LOG_JUNIT_VER.finest(" - will be compared:");//NOI18N
if (libraryComparator == null) {
libraryComparator = new JUnitLibraryComparator();
}
if (libraryComparator.compare(libraryToAdd, library) > 0) {
LOG_JUNIT_VER.finest(" - it won"); //NOI18N
libraryToAdd = library;
} else {
LOG_JUNIT_VER.finest(" - it lost"); //NOI18N
}
}
}
if (remove) {
LOG_JUNIT_VER.finest(" - to be removed"); //NOI18N
if (librariesToRemove == null) {
librariesToRemove = new ArrayList(2);
}
librariesToRemove.add(library);
}
}
if ((libraryToAdd == null) && (librariesToRemove == null)) {
return true;
}
final List projectArtifacts = getProjectTestArtifacts(project);
if (projectArtifacts.isEmpty()) {
displayMessage("MSG_cannot_set_junit_ver", //NOI18N
WARNING_MESSAGE);
return /*???*/true;
}
final Library[] libsToAdd, libsToRemove;
if (libraryToAdd != null) {
if (junitVer == JUnitVersion.JUNIT5){
// junit 5 doesn't require hamcrest
libsToAdd = new Library[] {libraryToAdd};
} else {
// junit-3.8.2 binaries were removed from standard build. User can
// open legacy project with or create new testcases using junit 3.x
// style. junit-4.x and hamcrest binaries are added as test
// dependencies for the project in those cases as well.
libsToAdd = new Library[] {libraryToAdd, libraryHamcrest};
}
} else{
libsToAdd = null;
}
if (librariesToRemove != null) {
libsToRemove = librariesToRemove.toArray(
new Library[librariesToRemove.size()]);
} else {
libsToRemove = null;
}
assert (libsToAdd != null) || (libsToRemove != null);
class LibrarySetModifier implements Runnable {
public void run() {
boolean modified = false;
try {
if (libsToAdd != null) {
for (FileObject prjArtifact : projectArtifacts) {
modified |= ProjectClassPathModifier.addLibraries(
libsToAdd, prjArtifact, COMPILE);
}
}
if (libsToRemove != null) {
for (FileObject prjArtifact : projectArtifacts) {
modified |= ProjectClassPathModifier.removeLibraries(
libsToRemove, prjArtifact, COMPILE);
}
}
} catch (UnsupportedOperationException ex) {
String prjName = ProjectUtils.getInformation(project)
.getDisplayName();
ErrorManager.getDefault().log(
WARNING,
"Project " + prjName //NOI18N
+ ": Could not modify set of JUnit libraries" //NOI18N
+ " - operation not supported by the project.");//NOI18N
} catch (IOException ex) {
ErrorManager.getDefault().notify(ERROR, ex);
}
if (modified) {
try {
ProjectManager.getDefault().saveProject(project);
} catch (IOException ex) {
ErrorManager.getDefault().notify(ERROR, ex);
}
}
}
}
ProjectManager.mutex().writeAccess(
new LibrarySetModifier());
return true;
}
/**
* Schedules displaying of a message to the event-dispatching thread.
*
* @param bundleKey resource bundle key of the message
* @param msgType type of the message
* (e.g. {@literal NotifyDescriptor.INFORMATION_MESSAGE})
*/
private static void displayMessage(String bundleKey, int msgType) {
DialogDisplayer.getDefault().notifyLater(
new NotifyDescriptor.Message(
NbBundle.getMessage(DefaultPlugin.class, bundleKey),
msgType));
}
/**
* Finds a project artifact used as an argument to method
* {@literal ProjectClassPathModifier.removeLibraries(...)}
* when modifying the set of JUnit libraries (used for tests).
*
* @param project project for which the project artifact should be found
* @return list of test project artifacts, or {@literal null} an empty list
* if no one could be determined
*/
private static List getProjectTestArtifacts(final Project project) {
assert project != null;
final ClassPathProvider cpProvider
= project.getLookup().lookup(ClassPathProvider.class);
if (cpProvider == null) {
Collections.emptyList();
}
final Collection testFolders = JUnitUtils.getTestFolders(project);
if (testFolders.isEmpty()) {
Collections.emptyList();
}
List result = null;
for (FileObject testRoot : testFolders) {
ClassPath testClassPath = cpProvider.findClassPath(testRoot,
ClassPath.COMPILE);
if (testClassPath != null) {
if (result == null) {
if (testFolders.size() == 1) {
return Collections.singletonList(testRoot);
} else {
result = new ArrayList(3);
}
}
result.add(testRoot);
}
}
return (result != null)
? result
: Collections.emptyList();
}
/**
* Reads information about preferred JUnit version from the IDE settings
* and stores is into field {@link #junitVer}.
*
* @see #junitVer
*/
private void readSystemSettingsJUnitVer() {
junitVer = null;
/*
String value = JUnitSettings.getDefault().getGenerator();
if ((value == null) || value.equals(JUNIT_GENERATOR_ASK_USER)) {
junitVer = null;
} else {
try {
junitVer = Enum.valueOf(JUnitVersion.class, value.toUpperCase());
} catch (IllegalArgumentException ex) {
junitVer = null;
}
}
*/
}
/**
* Creates a new test class.
*
* @param targetRoot
* @param testClassName
* @param testCreator {@literal TestCreator} to be used for filling
* the test class template
* @param templateDataObj {@literal DataObject} representing
* the test file template
* @return the created test, or {@literal null} if no test was created
*/
private DataObject createEmptyTest(FileObject targetRoot,
String testClassName,
TestCreator testCreator,
final Map templateParams,
DataObject templateDataObj) {
if (testClassName == null) {
throw new IllegalArgumentException("testClassName = null"); //NOI18N
}
DataObject testDataObj = null;
try {
DataFolder targetFolderDataObj = DataFolder.findFolder(targetRoot);
testDataObj = templateDataObj.createFromTemplate(
targetFolderDataObj,
testClassName,
templateParams);
/* fill in setup etc. according to dialog settings */
testCreator.createEmptyTest(testDataObj.getPrimaryFile());
} catch (IOException ex) {
ErrorManager.getDefault().notify(ex);
}
return testDataObj;
}
/**
*
*/
private static CreationResults createSingleTest(
FileObject sourceFile,
String requestedTestClassName,
final TestCreator testCreator,
final Map templateParams,
DataObject templateDataObj,
ClassPath testClassPath,
long skipTestabilityResultMask,
List parentSuite,
ProgressIndicator progress) throws CreationError {
List nonTestable;
List> testable;
try {
JavaSource javaSource = JavaSource.forFileObject(sourceFile);
//issue 161598
if (javaSource == null)
return CreationResults.EMPTY;
if (skipTestabilityResultMask != 0) {
nonTestable = new ArrayList();
testable = TopClassFinder.findTestableTopClasses(javaSource,
testCreator,
nonTestable,
skipTestabilityResultMask);
} else {
nonTestable = Collections.emptyList();
testable = TopClassFinder.findTopClasses(javaSource);
}
} catch (IOException ex) {
throw new CreationError(ex);
}
CreationResults result = new CreationResults(4);
if (!nonTestable.isEmpty()) {
result.addSkipped(nonTestable);
}
if (!testable.isEmpty()) {
/* used only if (requestedTestClassName != null): */
boolean mainClassProcessed = false;
try {
for (ElementHandle clsToTest : testable) {
String testClassName;
String srcClassNameFull = clsToTest.getQualifiedName();
if ((requestedTestClassName != null)
&& !mainClassProcessed
&& JUnitTestUtil.getSimpleName(srcClassNameFull)
.equals(sourceFile.getName())) {
testClassName = requestedTestClassName;
mainClassProcessed = true;
} else {
if(generatingIntegrationTest) {
testClassName = JUnitTestUtil.getIntegrationTestClassName(srcClassNameFull);
} else {
testClassName = JUnitTestUtil.getTestClassName(srcClassNameFull);
}
}
String testResourceName = testClassName.replace('.', '/');
/* find or create the test class DataObject: */
DataObject testDataObj = null;
FileObject testFile = testClassPath.findResource(
testResourceName + ".java");//NOI18N
boolean isNew = (testFile == null);
if (testFile == null) {
testDataObj = createTestClass(testClassPath, null,
testResourceName,
templateDataObj,
templateParams);
testFile = testDataObj.getPrimaryFile();
}
testCreator.createSimpleTest(clsToTest, testFile, isNew);
if (testDataObj == null) {
testDataObj = DataObject.find(testFile);
}
save(testDataObj);
result.addCreated(testDataObj);
// add the test class to the parent's suite
if (parentSuite != null) {
parentSuite.add(testClassName);
}
}
} catch (IOException ex) { //incl. DataObjectNotFoundException
throw new CreationError(ex);
}
}
return result;
}
/**
*
*/
private static CreationResults createTests(
final FileObject srcFileObj,
final TestCreator testCreator,
final Map templateParams,
DataObject doTestT,
DataObject doSuiteT,
final ClassPath testClassPath,
List parentSuite,
ProgressIndicator progress) throws CreationError {
CreationResults results;
if (srcFileObj.isFolder()) {
results = new CreationResults();
List mySuite = new LinkedList();
progress.setMessage(getScanningMsg(srcFileObj.getName()));
for (FileObject childFileObj : srcFileObj.getChildren()) {
if (progress.isCanceled()) {
results.setAbborted();
break;
}
if (!VisibilityQuery.getDefault().isVisible(childFileObj)) {
continue;
}
results.combine(createTests(childFileObj,
testCreator,
templateParams,
doTestT,
doSuiteT,
testClassPath,
mySuite,
progress));
if (results.isAbborted()) {
break;
}
}
// if everything went ok, and the option is enabled,
// create a suite for the folder .
if (!results.isAbborted()
// && !mySuite.isEmpty()
&& JUnitSettings.getDefault().isGenerateSuiteClasses()) {
createSuiteTest(srcFileObj,
(String) null,
testCreator,
templateParams,
doSuiteT,
testClassPath,
mySuite,
parentSuite,
progress);
}
} else if (srcFileObj.isData() && JUnitTestUtil.isJavaFile(srcFileObj)) {
results = createSingleTest(srcFileObj,
(String) null, //use the default clsName
testCreator,
templateParams,
doTestT,
testClassPath,
TestabilityResult.NO_TESTEABLE_METHODS.getReasonValue(),
parentSuite,
progress);
} else {
results = CreationResults.EMPTY;
}
return results;
}
/**
*
*/
private static DataObject createSuiteTest(
FileObject folder,
String suiteName,
final TestCreator testCreator,
final Map templateParams,
DataObject templateDataObj,
ClassPath testClassPath,
List classesToInclude,
List parentSuite,
ProgressIndicator progress) throws CreationError {
// find correct package name
ClassPath cp = ClassPath.getClassPath(folder, SOURCE);
assert cp != null : "SOURCE classpath was not found for " + folder; //NOI18N
if (cp == null) {
return null;
}
String pkg = cp.getResourceName(folder, '/', false);
// #176958 : append the rootFolderName in the fullSuiteName, so that we can decide in which Classpath root folder
// the new Suite file will be generated, when createTestClass(...) is called later on
String rootFolderName = ""; //NOI18N
if (cp.getRoots().length > 1) {
FileObject rootOwnerFO = cp.findOwnerRoot(folder);
if (rootOwnerFO != null) {
rootFolderName = rootOwnerFO.getName() + '/';
}
}
String dotPkg = pkg.replace('/', '.');
String fullSuiteName = rootFolderName.concat((suiteName != null)
? pkg + '/' + suiteName
: (generatingIntegrationTest ? JUnitTestUtil.convertPackage2ITSuiteName(pkg) : JUnitTestUtil.convertPackage2SuiteName(pkg)));
String classNames = makeListOfClasses(classesToInclude, null);
String classes = makeListOfClasses(classesToInclude, ".class"); //NOI18N
final Map suiteTemplParams
= new HashMap(templateParams);
suiteTemplParams.put(templatePropClassNames, classNames);
suiteTemplParams.put(templatePropClasses, classes);
try {
/* find or create the test class DataObject: */
DataObject testDataObj = null;
FileObject testFile = testClassPath.findResource(
fullSuiteName + ".java"); //NOI18N
boolean isNew = (testFile == null);
if (testFile == null) {
testDataObj = createTestClass(testClassPath, cp,
fullSuiteName,
templateDataObj,
suiteTemplParams);
testFile = testDataObj.getPrimaryFile();
}
List processedClasses;
//JavaSource testSrc = JavaSource.forFileObject(testFile);
try {
processedClasses = testCreator.createTestSuite(classesToInclude,
testFile,
isNew);
if (testDataObj == null) {
testDataObj = DataObject.find(testFile);
}
save(testDataObj);
} catch (Exception ex) {
ErrorManager.getDefault().notify(ErrorManager.ERROR, ex);
return null;
}
// add the suite class to the list of members of the parent
if ((parentSuite != null) && !processedClasses.isEmpty()) {
for (String simpleClassName : processedClasses) {
parentSuite.add(dotPkg.length() != 0
? dotPkg + '.' + simpleClassName
: simpleClassName);
}
}
return testDataObj;
} catch (IOException ioe) {
throw new CreationError(ioe);
}
}
/**
* Makes a string contaning comma-separated list of the given names.
* If the {@literal suffix} parameter is non-{@literal null}, each of the given
* names is appended a given suffix.
*
* Examples:
*
* makeListOfClasses(<"Alpha", "Beta", "Gamma">, null)
* => "Alpha,Beta,Gamma"
* makeListOfClasses(<"Alpha", "Beta", "Gamma">, ".class")
* => "Alpha.class,Beta.class,Gamma.class"
*
*/
private static final String makeListOfClasses(final List clsNames,
final String suffix) {
if (clsNames.isEmpty()) {
return ""; //NOI18N
}
if (clsNames.size() == 1) {
return (suffix == null) ? clsNames.get(0)
: clsNames.get(0) + suffix;
}
StringBuilder buf = new StringBuilder(128);
boolean first = true;
for (String clsName : clsNames) {
if (!first) {
buf.append(',');
}
buf.append(clsName);
if (suffix != null) {
buf.append(suffix);
}
first = false;
}
return buf.toString();
}
/**
*
*/
public DataObject createSuiteTest(
final FileObject targetRootFolder,
final FileObject targetFolder,
final String suiteName,
final Map params) {
final Map templateParams = createTemplateParams(params);
setAnnotationsSupport(targetFolder, junitVer, templateParams);
TestCreator testCreator = new TestCreator(params, junitVer);
final ClasspathInfo cpInfo = ClasspathInfo.create(targetRootFolder);
List testClassNames = JUnitTestUtil.getJavaFileNames(targetFolder,
cpInfo);
final String templateId;
switch (junitVer) {
case JUNIT3:
templateId = "PROP_junit3_testSuiteTemplate"; //NOI18N
break;
case JUNIT4:
templateId = "PROP_junit4_testSuiteTemplate"; //NOI18N
break;
case JUNIT5:
// JUnit5 doesnt support Suites except via their Vintage engine
templateId = "PROP_junit5_testSuiteTemplate"; //NOI18N
break;
default:
assert false;
templateId = null;
break;
}
final DataObject doSuiteTempl
= loadTestTemplate(templateId);
if (doSuiteTempl == null) {
return null;
}
DataObject suiteDataObj;
try {
return createSuiteTest(targetFolder,
suiteName,
testCreator,
templateParams,
doSuiteTempl,
cpInfo.getClassPath(PathKind.SOURCE),
new LinkedList(testClassNames),
null, //parent suite
null); //progress indicator
} catch (CreationError ex) {
return null;
}
}
/**
*/
private static DataObject createTestClass(
ClassPath testCp,
ClassPath cp,
String testClassName,
DataObject templateDataObj,
final Map templateParams)
throws DataObjectNotFoundException,
IOException {
FileObject root = testCp.getRoots()[0];
// #176958 : decide in which Classpath root folder the new Suite file will be generated
// as there exist 2 or more source/test root sources
String rootFolderName = ""; //NOI18N
if (testCp.getRoots().length > 1 || (cp != null && cp.getRoots().length > 1)) {
int indexFirst = testClassName.indexOf('/');
rootFolderName = testClassName.substring(0, indexFirst);
testClassName = testClassName.substring(indexFirst + 1);
for (int i = 0; i < testCp.getRoots().length; i++) {
FileObject rootFO = testCp.getRoots()[i];
if (rootFO.getPath().endsWith(rootFolderName)) {
root = rootFO;
}
}
}
int index = testClassName.lastIndexOf('/');
String pkg = index > -1 ? testClassName.substring(0, index)
: ""; //NOI18N
String clazz = index > -1 ? testClassName.substring(index+1)
: testClassName;
// create package if it does not exist
if (pkg.length() > 0) {
root = FileUtil.createFolder(root, pkg); //IOException
}
// instantiate template into the package
return templateDataObj.createFromTemplate( //IOException
DataFolder.findFolder(root),
clazz,
templateParams);
}
/**
* Determines whether annotations should be used in test classes in the
* given folder when generating the given type of JUnit tests.
* If annotations are supported, adds this information to the map of
* template parameters.
*
* @param testFolder target folder for generated test classes
* @param junitVer type of generated JUnit tests
* @param templateParams map of template params to store
* the information to
* @return {@literal true} if it was detected that annotations are supported;
* {@literal false} otherwise
*/
private static boolean setAnnotationsSupport(
FileObject testFolder,
JUnitVersion junitVer,
Map templateParams) {
if (!testFolder.isFolder()) {
throw new IllegalArgumentException("not a folder"); //NOI18N
}
final boolean supported;
switch (junitVer) {
case JUNIT3:
supported = JUnitTestUtil.areAnnotationsSupported(testFolder);
break;
case JUNIT4:
supported = true;
break;
case JUNIT5:
supported = true;
break;
default:
supported = false;
break;
}
if (supported) {
templateParams.put(templatePropUseAnnotations, supported);
}
return supported;
}
/**
*
*/
private static void save(DataObject dataObj) throws IOException {
Savable sc = dataObj.getLookup().lookup(Savable.class);
if (null != sc) {
sc.save();
}
}
/**
* Loads a test template.
* If the template loading fails, displays an error message.
*
* @param templateID bundle key identifying the template type
* @return loaded template, or null if the template
* could not be loaded
*/
private static DataObject loadTestTemplate(String templateID) {
// get the Test class template
String path = NbBundle.getMessage(DefaultPlugin.class,
templateID);
try {
FileObject fo = FileUtil.getConfigFile(path);
if (fo == null) {
noTemplateMessage(path);
return null;
}
return DataObject.find(fo);
}
catch (DataObjectNotFoundException e) {
noTemplateMessage(path);
return null;
}
}
/**
*
*/
private static void noTemplateMessage(String temp) {
String msg = NbBundle.getMessage(
DefaultPlugin.class,
"MSG_template_not_found", //NOI18N
temp);
NotifyDescriptor descr = new NotifyDescriptor.Message(
msg,
NotifyDescriptor.ERROR_MESSAGE);
DialogDisplayer.getDefault().notify(descr);
}
/**
* A helper method to create the reason string from a result
* and two message bundle keys that indicate the separators to be used instead
* of "," and " and " in a connected reason like:
* "abstract, package-private and without testable methods".
*
* The values of the keys are expected to be framed by two extra characters
* (e.g. as in " and "), which are stripped off. These characters serve to
* preserve the spaces in the properties file.
*
* @param reason the TestabilityResult to represent
* @param commaKey bundle key for the connective to be used instead of ", "
* @param andKey bundle key for the connective to be used instead of "and"
* @return String composed of the reasons contained in
* reason separated by the values of commaKey and
* andKey.
*/
private static String strReason(TestabilityResult reason, String commaKey, String andKey) {
String strComma = NbBundle.getMessage(DefaultPlugin.class,commaKey);
String strAnd = NbBundle.getMessage(DefaultPlugin.class,andKey);
String strReason = reason.getReason( // string representation of the reasons
strComma.substring(1, strComma.length()-1),
strAnd.substring(1, strAnd.length()-1));
return strReason;
}
/**
*
*/
private static String getCreatingMsg(String className) {
return NbBundle.getMessage(
DefaultPlugin.class,
"FMT_generator_status_creating", //NOI18N
className);
}
/**
*
*/
private static String getScanningMsg(String sourceName) {
return NbBundle.getMessage(
DefaultPlugin.class,
"FMT_generator_status_scanning", //NOI18N
sourceName);
}
/**
*
*/
private static String getIgnoringMsg(String sourceName, String reason) {
return NbBundle.getMessage(
DefaultPlugin.class,
"FMT_generator_status_ignoring", //NOI18N
sourceName);
}
private JUnitVersion useVersion() {
if (generateVersion != null) {
return generateVersion;
}
return junitVer;
}
/**
* Error thrown by failed test creation.
*/
@SuppressWarnings("serial")
private static final class CreationError extends Exception {
CreationError() {};
CreationError(Throwable cause) {
super(cause);
}
}
/**
* Utility class representing the results of a test creation
* process. It gatheres all tests (as DataObject) created and all
* classes (as JavaClasses) for which no test was created.
*/
static final class CreationResults {
static final CreationResults EMPTY = new CreationResults();
Set created; // Set< createdTest : DataObject >
Set skipped;
boolean abborted = false;
CreationResults() { this(20);}
CreationResults(int expectedSize) {
created = new HashSet(expectedSize * 2, 0.5f);
skipped = new HashSet(expectedSize * 2, 0.5f);
}
void setAbborted() {
abborted = true;
}
/**
* Returns true if the process of creation was abborted. The
* result contains the results gathered so far.
*/
boolean isAbborted() {
return abborted;
}
/**
* Adds a new entry to the set of created tests.
* @return true if it was added, false if it was present before
*/
boolean addCreated(DataObject test) {
return created.add(test);
}
/**
*/
boolean addSkipped(SkippedClass skippedClass) {
return skipped.add(skippedClass);
}
/**
*/
void addSkipped(Collection skippedClasses) {
if (!skippedClasses.isEmpty()) {
skipped.addAll(skippedClasses);
}
}
/**
* Returns a set of classes that were skipped in the process.
* @return Set
*/
Set getSkipped() {
return skipped;
}
/**
* Returns a set of test data objects created.
* @return Set
*/
Set getCreated() {
return created;
}
/**
* Combines two results into one. If any of the results is an
* abborted result, the combination is also abborted. The
* collections of created and skipped classes are unified.
* @param rhs the other CreationResult to combine into this
*/
void combine(CreationResults rhs) {
if (rhs.abborted) {
this.abborted = true;
}
this.created.addAll(rhs.created);
this.skipped.addAll(rhs.skipped);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy