Test history refactoring and improvements

pom.xml

@@ -181,11 +181,27 @@
             <groupId>org.jenkins-ci.plugins</groupId>
             <artifactId>jackson2-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.pivovarit</groupId>
+            <artifactId>parallel-collectors</artifactId>
+            <version>2.6.1</version>
+        </dependency>
         <dependency>
             <groupId>org.jenkins-ci.plugins</groupId>
             <artifactId>pipeline-utility-steps</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>ca.umontreal.iro.simul</groupId>
+            <artifactId>ssj</artifactId>
+            <version>3.3.1</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.google.code.gson</groupId>
+                    <artifactId>gson</artifactId>
+                </exclusion>
+            </exclusions> 
+        </dependency>
     </dependencies>
     <dependencyManagement>
         <dependencies>

src/main/java/hudson/tasks/junit/CaseResult.java

@@ -51,11 +51,15 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
 /**
  * One test result.
  *
@@ -65,7 +69,7 @@
  */
 public class CaseResult extends TestResult implements Comparable<CaseResult> {
     private static final Logger LOGGER = Logger.getLogger(CaseResult.class.getName());
-    private final float duration;
+    private float duration;
     /**
      * Start time in epoch milliseconds - default is -1 for unset
      */
@@ -74,17 +78,18 @@
      * In JUnit, a test is a method of a class. This field holds the fully qualified class name
      * that the test was in.
      */
-    private final String className;
+    private String className;
     /**
      * This field retains the method name.
      */
-    private final String testName;
+    private String testName;
     private transient String safeName;
-    private final boolean skipped;
-    private final String skippedMessage;
-    private final String errorStackTrace;
-    private final String errorDetails;
-    private final Map<String, String> properties;
+    private boolean skipped;
+    private boolean keepTestNames;
+    private String skippedMessage;
+    private String errorStackTrace;
+    private String errorDetails;
+    private Map<String, String> properties;
     @SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "Specific method to restore it")
     private transient SuiteResult parent;
 
@@ -98,14 +103,14 @@
      * If these information are reported at the test case level, these fields are set,
      * otherwise null, in which case {@link SuiteResult#stdout}.
      */
-    private final String stdout,stderr;
+    private String stdout,stderr;
 
     /**
      * This test has been failing since this build number (not id.)
      *
      * If {@link #isPassed() passing}, this field is left unused to 0.
      */
-    private /*final*/ int failedSince;
+    private int failedSince;
 
     private static float parseTime(Element testCase) {
         String time = testCase.attributeValue("time");
@@ -138,6 +143,7 @@
         this.skipped = false;
         this.skippedMessage = null;
         this.properties = Collections.emptyMap();
+        this.keepTestNames = false;
     }
 
     @Restricted(Beta.class)
@@ -165,14 +171,15 @@
         this.skipped = skippedMessage != null;
         this.skippedMessage = skippedMessage;
         this.properties = Collections.emptyMap();
+        this.keepTestNames = false;
     }
 
     @Deprecated
