simplify code

Signed-off-by: Olivier Lamy <[email protected]>

Author: olamy

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

@@ -84,8 +84,8 @@ public class CaseResult extends TestResult implements Comparable<CaseResult> {
     private String errorStackTrace;
     private String errorDetails;
     private Map<String, String> properties;
-    private List<FlakyFailure> flakyFailures;
-    private List<RerunFailure> rerunFailures;
+    private List<Failure> flakyFailures;
+    private List<Failure> rerunFailures;
 
     @SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "Specific method to restore it")
     private transient SuiteResult parent;
@@ -275,8 +275,8 @@ public static float clampDuration(float d) {
         return Math.min(365.0f * 24 * 60 * 60, Math.max(0.0f, d));
     }
 
-    private static List<FlakyFailure> parseFlakyFailures(Element testCase) {
-        List<FlakyFailure> flakyFailures = new ArrayList<>();
+    private static List<Failure> parseFlakyFailures(Element testCase) {
+        List<Failure> failures = new ArrayList<>();
         List<Element> flakyFailuresElements = testCase.elements("flakyFailure");
         if (flakyFailuresElements != null) {
             for (Element flakyFailuresElement : flakyFailuresElements) {
@@ -285,14 +285,14 @@ private static List<FlakyFailure> parseFlakyFailures(Element testCase) {
                 String stackTrace = flakyFailuresElement.elementText("stackTrace");
                 String stdout = flakyFailuresElement.elementText("system-out");
                 String stderr = flakyFailuresElement.elementText("system-err");
-                flakyFailures.add(new FlakyFailure(message, type, stackTrace, stdout, stderr));
+                failures.add(new Failure(message, type, stackTrace, stdout, stderr));
             }
         }
-        return flakyFailures;
+        return failures;
     }
 
-    private static List<RerunFailure> parseRerunFailures(Element testCase) {
-        List<RerunFailure> rerunFailures = new ArrayList<>();
+    private static List<Failure> parseRerunFailures(Element testCase) {
+        List<Failure> rerunFailures = new ArrayList<>();
         List<Element> rerunFailureElements = testCase.elements("rerunFailure");
         if (rerunFailureElements != null) {
             for (Element rerunFailureElement : rerunFailureElements) {
@@ -301,7 +301,7 @@ private static List<RerunFailure> parseRerunFailures(Element testCase) {
                 String stackTrace = rerunFailureElement.elementText("stackTrace");
                 String stdout = rerunFailureElement.elementText("system-out");
                 String stderr = rerunFailureElement.elementText("system-err");
-                rerunFailures.add(new RerunFailure(message, type, stackTrace, stdout, stderr));
+                rerunFailures.add(new Failure(message, type, stackTrace, stdout, stderr));
             }
         }
         return rerunFailures;
@@ -359,10 +359,10 @@ static CaseResult parse(SuiteResult parent, final XMLStreamReader reader, String
                         parseProperties(r.properties, reader, context, ver);
                         break;
                     case "flakyFailures":
-                        r.flakyFailures = parseFlakyFailures(reader, context, ver);
+                        r.flakyFailures = parseFailures(reader, context, "flakyFailures");
                         break;
                     case "rerunFailures":
-                        r.rerunFailures = parseRerunFailures(reader, context, ver);
+                        r.rerunFailures = parseFailures(reader, context, "rerunFailures");
                         break;
                     default:
                         LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
@@ -372,98 +372,35 @@ static CaseResult parse(SuiteResult parent, final XMLStreamReader reader, String
         return r;
     }
 
-    static List<FlakyFailure> parseFlakyFailures(final XMLStreamReader reader, String context, String ver)
+    static List<Failure> parseFailures(final XMLStreamReader reader, String context, String endElement)
             throws XMLStreamException {
-        List<FlakyFailure> flakyFailures = new ArrayList<>();
+        List<Failure> failures = new ArrayList<>();
         while (reader.hasNext()) {
             final int event = reader.next();
-            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("flakyFailures")) {
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals(endElement)) {
                 break;
             }
             if (event == XMLStreamReader.START_ELEMENT) {
                 final String elementName = reader.getLocalName();
-                switch (elementName) {
-                    case "flakyFailure":
-                        flakyFailures.add(parseFlakyFailure(reader, context, ver));
-                        break;
-                    default:
-                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
+                if (elementName.equals("failure")) {
+                    failures.add(parseFailure(reader, context));
+                } else {
+                    LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
                 }
             }
         }
-        return flakyFailures;
+        return failures;
     }
 
-    public static FlakyFailure parseFlakyFailure(XMLStreamReader reader, String context, String ver)
-            throws XMLStreamException {
-        String message = null;
-        String type = null;
-        String stackTrace = null;
-        String stdout = null;
-        String stderr = null;
-        while (reader.hasNext()) {
-            int event = reader.next();
-            if (event == XMLStreamReader.END_ELEMENT && "flakyFailure".equals(reader.getLocalName())) {
-                break;
-            }
-            if (event == XMLStreamReader.START_ELEMENT) {
-                String elementName = reader.getLocalName();
-                switch (elementName) {
-                    case "message":
-                        message = reader.getElementText();
-                        break;
-                    case "type":
-                        type = reader.getElementText();
-                        break;
-                    case "stackTrace":
-                        stackTrace = reader.getElementText();
-                        break;
-                    case "stdout":
-                        stdout = reader.getElementText();
-                        break;
-                    case "stderr":
-                        stderr = reader.getElementText();
-                        break;
-                    default:
-                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
-                }
-            }
-        }
-        return new FlakyFailure(message, type, stackTrace, stdout, stderr);
-    }
-
-    static List<RerunFailure> parseRerunFailures(final XMLStreamReader reader, String context, String ver)
-            throws XMLStreamException {
-        List<RerunFailure> rerunFailures = new ArrayList<>();
-        while (reader.hasNext()) {
-            final int event = reader.next();
-            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("rerunFailures")) {
-                break;
-            }
-            if (event == XMLStreamReader.START_ELEMENT) {
-                final String elementName = reader.getLocalName();
-                switch (elementName) {
-                    case "rerunFailure":
-                        rerunFailures.add(parseRerunFailure(reader, context, ver));
-                        break;
-                    default:
-                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
-                }
-            }
-        }
-        return rerunFailures;
-    }
-
-    public static RerunFailure parseRerunFailure(XMLStreamReader reader, String context, String ver)
-            throws XMLStreamException {
+    public static Failure parseFailure(XMLStreamReader reader, String context) throws XMLStreamException {
         String message = null;
         String type = null;
         String stackTrace = null;
         String stdout = null;
         String stderr = null;
         while (reader.hasNext()) {
             int event = reader.next();
-            if (event == XMLStreamReader.END_ELEMENT && "rerunFailure".equals(reader.getLocalName())) {
+            if (event == XMLStreamReader.END_ELEMENT && "failure".equals(reader.getLocalName())) {
                 break;
             }
             if (event == XMLStreamReader.START_ELEMENT) {
@@ -489,7 +426,7 @@ public static RerunFailure parseRerunFailure(XMLStreamReader reader, String cont
                 }
             }
         }
-        return new RerunFailure(message, type, stackTrace, stdout, stderr);
+        return new Failure(message, type, stackTrace, stdout, stderr);
     }
 
     static void parseProperties(Map<String, String> r, final XMLStreamReader reader, String context, String ver)
@@ -1206,13 +1143,13 @@ void replaceParent(SuiteResult parent) {
 
     @Exported
     @Override
-    public List<FlakyFailure> getFlakyFailures() {
+    public List<Failure> getFlakyFailures() {
         return flakyFailures == null ? Collections.emptyList() : Collections.unmodifiableList(flakyFailures);
     }
 
     @Exported
     @Override
-    public List<RerunFailure> getRerunFailures() {
+    public List<Failure> getRerunFailures() {
         return rerunFailures == null ? Collections.emptyList() : Collections.unmodifiableList(rerunFailures);
     }
 

…ava/hudson/tasks/junit/FlakyFailure.java …ain/java/hudson/tasks/junit/Failure.javasrc/main/java/hudson/tasks/junit/FlakyFailure.java renamed to src/main/java/hudson/tasks/junit/Failure.java src/main/java/hudson/tasks/junit/FlakyFailure.java renamed to src/main/java/hudson/tasks/junit/Failure.java

@@ -4,5 +4,5 @@
 import org.kohsuke.stapler.export.ExportedBean;
 
 @ExportedBean
-public record FlakyFailure(String message, String type, String stackTrace, String stdout, String stderr)
+public record Failure(String message, String type, String stackTrace, String stdout, String stderr)
         implements Serializable {}

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

@@ -427,8 +427,7 @@ public Widget getWidget() {
         XSTREAM.alias("result", TestResult.class);
         XSTREAM.alias("suite", SuiteResult.class);
         XSTREAM.alias("case", CaseResult.class);
-        XSTREAM.alias("flakyFailure", FlakyFailure.class);
-        XSTREAM.alias("rerunFailure", RerunFailure.class);
+        XSTREAM.alias("failure", Failure.class);
         XSTREAM.registerConverter(new HeapSpaceStringConverter(), 100);
     }
 }

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

@@ -26,8 +26,7 @@
 import hudson.model.Job;
 import hudson.model.Result;
 import hudson.model.Run;
-import hudson.tasks.junit.FlakyFailure;
-import hudson.tasks.junit.RerunFailure;
+import hudson.tasks.junit.Failure;
 import hudson.tasks.junit.TestAction;
 import java.util.Collection;
 import java.util.Collections;
@@ -266,11 +265,11 @@ public Map<String, String> getProperties() {
         return Collections.emptyMap();
     }
 
-    public List<FlakyFailure> getFlakyFailures() {
+    public List<Failure> getFlakyFailures() {
         return Collections.emptyList();
     }
 
-    public List<RerunFailure> getRerunFailures() {
+    public List<Failure> getRerunFailures() {
         return Collections.emptyList();
     }
 

src/main/java/hudson/tasks/test/TestResult.java

@@ -442,19 +442,19 @@ void bigResultReadWrite() throws Exception {
         TestResult tr = new TestResult();
         tr.getSuites().add(sr);
 
-        List<FlakyFailure> flakyFailures =
+        List<Failure> failures =
                 tr.getSuites().stream().map(SuiteResult::getCases).flatMap(Collection::stream).toList().stream()
                         .map(CaseResult::getFlakyFailures)
-                        .filter(failures -> !failures.isEmpty())
+                        .filter(flakyFailures -> !flakyFailures.isEmpty())
                         .flatMap(Collection::stream)
                         .toList();
 
-        assertEquals(2, flakyFailures.size());
-        assertNotNull(flakyFailures.get(0).message());
-        assertNotNull(flakyFailures.get(0).type());
-        assertNotNull(flakyFailures.get(0).stackTrace());
-        assertNotNull(flakyFailures.get(0).stdout());
-        assertNotNull(flakyFailures.get(0).stderr());
+        assertEquals(2, failures.size());
+        assertNotNull(failures.get(0).message());
+        assertNotNull(failures.get(0).type());
+        assertNotNull(failures.get(0).stackTrace());
+        assertNotNull(failures.get(0).stdout());
+        assertNotNull(failures.get(0).stderr());
 
         XmlFile f = new XmlFile(TestResultAction.XSTREAM, File.createTempFile("junitResult.xml", null, tmp));
         f.write(tr);
@@ -522,16 +522,16 @@ void includeFlakyAndRerun() throws Exception {
                             .size(),
                     "Wrong number of flayfailures");
 
-            FlakyFailure flakyFailure = flakySuiteResult
+            Failure failure = flakySuiteResult
                     .getCase("io.olamy.FlakyTest.testApp")
                     .getFlakyFailures()
                     .get(0);
-            assertNotNull(flakyFailure);
-            assertEquals("junit.framework.AssertionFailedError", flakyFailure.type());
-            assertEquals("obvious fail", flakyFailure.message());
-            assertTrue(flakyFailure.stackTrace().contains("at io.olamy.FlakyTest.testApp(FlakyTest.java:27)"));
-            assertEquals("this will fail maybe", flakyFailure.stdout().trim());
-            assertEquals("this will maybe fail", flakyFailure.stderr().trim());
+            assertNotNull(failure);
+            assertEquals("junit.framework.AssertionFailedError", failure.type());
+            assertEquals("obvious fail", failure.message());
+            assertTrue(failure.stackTrace().contains("at io.olamy.FlakyTest.testApp(FlakyTest.java:27)"));
+            assertEquals("this will fail maybe", failure.stdout().trim());
+            assertEquals("this will maybe fail", failure.stderr().trim());
 
             TestResult tr = new TestResult();
             tr.getSuites().add(flakySuiteResult);
@@ -577,7 +577,7 @@ void includeFlakyAndRerun() throws Exception {
                             .size(),
                     "Wrong number of rerun failures");
 
-            RerunFailure rerunFailure = rerunSuite
+            Failure rerunFailure = rerunSuite
                     .getCase("io.olamy.AlwaysFailTest.testApp")
                     .getRerunFailures()
                     .get(0);