Java自动生成testcase
package com.citi.sl.tlc.services.tlc.collateralDataProcess.util;
import java.io.BufferedWriter;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.apache.commons.lang.RandomStringUtils;
import com.google.common.collect.Lists;
public class TestCaseGenerator {
private static final String FILE_SUFFIX_LOWERCASE = ".java";
private static final String FILE_SUFFIX_UPPERCASE = ".JAVA";
public static void main(String[] args) {
generateTestCaseFiles("C:\\Users\\pz27063\\git\\xx\\src\\main\\java\\");
}
/**
* Example1 :
* C:\\Users\\pz27063\\git\\tradelifecycle\\TLCCommon\\CommonExtract\\src\\main\\java
* Example2 :
* C:\\Users\\pz27063\\git\\tradelifecycle\\TLCCommon\\CommonExtract\\src\\main\\java\\com\\citi\\sl\\tlc\\common\\extract\\jobs\\eurexeligible
*
* @param projectAbsolutePath
*/
public static void generateTestCaseFiles(String projectAbsolutePath) {
List<String> folderList = getAllSubFolders(Paths.get(projectAbsolutePath));
if (folderList.isEmpty()) {
System.out.println("folder not exist or no files.");
}
folderList.forEach(sourceDir -> {
Path sourcePath = Paths.get(sourceDir);
String testFolderStr = sourceDir.replace("\\src\\main", "\\src\\test");
Path createdTestFolderPath = createTestCaseFolder(Paths.get(testFolderStr));
createTestCaseFile(sourcePath, createdTestFolderPath);
});
}
public static List<String> getAllSubFolders(Path path) {
List<String> folders = new ArrayList<>();
try {
if (path.toFile().isDirectory()) {
folders.add(path.toFile().getAbsolutePath());
Files.list(path).forEach(f -> {
List<String> subFolders = getAllSubFolders(f);
folders.addAll(subFolders);
});
}
} catch (IOException e) {
exitProcess(e);
}
return folders;
}
private static Path createTestCaseFolder(Path createTargetPath) {
try {
if (notExists(createTargetPath)) {
return Files.createDirectories(createTargetPath);
}
} catch (IOException e) {
exitProcess(e);
}
return createTargetPath;
}
private static void createTestCaseFile(Path sourcePath, Path testFolderPath) {
try {
Files.list(sourcePath).forEach(sourceFilePath -> {
if (sourceFilePath.toFile().isFile() && (sourceFilePath.toString().endsWith(FILE_SUFFIX_UPPERCASE)
|| sourceFilePath.toString().endsWith(FILE_SUFFIX_LOWERCASE))) {
buildTestClass(sourceFilePath, testFolderPath);
}
});
} catch (IOException e) {
exitProcess(e);
}
}
private static void buildTestClass(Path sourceFilePath, Path targetFolder) {
String className = sourceFilePath.getFileName().toString().replace(FILE_SUFFIX_LOWERCASE, "");
try {
Path newTestFilePath = targetFolder.resolve(className + "Test" + FILE_SUFFIX_LOWERCASE);
if (notExists(newTestFilePath)) {
String javaPath = convertPathToPackageClass(sourceFilePath);
Class<?> sourceClass = getSourceClass(javaPath);
if (isJavaBean(sourceClass)) {
newTestFilePath = Files.createFile(newTestFilePath);
writeJavaBeanTestClass(sourceClass, newTestFilePath);
System.out.println("JavaBean :" + newTestFilePath.toString() + " created.");
} else if (isNotAbstract(sourceClass) && isNotInterface(sourceClass) && isNotEnum(sourceClass)) {
newTestFilePath = Files.createFile(newTestFilePath);
writeTestClass(sourceClass, newTestFilePath);
System.out.println(newTestFilePath.toString() + " created.");
}
}
} catch (IOException e) {
exitProcess(e);
}
}
private static void writeTestClass(Class<?> sourceClass, Path newTestFilePath) {
String className = sourceClass.getSimpleName();
Set<String> methodNames = getClassPublicMethods(sourceClass);
Map<String, Object> methodMap = getMethodMap(sourceClass);
String packageLine = sourceClass.getPackage().toString();
BufferedWriter writer = null;
try {
writer = Files.newBufferedWriter(newTestFilePath);
StringBuilder fileBuilder = new StringBuilder();
fileBuilder.append(packageLine + ";\n");
fileBuilder.append("\n");
String importPackage = "import org.mockito.InjectMocks;\r\n" + "import org.mockito.MockitoAnnotations;\r\n"
+ "import org.junit.Before;\r\n" + "import org.junit.Test;";
fileBuilder.append(importPackage);
fileBuilder.append("\n");
fileBuilder.append("public class " + className + "Test{\n");
fileBuilder.append("\n");
fileBuilder.append("\t");
fileBuilder.append("@InjectMocks\n");
fileBuilder.append("\t");
fileBuilder.append("private " + className + " "
+ className.substring(0, 1).toLowerCase().concat(className.substring(1)) + ";\n");
fileBuilder.append(getInitMethodString());
for (String methodName : methodNames) {
fileBuilder.append(generateTestMethod(methodName, methodMap));
}
fileBuilder.append("\n\n}");
writer.write(fileBuilder.toString());
} catch (IOException e) {
exitProcess(e);
} finally {
if (null != writer) {
try {
writer.close();
} catch (IOException e) {
exitProcess(e);
}
}
}
}
private static void writeJavaBeanTestClass(Class<?> sourceClass, Path newTestFilePath) {
String className = sourceClass.getSimpleName();
String packageLine = sourceClass.getPackage().toString();
BufferedWriter writer = null;
try {
writer = Files.newBufferedWriter(newTestFilePath);
StringBuilder fileBuilder = new StringBuilder();
fileBuilder.append(packageLine + ";\n");
fileBuilder.append("\n");
fileBuilder.append(generateJavaBeanTestClass(sourceClass.getPackage().getName(), className));
writer.write(fileBuilder.toString());
} catch (IOException e) {
exitProcess(e);
} finally {
if (null != writer) {
try {
writer.close();
} catch (IOException e) {
exitProcess(e);
}
}
}
}
private static String generateJavaBeanTestClass(String packageName, String className) {
String packageImport = "import java.beans.PropertyDescriptor;\r\n" + "import java.lang.reflect.Field;\r\n"
+ "import java.lang.reflect.Method;\r\n" + "\r\n" + "import org.junit.Before;\r\n"
+ "import org.junit.Test;\r\n" + "import org.mockito.InjectMocks;\r\n"
+ "import org.mockito.MockitoAnnotations;\n";
String classBodyStart = "public class " + className + "Test{\n";
String method = " \r\n" + " @InjectMocks\r\n" + " private " + className + " "
+ className.substring(0, 1).toLowerCase().concat(className.substring(1, className.length())) + ";\r\n"
+ "\r\n" + " @Before\r\n" + " public void initMocks(){\r\n"
+ " MockitoAnnotations.initMocks(this);\r\n" + " }\r\n" + " @Test\r\n"
+ " public void testSetGetMethod() {\r\n" + " try {\r\n"
+ " Class<?> clazz = Class.forName(\"" + packageName + "." + className + "\");\r\n"
+ " Object obj = clazz.newInstance();\r\n"
+ " Field[] fields = clazz.getDeclaredFields();\r\n"
+ " for (Field f : fields) {\r\n" + " try {\r\n"
+ " PropertyDescriptor pd = new PropertyDescriptor(f.getName(), clazz);\r\n"
+ " Method writeMethod = pd.getWriteMethod();\r\n"
+ " writeMethod.invoke(obj, new Object[] { null });\r\n"
+ " Method readMethod = pd.getReadMethod();\r\n"
+ " readMethod.invoke(obj);\r\n" + " } catch (Exception e) {\r\n"
+ " System.out.println(e);\r\n" + " }\r\n" + " }\r\n"
+ " } catch (Exception e) {\r\n" + " System.out.println(e);\r\n" + " }\r\n" + "\r\n"
+ " }";
String classBodyEnd = "}";
StringBuilder builder = new StringBuilder();
builder.append(packageImport);
builder.append("\n\n");
builder.append(classBodyStart);
builder.append(method);
builder.append(classBodyEnd);
return builder.toString();
}
private static boolean isJavaBean(Class<?> sourceClass) {
String fullPackage = sourceClass.getPackage().getName().toLowerCase();
return (fullPackage.endsWith(".bean") || fullPackage.endsWith(".entity") || fullPackage.endsWith(".beans")
|| fullPackage.endsWith(".entities"));
}
private static String generateTestMethod(String methodName, Map<String, Object> methodMap) {
StringBuilder methodBuilder = new StringBuilder();
String className = (String) methodMap.get("className");
Object[] methodObj = (Object[]) methodMap.get(methodName);
Class<?> returnType = (Class<?>) methodObj[0];
Class[] paramTypes = (Class[]) methodObj[1];
List<Class<?>> paramTypeList = Arrays.asList(paramTypes);
List<String> paramTypeParam = Lists.newArrayList();
List<String> stringList = Lists.newArrayList("String");
List<String> intList = Lists.newArrayList("int", "Integer");
List<String> longList = Lists.newArrayList("Long", "long");
List<String> doubleList = Lists.newArrayList("Double", "double");
List<String> shortList = Lists.newArrayList("Short", "short");
List<String> floatList = Lists.newArrayList("Float", "float");
List<String> booleanList = Lists.newArrayList("boolean");
List<String> charList = Lists.newArrayList("Char", "char");
List<String> byteList = Lists.newArrayList("Byte", "byte");
for (Class<?> paramClass : paramTypeList) {
// String paramClsStr = paramClass.getSimpleName().toUpperCase();
String paramClsStr = paramClass.getSimpleName();
if (stringList.contains(paramClsStr)) {
paramTypeParam.add("\"" + RandomStringUtils.randomAlphabetic(3) + "\"");
} else if (intList.contains(paramClsStr)) {
paramTypeParam.add("0");
} else if (longList.contains(paramClsStr)) {
paramTypeParam.add("1L");
} else if (doubleList.contains(paramClsStr)) {
paramTypeParam.add("1D");
} else if (shortList.contains(paramClsStr)) {
paramTypeParam.add("1");
} else if (floatList.contains(paramClsStr)) {
paramTypeParam.add("1F");
} else if (booleanList.contains(paramClsStr)) {
paramTypeParam.add("true");
} else if (charList.contains(paramClsStr)) {
paramTypeParam.add("\'A\'");
} else if (byteList.contains(paramClsStr)) {
paramTypeParam.add("10");
} else {
if (paramClsStr instanceof Object && !paramClass.isEnum() && !paramClass.isInterface()
&& !paramClass.isArray()) {
paramTypeParam.add("new " + paramClass.getName() + "()");
} else {
paramTypeParam.add("null");
}
}
}
String paramStr = String.join(",", paramTypeParam);
String returnCode = "";
String returnClassName = returnType.getSimpleName();
if (!returnClassName.equals("void")) {
returnCode = returnType.getName() + " result = ";
}
String methodBody = "\t@Test\r\n" + " public void test"
+ methodName.substring(0, 1).toUpperCase().concat(methodName.substring(1)) + "(){\r\n" + "\t\ttry{\r\n"
+ "\t\t\t" + returnCode
+ className.substring(0, 1).toLowerCase().concat(className.substring(1, className.length())) + "."
+ methodName + "(" + paramStr + ");\r\n" + "\t\t}catch (Exception e) {\n\t\t}\n" + "\n\t}\n\n";
methodBuilder.append(methodBody);
return methodBuilder.toString();
}
private static String getInitMethodString() {
StringBuilder methodBuilder = new StringBuilder();
methodBuilder.append("\n");
methodBuilder.append("\t@Before\n");
methodBuilder.append("\t");
methodBuilder.append("public void initMocks(){\n");
methodBuilder.append("\t\tMockitoAnnotations.initMocks(this);\n");
methodBuilder.append("\t}");
methodBuilder.append("\n");
return methodBuilder.toString();
}
private static String convertPathToPackageClass(Path sourcePath) {
String fileName = "";
fileName = sourcePath.getFileName().toString().replace(".java", "");
String packageName = getPackageName(sourcePath);
return packageName + "." + fileName;
}
private static String getPackageName(Path sourcePath) {
try {
Optional<String> optional = Files.lines(sourcePath).findFirst();
if (optional.isPresent()) {
return optional.get().replace("package ", "").replace(";", "");
}
} catch (IOException e) {
exitProcess(e);
}
return "";
}
private static boolean isNotAbstract(Class<?> cls) {
return !Modifier.isAbstract(cls.getModifiers());
}
private static boolean isNotInterface(Class<?> cls) {
return !Modifier.isInterface(cls.getModifiers());
}
private static boolean isNotEnum(Class<?> cls) {
return !cls.isEnum();
}
private static Set<String> getClassPublicMethods(Class<?> cls) {
Set<String> methodSet = new HashSet<>();
Method[] publicMethods = cls.getDeclaredMethods();
for (Method m : publicMethods) {
if (Modifier.isPublic(m.getModifiers()) || Modifier.isProtected(m.getModifiers())) {
methodSet.add(m.getName());
}
}
return methodSet;
}
private static Map<String, Object> getMethodMap(Class<?> cls) {
Map<String, Object> methodMap = new HashMap<>();
Method[] publicMethods = cls.getDeclaredMethods();
for (Method m : publicMethods) {
if (Modifier.isPublic(m.getModifiers()) || Modifier.isProtected(m.getModifiers())) {
// Return type
Class<?> returnType = m.getReturnType();
// Method parameter
Class[] paramTypes = m.getParameterTypes();
Object[] methodObj = new Object[] { returnType, paramTypes };
methodMap.put(m.getName(), methodObj);
}
}
methodMap.put("className", cls.getSimpleName());
return methodMap;
}
private static Class<?> getSourceClass(String className) {
Class<?> cls = null;
try {
cls = Class.forName(className);
} catch (ClassNotFoundException e) {
exitProcess(e);
}
return cls;
}
private static void exitProcess(Exception e) {
e.printStackTrace();
System.exit(-1);
}
private static boolean notExists(Path path) {
return !exists(path);
}
private static boolean exists(Path path) {
return path.toFile().exists();
}
}