-    CaseResult(SuiteResult parent, Element testCase, String testClassName, boolean keepLongStdio, boolean keepProperties) {
-        this(parent, testCase, testClassName, StdioRetention.fromKeepLongStdio(keepLongStdio), keepProperties);
+    CaseResult(SuiteResult parent, Element testCase, String testClassName, boolean keepLongStdio, boolean keepProperties, boolean keepTestNames) {
+        this(parent, testCase, testClassName, StdioRetention.fromKeepLongStdio(keepLongStdio), keepProperties, keepTestNames);
     }
 
-    CaseResult(SuiteResult parent, Element testCase, String testClassName, StdioRetention stdioRetention, boolean keepProperties) {
+    CaseResult(SuiteResult parent, Element testCase, String testClassName, StdioRetention stdioRetention, boolean keepProperties, boolean keepTestNames) {
         // schema for JUnit report XML format is not available in Ant,
         // so I don't know for sure what means what.
         // reports in http://www.nabble.com/difference-in-junit-publisher-and-ant-junitreport-tf4308604.html#a12265700
@@ -200,7 +207,7 @@
         errorStackTrace = getError(testCase);
         errorDetails = getErrorMessage(testCase);
         this.parent = parent;
-        duration = parseTime(testCase);
+        duration = clampDuration(parseTime(testCase));
         this.startTime = -1;
         skipped = isMarkedAsSkipped(testCase);
         skippedMessage = getSkippedMessage(testCase);
@@ -226,6 +233,138 @@
             }
         }
         this.properties = properties;
+        this.keepTestNames = keepTestNames;
+    }
+
+    public CaseResult(CaseResult src) {
+        this.duration = src.duration;
+        this.className = src.className;
+        this.testName = src.testName;
+        this.skippedMessage = src.skippedMessage;
+        this.skipped = src.skipped;
+        this.keepTestNames = src.keepTestNames;
+        this.errorStackTrace = src.errorStackTrace;
+        this.errorDetails = src.errorDetails;
+        this.failedSince = src.failedSince;
+        this.stdout = src.stdout;
+        this.stderr = src.stderr;
+        this.properties = new HashMap<>();
+        this.properties.putAll(src.properties);
+    }
+
+    public static float clampDuration(float d) {
+        return Math.min(365.0f * 24 * 60 * 60, Math.max(0.0f, d));
+    }
+
+    public static CaseResult parse(SuiteResult parent, final XMLStreamReader reader, String ver) throws XMLStreamException {
+        CaseResult r = new CaseResult(parent, null, null, null);
+        while (reader.hasNext()) {
+            final int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("case")) {
+                return r;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                final String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "duration":
+                        r.duration = clampDuration(new TimeToFloat(reader.getElementText()).parse());
+                        break;
+                    case "startTime":
+                        r.startTime = Long.parseLong(reader.getElementText());
+                        break;
+                    case "className":
+                        r.className = reader.getElementText();
+                        break;
+                    case "testName":
+                        r.testName = reader.getElementText();
+                        break;
+                    case "skippedMessage":
+                        r.skippedMessage = reader.getElementText();
+                        break;
+                    case "skipped":
+                        r.skipped = Boolean.parseBoolean(reader.getElementText());
+                        break;
+                    case "keepTestNames":
+                        r.keepTestNames = Boolean.parseBoolean(reader.getElementText());
+                        break;
+                    case "errorStackTrace":
+                        r.errorStackTrace = reader.getElementText();
+                        break;
+                    case "errorDetails":
+                        r.errorDetails = reader.getElementText();
+                        break;
+                    case "failedSince":
+                        r.failedSince = Integer.parseInt(reader.getElementText());
+                        break;
+                    case "stdout":
+                        r.stdout = reader.getElementText();
+                        break;
+                    case "stderr":
+                        r.stderr = reader.getElementText();
+                        break;
+                    case "properties":
+                        r.properties = new HashMap<>();
+                        parseProperties(r.properties, reader, ver);
+                        break;
+                    default:
+                        if (LOGGER.isLoggable(Level.FINEST)) {
+                            LOGGER.finest("CaseResult.parse encountered an unknown field: " + elementName);
+                        }
+                }
+            }
+        }
+        return r;
+    }
+
+    public static void parseProperties(Map<String, String> r, final XMLStreamReader reader, String ver) throws XMLStreamException {
+        while (reader.hasNext()) {
+            final int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("properties")) {
+                return;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                final String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "entry":
+                        parseProperty(r, reader, ver);
+                        break;
+                    default:
+                        if (LOGGER.isLoggable(Level.FINEST)) {
+                            LOGGER.finest("CaseResult.parseProperties encountered an unknown field: " + elementName);
+                        }
+                }
+            }
+        }
+    }
+
+    public static void parseProperty(Map<String, String> r, final XMLStreamReader reader, String ver) throws XMLStreamException {
+        String name = null, value = null;
+        while (reader.hasNext()) {
+            final int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("entry")) {
+                if (name != null && value != null) {
+                    r.put(name, value);
+                }
+                return;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                final String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "string":
+                        if (name == null) {
+                            name = reader.getElementText();
+                        } else {
+                            value = reader.getElementText();
+                        }
+                        break;
+                    default:
+                        if (LOGGER.isLoggable(Level.FINEST)) {
+                            LOGGER.finest("CaseResult.parseProperty encountered an unknown field: " + elementName);
+                        }
+                }
+            }
+        }
+
     }
 
     static String possiblyTrimStdio(Collection<CaseResult> results, StdioRetention stdioRetention, String stdio) { // HUDSON-6516
@@ -354,7 +493,7 @@
     private String getNameWithEnclosingBlocks(String rawName) {
         // Only prepend the enclosing flow node names if there are any and the run this is in has multiple blocks directly containing
         // test results.
-        if (!getEnclosingFlowNodeNames().isEmpty()) {
+        if (!keepTestNames && !getEnclosingFlowNodeNames().isEmpty()) {
             Run<?, ?> r = getRun();
             if (r != null) {
                 TestResultAction action = r.getAction(TestResultAction.class);
@@ -579,15 +718,27 @@
         return getSuiteResult().getStderr();
     }
 
+    static int PREVIOUS_TEST_RESULT_BACKTRACK_BUILDS_MAX =
+        Integer.parseInt(System.getProperty(History.HistoryTableResult.class.getName() + ".PREVIOUS_TEST_RESULT_BACKTRACK_BUILDS_MAX","25"));
+
     @Override
     public CaseResult getPreviousResult() {
         if (parent == null) return null;
 
-        TestResult previousResult = parent.getParent().getPreviousResult();
-        if (previousResult == null) return null;
-        if (previousResult instanceof hudson.tasks.junit.TestResult) {
-            hudson.tasks.junit.TestResult pr = (hudson.tasks.junit.TestResult) previousResult;
-            return pr.getCase(parent.getName(), getTransformedFullDisplayName());
+        TestResult previousResult = parent.getParent();
+        int n = 0;
+        while (previousResult != null && n < PREVIOUS_TEST_RESULT_BACKTRACK_BUILDS_MAX) {
+            previousResult = previousResult.getPreviousResult();
+            if (previousResult == null) 
+                return null;
+            if (previousResult instanceof hudson.tasks.junit.TestResult) {
+	            hudson.tasks.junit.TestResult pr = (hudson.tasks.junit.TestResult) previousResult;
+                CaseResult cr = pr.getCase(parent.getName(), getTransformedFullDisplayName());
+                if (cr != null) {
+                    return cr;
+                }
+            }
+            ++n;
         }
         return null;
     }

src/main/java/hudson/tasks/junit/ClassResult.java

@@ -31,9 +31,7 @@
 import org.kohsuke.stapler.StaplerResponse;
 import org.kohsuke.stapler.export.Exported;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 /**
  * Cumulative test result of a test class.
@@ -44,7 +42,7 @@ public final class ClassResult extends TabulatedResult implements Comparable<Cla
     private final String className; // simple name
     private transient String safeName;
 
-    private final List<CaseResult> cases = new ArrayList<>();
+    private final Set<CaseResult> cases = new TreeSet<CaseResult>();
 
     private int passCount,failCount,skipCount;
 
@@ -146,7 +144,7 @@ public Object getDynamic(String name, StaplerRequest req, StaplerResponse rsp) {
 
     @Exported(name="child")
     @Override
-    public List<CaseResult> getChildren() {
+    public Collection<CaseResult> getChildren() {
         return cases;
     }
 
@@ -216,7 +214,6 @@ else if(r.isPassed()) {
 
     void freeze() {
         this.tally();
-        Collections.sort(cases);
     }
 
     public String getClassName() {