--- /dev/null
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed 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 util;
+
+import dxc.junit.AllTests;
+
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+import junit.textui.TestRunner;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.Map.Entry;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Main class to generate data from the test suite to later run from a shell
+ * script. the project's home folder.<br>
+ * <project-home>/src must contain the java sources<br>
+ * <project-home>/data/scriptdata will be generated<br>
+ * <project-home>/src/<for-each-package>/Main_testN1.java will be generated<br>
+ * (one Main class for each test method in the Test_... class
+ */
+public class CollectAllTests {
+
+ private static String PROJECT_FOLDER = "";
+ private static String PROJECT_FOLDER_OUT = "missing out folder!";
+ private static String JAVASRC_FOLDER = PROJECT_FOLDER + "/src";
+ private static HashSet<String> OPCODES = null;
+
+ /*
+ * a map. key: fully qualified class name, value: a list of test methods for
+ * the given class
+ */
+ private TreeMap<String, List<String>> map = new TreeMap<String, List<String>>();
+
+ private int testClassCnt = 0;
+ private int testMethodsCnt = 0;
+
+ private class MethodData {
+ String methodBody, constraint, title;
+ }
+
+ /**
+ * @param args
+ * args 0 must be the project root folder (where src, lib etc.
+ * resides)
+ * args 1 must be the project out root folder (where the Main_*.java files
+ * are put, and also data/scriptdata)
+ */
+ public static void main(String[] args) {
+ if (args.length >= 2) {
+ PROJECT_FOLDER = args[0];
+ PROJECT_FOLDER_OUT = args[1];
+ JAVASRC_FOLDER = PROJECT_FOLDER + "/src";
+ } else {
+ System.out.println("usage: args 0 must be the project root folder (where src, lib etc. resides)" +
+ "and args 1 must be the project out root folder (where the Main_*.java file" +
+ " are put, and also data/scriptdata)");
+ return;
+ }
+
+
+ for (int i = 2; i < args.length; i++) {
+ if (OPCODES == null) {
+ OPCODES = new HashSet<String>();
+ }
+ OPCODES.add(args[i]);
+ }
+
+ System.out.println("using java src:"+JAVASRC_FOLDER);
+ CollectAllTests cat = new CollectAllTests();
+ cat.compose();
+ }
+
+ public void compose() {
+ System.out.println("Collecting all junit tests...");
+ new TestRunner() {
+ @Override
+ protected TestResult createTestResult() {
+ return new TestResult() {
+ @Override
+ protected void run(TestCase test) {
+ addToTests(test);
+ }
+
+ };
+ }
+ }.doRun(AllTests.suite());
+
+ // for each combination of TestClass and method, generate a Main_testN1
+ // etc.
+ // class in the respective package.
+ // for the report make sure all N... tests are called first, then B,
+ // then
+ // E, then VFE test methods.
+ // so we need x Main_xxxx methods in a package, and x entries in the
+ // global scriptdata file (read by a bash script for the tests)
+ // e.g. dxc.junit.opcodes.aaload.Test_aaload - testN1() ->
+ // File Main_testN1.java in package dxc.junit.opcodes.aaload
+ // and entry dxc.junit.opcodes.aaload.Main_testN1 in class execution
+ // table.
+ //
+ handleTests();
+ }
+
+ private void addToTests(TestCase test) {
+
+ String packageName = test.getClass().getPackage().getName();
+ packageName = packageName.substring(packageName.lastIndexOf('.')+1);
+ if (OPCODES != null && !OPCODES.contains(packageName)) {
+ return;
+ }
+
+
+ String method = test.getName(); // e.g. testVFE2
+ String fqcn = test.getClass().getName(); // e.g.
+ // dxc.junit.opcodes.iload_3.Test_iload_3
+ // order: take the order of the test-suites for the classes,
+ // TODO and for methods: take Nx, then Bx, then Ex, then VFEx
+ //System.out.println("collecting test:" + test.getName() + ", class "
+ // + test.getClass().getName());
+ testMethodsCnt++;
+ List<String> li = map.get(fqcn);
+ if (li == null) {
+ testClassCnt++;
+ li = new ArrayList<String>();
+ map.put(fqcn, li);
+ }
+ li.add(method);
+ }
+
+ private void handleTests() {
+ System.out.println("collected "+testMethodsCnt+" test methods in "+testClassCnt+" junit test classes");
+ String datafileContent = "";
+
+ for (Entry<String, List<String>> entry : map.entrySet()) {
+
+ String fqcn = entry.getKey();
+ int lastDotPos = fqcn.lastIndexOf('.');
+ String pName = fqcn.substring(0, lastDotPos);
+ String classOnlyName = fqcn.substring(lastDotPos + 1);
+ String instPrefix = "new " + classOnlyName + "()";
+
+ String[] nameParts = pName.split("\\.");
+ if (nameParts.length != 4) {
+ throw new RuntimeException(
+ "package name does not comply to naming scheme: " + pName);
+ }
+
+
+ List<String> methods = entry.getValue();
+ Collections.sort(methods, new Comparator<String>() {
+ public int compare(String s1, String s2) {
+ // TODO sort according: test ... N, B, E, VFE
+ return s1.compareTo(s2);
+ }
+ });
+ for (String method : methods) {
+ // e.g. testN1
+ if (!method.startsWith("test")) {
+ throw new RuntimeException("no test method: " + method);
+ }
+
+ // generate the Main_xx java class
+
+ // a Main_testXXX.java contains:
+ // package <packagenamehere>;
+ // public class Main_testxxx {
+ // public static void main(String[] args) {
+ // new dxc.junit.opcodes.aaload.Test_aaload().testN1();
+ // }
+ // }
+
+ MethodData md = parseTestMethod(pName, classOnlyName, method);
+ String methodContent = md.methodBody;
+
+ Set<String> dependentTestClassNames = parseTestClassName(pName,
+ classOnlyName, methodContent);
+
+ if (dependentTestClassNames.isEmpty())
+ {
+ continue;
+ }
+
+
+ String content = "//autogenerated by "
+ + this.getClass().getName()
+ + ", do not change\n"
+ + "package "
+ + pName
+ + ";\n"
+ + "import "
+ + pName
+ + ".jm.*;\n"
+ + "import dxc.junit.*;\n"
+ + "public class Main_"
+ + method
+ + " extends DxAbstractMain {\n"
+ + "public static void main(String[] args) throws Exception {\n"
+ + "new Main_" + method + "()." + method + "();\n"
+ + "}\n" + methodContent + "\n}\n";
+
+ writeToFile(getFileFromPackage(pName, method), content);
+
+ // prepare the entry in the data file for the bash script.
+ // e.g.
+ // main class to execute; opcode/constraint; test purpose
+ // dxc.junit.opcodes.aaload.Main_testN1;aaload;normal case test
+ // (#1)
+
+ char ca = method.charAt("test".length()); // either N,B,E, oradd_double
+ // V (VFE)
+ String comment;
+ switch (ca) {
+ case 'N':
+ comment = "Normal #" + method.substring(5);
+ break;
+ case 'B':
+ comment = "Boundary #" + method.substring(5);
+ break;
+ case 'E':
+ comment = "Exception #" + method.substring(5);
+ break;
+ case 'V':
+ comment = "Verifier #" + method.substring(7);
+ break;
+ default:
+ throw new RuntimeException("unknown test abbreviation:"
+ + method + " for " + fqcn);
+ }
+
+ String opcConstr = pName.substring(pName.lastIndexOf('.') + 1);
+ // beautify test title
+ if (opcConstr.startsWith("t4")) {
+ opcConstr = "verifier"; // + opcConstr.substring(1);
+ } else if (opcConstr.startsWith("pargs")) {
+ opcConstr = "sanity";
+ } else if (opcConstr.startsWith("opc_")) {
+ // unescape reserved words
+ opcConstr = opcConstr.substring(4);
+ }
+
+ String line = pName + ".Main_" + method + ";";
+ for (String className : dependentTestClassNames) {
+ try {
+ Class.forName(className);
+ } catch (ClassNotFoundException e) {
+ throw new RuntimeException(
+ "dependent class not found : " + className);
+ } catch (Throwable e) {
+ // ignore
+ }
+
+ line += className + " ";
+ }
+
+ String details = (md.title != null ? md.title : "");
+ if (md.constraint != null) {
+ details = "Constraint " + md.constraint + ", " + details;
+ }
+ if (details.length() != 0) {
+ details = details.substring(0, 1).toUpperCase()
+ + details.substring(1);
+ }
+
+ line += ";" + opcConstr + ";"+ comment + ";" + details;
+
+ datafileContent += line + "\n";
+
+ }
+
+
+ }
+ new File(PROJECT_FOLDER_OUT + "/data").mkdirs();
+ writeToFile(new File(PROJECT_FOLDER_OUT + "/data/scriptdata"),
+ datafileContent);
+ }
+
+
+
+ /**
+ *
+ * @param pName
+ * @param classOnlyName
+ * @param methodSource
+ * @return a set
+ */
+ private Set<String> parseTestClassName(String pName, String classOnlyName,
+ String methodSource) {
+ Set<String> entries = new HashSet<String>();
+ String opcodeName = classOnlyName.substring(5);
+
+ Scanner scanner = new Scanner(methodSource);
+
+ String[] patterns = new String[] {
+ "new\\s(T_" + opcodeName + "\\w*)",
+ "(T_" + opcodeName + "\\w*)", "new\\s(T\\w*)"};
+
+ String token = null;
+ for (String pattern : patterns) {
+ token = scanner.findWithinHorizon(pattern, methodSource.length());
+ if (token != null) {
+ break;
+ }
+ }
+
+ if (token == null) {
+ System.err.println("warning: failed to find dependent test class name: "+pName+", "+classOnlyName);
+ return entries;
+ }
+
+ MatchResult result = scanner.match();
+
+ entries.add((pName + ".jm." + result.group(1)).trim());
+
+ // search additional @uses directives
+ Pattern p = Pattern.compile("@uses\\s+(.*)\\s+", Pattern.MULTILINE);
+ Matcher m = p.matcher(methodSource);
+ while (m.find()) {
+ String res = m.group(1);
+ entries.add(res.trim());
+ }
+
+ //lines with the form @uses dx.junit.opcodes.add_double.jm.T_add_double_2
+ // one dependency per one @uses
+ //TODO
+
+ return entries;
+ }
+
+ private MethodData parseTestMethod(String pname, String classOnlyName,
+ String method) {
+
+ String path = pname.replaceAll("\\.", "/");
+ String absPath = JAVASRC_FOLDER + "/" + path + "/" + classOnlyName
+ + ".java";
+ File f = new File(absPath);
+
+ Scanner scanner;
+ try {
+ scanner = new Scanner(f);
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException("error while reading from file: "
+ + e.getClass().getName() + ", msg:" + e.getMessage());
+ }
+
+ String methodPattern = "public\\s+void\\s+" + method + "[^\\{]+\\{";
+
+ String token = scanner.findWithinHorizon(methodPattern, (int) f
+ .length());
+ if (token == null) {
+ throw new RuntimeException(
+ "cannot find method source of 'public void" + method
+ + "' in file '" + absPath + "'");
+ }
+
+ MatchResult result = scanner.match();
+ result.start();
+ result.end();
+
+ StringBuilder builder = new StringBuilder();
+ builder.append(token);
+
+ try {
+ FileReader reader = new FileReader(f);
+ reader.skip(result.end());
+
+ char currentChar;
+ int blocks = 1;
+ while ((currentChar = (char) reader.read()) != -1 && blocks > 0) {
+ switch (currentChar) {
+ case '}': {
+ blocks--;
+ builder.append(currentChar);
+ break;
+ }
+ case '{': {
+ blocks++;
+ builder.append(currentChar);
+ break;
+ }
+ default: {
+ builder.append(currentChar);
+ break;
+ }
+ }
+ }
+ if (reader != null) {
+ reader.close();
+ }
+ } catch (Exception e) {
+ throw new RuntimeException("failed to parse", e);
+ }
+
+ // find the @title/@constraint in javadoc comment for this method
+ Scanner scanner2;
+ try {
+ // using platform's default charset
+ scanner2 = new Scanner(f);
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException("error while reading from file: "
+ + e.getClass().getName() + ", msg:" + e.getMessage());
+ }
+
+ // using platform's default charset
+ String all = new String(readFile(f));
+ // System.out.println("grepping javadoc found for method "+method +
+ // " in "+pname+","+classOnlyName);
+ String commentPattern = "/\\*\\*([^{]*)\\*/\\s*" + methodPattern;
+ Pattern p = Pattern.compile(commentPattern, Pattern.DOTALL);
+ Matcher m = p.matcher(all);
+ String title = null, constraint = null;
+ if (m.find()) {
+ String res = m.group(1);
+ // System.out.println("res: "+res);
+ // now grep @title and @constraint
+ Matcher titleM = Pattern.compile("@title (.*)", Pattern.DOTALL)
+ .matcher(res);
+ if (titleM.find()) {
+ title = titleM.group(1).replaceAll("\\n \\*", "");
+ title = title.replaceAll("\\n", " ");
+ title = title.trim();
+ // System.out.println("title: " + title);
+ } else {
+ System.err.println("warning: no @title found for method "
+ + method + " in " + pname + "," + classOnlyName);
+ }
+ // constraint can be one line only
+ Matcher constraintM = Pattern.compile("@constraint (.*)").matcher(
+ res);
+ if (constraintM.find()) {
+ constraint = constraintM.group(1);
+ constraint = constraint.trim();
+ // System.out.println("constraint: " + constraint);
+ } else if (method.contains("VFE")) {
+ System.err
+ .println("warning: no @constraint for for a VFE method:"
+ + method + " in " + pname + "," + classOnlyName);
+ }
+ } else {
+ System.err.println("warning: no javadoc found for method " + method
+ + " in " + pname + "," + classOnlyName);
+ }
+ MethodData md = new MethodData();
+ md.methodBody = builder.toString();
+ md.constraint = constraint;
+ md.title = title;
+ if (scanner != null) {
+ scanner.close();
+ }
+ if (scanner2 != null) {
+ scanner2.close();
+ }
+ return md;
+ }
+
+ private void writeToFile(File file, String content) {
+ //System.out.println("writing file " + file.getAbsolutePath());
+ try {
+ BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
+ new FileOutputStream(file), "utf-8"));
+ bw.write(content);
+ bw.close();
+ } catch (Exception e) {
+ throw new RuntimeException("error while writing to file: "
+ + e.getClass().getName() + ", msg:" + e.getMessage());
+ }
+ }
+
+ private File getFileFromPackage(String pname, String methodName) {
+ // e.g. dxc.junit.argsreturns.pargsreturn
+ String path = pname.replaceAll("\\.", "/");
+ String absPath = PROJECT_FOLDER_OUT + "/" + path;
+ new File(absPath).mkdirs();
+ return new File(absPath + "/Main_" + methodName + ".java");
+ }
+
+ private byte[] readFile(File file) {
+ int len = (int) file.length();
+ byte[] res = new byte[len];
+ try {
+ FileInputStream in = new FileInputStream(file);
+ int pos = 0;
+ while (len > 0) {
+ int br = in.read(res, pos, len);
+ if (br == -1) {
+ throw new RuntimeException("unexpected EOF for file: "+file);
+ }
+ pos += br;
+ len -= br;
+ }
+ in.close();
+ } catch (IOException ex) {
+ throw new RuntimeException("error reading file:"+file, ex);
+ }
+ return res;
+ }
+}
OSDN Git Service
