Allow to configure the number of bytes to keep from stdout/stderr for passed/failed test.

Author: avaiss

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

@@ -106,7 +106,18 @@ private static float parseTime(Element testCase) {
         return 0.0f;
     }
 
+    /**
+     * @deprecated in favor of {@link #CaseResult(SuiteResult, Element, String, PluginConfig)}.
+     */
+    @Deprecated
     CaseResult(SuiteResult parent, Element testCase, String testClassName, boolean keepLongStdio) {
+        this(parent, testCase, testClassName, PluginConfig.defaults(keepLongStdio));
+    }
+
+    /**
+     * @since 1.6
+     */
+    CaseResult(SuiteResult parent, Element testCase, String testClassName, PluginConfig config) {
         // 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
@@ -139,41 +150,58 @@ private static float parseTime(Element testCase) {
         skippedMessage = getSkippedMessage(testCase);
         @SuppressWarnings("LeakingThisInConstructor")
         Collection<CaseResult> _this = Collections.singleton(this);
-        stdout = possiblyTrimStdio(_this, keepLongStdio, testCase.elementText("system-out"));
-        stderr = possiblyTrimStdio(_this, keepLongStdio, testCase.elementText("system-err"));
+        stdout = possiblyTrimStdio(_this, config, testCase.elementText("system-out"));
+        stderr = possiblyTrimStdio(_this, config, testCase.elementText("system-err"));
     }
 
-    static String possiblyTrimStdio(Collection<CaseResult> results, boolean keepLongStdio, String stdio) { // HUDSON-6516
+    static String possiblyTrimStdio(Collection<CaseResult> results, PluginConfig config, String stdio) { // HUDSON-6516
         if (stdio == null) {
             return null;
         }
-        if (keepLongStdio) {
+        if (config.isKeepLongStdio()) {
             return stdio;
         }
         int len = stdio.length();
-        int halfMaxSize = halfMaxSize(results);
-        int middle = len - halfMaxSize * 2;
+
+        int maxSize = config.getMaxSize(hasFailed(results));
+        if (maxSize < 0) {
+            return stdio;
+        }
+        if (maxSize == 0) {
+            return null;
+        }
+
+        int middle = len - maxSize;
         if (middle <= 0) {
             return stdio;
         }
+
+        int halfMaxSize = maxSize / 2;
         return stdio.subSequence(0, halfMaxSize) + "\n...[truncated " + middle + " chars]...\n" + stdio.subSequence(len - halfMaxSize, len);
     }
 
     /**
-     * Flavor of {@link #possiblyTrimStdio(Collection, boolean, String)} that doesn't try to read the whole thing into memory.
+     * Flavor of {@link #possiblyTrimStdio(Collection, PluginConfig, String)} that doesn't try to read the whole thing into memory.
      */
-    static String possiblyTrimStdio(Collection<CaseResult> results, boolean keepLongStdio, File stdio) throws IOException {
+    static String possiblyTrimStdio(Collection<CaseResult> results, PluginConfig config, File stdio) throws IOException {
         long len = stdio.length();
-        if (keepLongStdio && len < 1024 * 1024) {
+        if (config.isKeepLongStdio() && len < 1024 * 1024) {
             return FileUtils.readFileToString(stdio);
         }
-        int halfMaxSize = halfMaxSize(results);
+        int maxSize = config.getMaxSize(hasFailed(results));
+        if (maxSize < 0) {
+            return FileUtils.readFileToString(stdio);
+        }
+        if (maxSize == 0) {
+            return null;
+        }
 
-        long middle = len - halfMaxSize * 2;
+        long middle = len - maxSize;
         if (middle <= 0) {
             return FileUtils.readFileToString(stdio);
         }
 
+        int halfMaxSize = maxSize / 2;
         TextFile tx = new TextFile(stdio);
         String head = tx.head(halfMaxSize);
         String tail = tx.fastTail(halfMaxSize);
@@ -190,15 +218,13 @@ static String possiblyTrimStdio(Collection<CaseResult> results, boolean keepLong
         return head + "\n...[truncated " + middle + " bytes]...\n" + tail;
     }
 
-    private static final int HALF_MAX_SIZE = 500;
-    private static final int HALF_MAX_FAILING_SIZE = 50000;
-    private static int halfMaxSize(Collection<CaseResult> results) {
+    private static boolean hasFailed(Collection<CaseResult> results) {
         for (CaseResult result : results) {
             if (result.errorStackTrace != null) {
-                return HALF_MAX_FAILING_SIZE;
+                return true;
             }
         }
-        return HALF_MAX_SIZE;
+        return false;
     }
 
 

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

@@ -39,12 +39,12 @@
 
 /**
  * Parse some JUnit xml files and generate a TestResult containing all the
- * results parsed. 
+ * results parsed.
  */
 @Extension
 public class JUnitParser extends TestResultParser {
 
-    private final boolean keepLongStdio;
+    private final PluginConfig config;
 
     /** TODO TestResultParser.all does not seem to ever be called so why must this be an Extension? */
     @Deprecated
@@ -56,8 +56,17 @@ public JUnitParser() {
      * @param keepLongStdio if true, retain a suite's complete stdout/stderr even if this is huge and the suite passed
      * @since 1.358
      */
+    @Deprecated
     public JUnitParser(boolean keepLongStdio) {
-        this.keepLongStdio = keepLongStdio;
+        this.config = PluginConfig.defaults(keepLongStdio);
+    }
+
+    /**
+     * @param config configuration of the plugin.
+     * @since 1.6
+     */
+    public JUnitParser(PluginConfig config) {
+        this.config = config;
     }
 
     @Override
@@ -86,21 +95,21 @@ public TestResult parseResult(String testResultLocations,
 
         // [BUG 3123310] TODO - Test Result Refactor: review and fix TestDataPublisher/TestAction subsystem]
         // also get code that deals with testDataPublishers from JUnitResultArchiver.perform
-        
-        return workspace.act(new ParseResultCallable(testResultLocations, buildTime, timeOnMaster, keepLongStdio));
+
+        return workspace.act(new ParseResultCallable(testResultLocations, buildTime, timeOnMaster, config));
     }
 
     private static final class ParseResultCallable extends MasterToSlaveFileCallable<TestResult> {
         private final long buildTime;
         private final String testResults;
         private final long nowMaster;
-        private final boolean keepLongStdio;
+        private final PluginConfig config;
 
-        private ParseResultCallable(String testResults, long buildTime, long nowMaster, boolean keepLongStdio) {
+        private ParseResultCallable(String testResults, long buildTime, long nowMaster, PluginConfig config) {
             this.buildTime = buildTime;
             this.testResults = testResults;
             this.nowMaster = nowMaster;
-            this.keepLongStdio = keepLongStdio;
+            this.config = config;
         }
 
         public TestResult invoke(File ws, VirtualChannel channel) throws IOException {
@@ -116,9 +125,9 @@ public TestResult invoke(File ws, VirtualChannel channel) throws IOException {
                 throw new AbortException(Messages.JUnitResultArchiver_NoTestReportFound());
             }
 
-            TestResult result = new TestResult(buildTime + (nowSlave - nowMaster), ds, keepLongStdio);
+            TestResult result = new TestResult(buildTime + (nowSlave - nowMaster), ds, config);
             result.tally();
-            return result; 
+            return result;
         }
     }
 

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

@@ -74,6 +74,10 @@ public class JUnitResultArchiver extends Recorder implements SimpleBuildStep {
      */
     private boolean keepLongStdio;
 
+    private int maxSucceededSize;
+
+    private int maxFailedSize;
+
     /**
      * {@link TestDataPublisher}s configured for this archiver, to process the recorded data.
      * For compatibility reasons, can be null.
@@ -117,7 +121,7 @@ public JUnitResultArchiver(
     private TestResult parse(String expandedTestResults, Run<?,?> run, @Nonnull FilePath workspace, Launcher launcher, TaskListener listener)
             throws IOException, InterruptedException
     {
-        return new JUnitParser(isKeepLongStdio()).parseResult(expandedTestResults, run, workspace, launcher, listener);
+        return new JUnitParser(new PluginConfig(isKeepLongStdio(), getMaxSucceededSize(), getMaxFailedSize())).parseResult(expandedTestResults, run, workspace, launcher, listener);
     }
 
     @Deprecated
@@ -230,8 +234,26 @@ public boolean isKeepLongStdio() {
         this.keepLongStdio = keepLongStdio;
     }
 
+    /** @since 1.6 */
+    @DataBoundSetter public final void setMaxSucceededSize(int size) {
+        this.maxSucceededSize = size;
+    }
+
+    /** @since 1.6 */
+    @DataBoundSetter public final void setMaxFailedSize(int size) {
+        this.maxFailedSize = size;
+    }
+
 	private static final long serialVersionUID = 1L;
 
+    public int getMaxSucceededSize() {
+        return maxSucceededSize;
+    }
+
+    public int getMaxFailedSize() {
+        return maxFailedSize;
+    }
+
     @Extension
     public static class DescriptorImpl extends BuildStepDescriptor<Publisher> {
 		public String getDisplayName() {

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

@@ -0,0 +1,85 @@
+package hudson.tasks.junit;
+
+import java.io.Serializable;
+
+/**
+ * An object storing the plugin configuration.
+ */
+public class PluginConfig implements Serializable {
+
+  private final static int DEFAULT_MAX_SUCCEEDED_SIZE = 1000;
+
+  private final static int DEFAULT_MAX_FAILED_SIZE = 100000;
+
+  private final boolean keepLongStdio;
+
+  private final int maxSucceededSize;
+
+  private final int maxFailedSize;
+
+  public PluginConfig(boolean keepLongStdio, int maxSucceededSize, int maxFailedSize) {
+    this.keepLongStdio = keepLongStdio;
+    this.maxFailedSize = maxFailedSize;
+    this.maxSucceededSize = maxSucceededSize;
+  }
+
+  /**
+   * If true, retain a suite's complete stdout/stderr even if this is huge and the
+   * suite passed.
+   * @return
+   */
+  public boolean isKeepLongStdio() {
+    return keepLongStdio;
+  }
+
+  /**
+   * @return maximum number of bytes to keep for a succeeded test, or -1 if infinite.
+   */
+  public int getMaxSucceededSize() {
+    return maxSucceededSize;
+  }
+
+  /**
+   * @return maximum number of bytes to keep for a failed test, or -1 if infinite.
+   */
+  public int getMaxFailedSize() {
+    return maxFailedSize;
+  }
+
+  /**
+   * Get a new {@link PluginConfig} initialized with defaults values.
+   */
+  public static PluginConfig defaults() {
+    return new PluginConfig(false, DEFAULT_MAX_SUCCEEDED_SIZE, DEFAULT_MAX_FAILED_SIZE);
+  }
+
+  /**
+   * Get a new {@link PluginConfig} with given <code>keepLongStdio</code>, and
+   * defaults values for other configuration parameters.
+   */
+  public static PluginConfig defaults(boolean keepLongStdio) {
+    return new PluginConfig(keepLongStdio, DEFAULT_MAX_SUCCEEDED_SIZE, DEFAULT_MAX_FAILED_SIZE);
+  }
+
+  /**
+   * Get the maximum size of data to keep for a test, according to configuration.
+   * @param failed if test has failed.
+   * @return maximum number of bytes to keep.
+   */
+  public int getMaxSize(boolean failed) {
+    if (keepLongStdio) {
+      return -1;
+    }
+
+    if (failed) {
+      if (maxFailedSize < 0)
+        return -1;
+      return (int) maxFailedSize;
+    }
+    else {
+      if (maxSucceededSize < 0)
+        return -1;
+      return (int) maxSucceededSize;
+    }
+  }
+}