hudson.tasks.test.TestResult Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hudson-core Show documentation
Contains the core Hudson code and view files to render HTML.
The newest version!
/*******************************************************************************
 *
 * Copyright (c) 2009, Yahoo!, Inc.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors: 
 *
 *   
 *      
 *
 *******************************************************************************/ 

package hudson.tasks.test;

import hudson.tasks.junit.TestAction;
import hudson.model.AbstractBuild;
import hudson.model.Run;
import hudson.model.Result;

import java.util.Collection;

import static java.util.Collections.emptyList;


/**
 * A class that represents a general concept of a test result, without any
 * language or implementation specifics.
 * Subclasses must add @Exported annotation to the fields they want to export.
 *
 * @sine 1.343
 */
public abstract class TestResult extends TestObject {

    /**
     * If the concept of a parent action is important to a subclass, then it should
     * provide a non-noop implementation of this method. 
     * @param action
     */
    public void setParentAction(AbstractTestResultAction action) {
    }

    /**
     * Returns the action that points to the top level test result includes
     * this test result.
     * 
     * @return
     */
    public AbstractTestResultAction getParentAction() {
        return getOwner().getTestResultAction();
    }
    
    /**
     * Request that the result update its counts of its children. Does not
     * require a parent action or owner or siblings. Subclasses should
     * implement this, unless they are *always* in a tallied state.  
     */
    public void tally() {
    }
    
    /**
     * Sets the parent test result
     * @param parent
     */
    public void setParent(TestObject parent) {
    }

    /**
     * Gets the human readable title of this result object.
     */
    public /* abstract */ String getTitle(){
        return "";
    }

    /**
     * Mark a build as unstable if there are failures. Otherwise, leave the
     * build result unchanged.
     *
     * @return {@link Result#UNSTABLE} if there are test failures, null otherwise.
     *
     */
    public Result getBuildResult() {
        if (getFailCount() > 0) {
            return Result.UNSTABLE;
        } else {
            return null;
        }
    }

    /**
     * Time it took to run this test. In seconds.
     */
    public /* abstract */ float getDuration() {
        return 0.0f;
    }

    /**
     * Gets the total number of passed tests.
     */
    public /* abstract */ int getPassCount() {
        return 0;
    }

    /**
     * Gets the total number of failed tests.
     */
    public /* abstract */ int getFailCount() {
        return 0;
    }


    /**
     * Gets the total number of skipped tests.
     */
    public /* abstract */ int getSkipCount() {
        return 0;
    }
    
    /**
     * Gets the counter part of this {@link TestResult} in the previous run.
     *
     * @return null if no such counter part exists.
     */
    public TestResult getPreviousResult() {
        AbstractBuild b = getOwner();
        if (b == null) {
            return null;
        }
        while(true) {
            b = b.getPreviousBuild();
            if(b==null)
                return null;
            AbstractTestResultAction r = b.getAction(getParentAction().getClass());
            if(r!=null) {
                TestResult result = r.findCorrespondingResult(this.getId());
                if (result!=null)
                    return result;
            }
        }
    }

    /**
     * Gets the counter part of this {@link TestResult} in the specified run.
     *
     * @return null if no such counter part exists.
     */
    public TestResult getResultInBuild(AbstractBuild build) {
        AbstractTestResultAction tra = build.getAction(getParentAction().getClass());
        if (tra == null) {
            tra = build.getAction(AbstractTestResultAction.class);
        }
        return (tra == null) ? null : tra.findCorrespondingResult(this.getId());
    }

    /**
     * Gets the "children" of this test result that failed
     * @return the children of this test result, if any, or an empty collection
     */
    public Collection getFailedTests() {
        return emptyList();
    }


    /**
     * Gets the "children" of this test result that passed
     * @return the children of this test result, if any, or an empty collection
     */
    public Collection getPassedTests() {
        return emptyList();
    }

    /**
     * Gets the "children" of this test result that were skipped
     * @return the children of this test result, if any, or an empty list
     */
    public Collection getSkippedTests() {
        return emptyList();
    }

    /**
     * If this test failed, then return the build number
     * when this test started failing.
     */
    public int getFailedSince() {
        return 0;
    }

    /**
     * If this test failed, then return the run
     * when this test started failing.
     */
    public Run getFailedSinceRun() {
        return null;
    }

    /**
     * The stdout of this test.
     */
    public String getStdout() {
        return "";
    }

    /**
     * The stderr of this test.
     */
    public String getStderr() {
        return "";
    }

    /**
     * If there was an error or a failure, this is the stack trace, or otherwise null.
     */
    public String getErrorStackTrace() {
        return "";
    }

    /**
     * If there was an error or a failure, this is the text from the message.
     */
    public String getErrorDetails() {
        return ""; 
    }

    /**
     * @return true if the test was not skipped and did not fail, false otherwise.
     */
    public boolean isPassed() {
        return ((getSkipCount() == 0) && (getFailCount() == 0));
    }

    public String toPrettyString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        sb.append("Name: ").append(this.getName()).append(", ");
        sb.append("Result: ").append(this.getBuildResult()).append(",\n");
        sb.append("Total Count: ").append(this.getTotalCount()).append(", ");
        sb.append("Fail: ").append(this.getFailCount()).append(", ");
        sb.append("Skipt: ").append(this.getSkipCount()).append(", ");
        sb.append("Pass: ").append(this.getSkipCount()).append(",\n");
        sb.append("Test Result Class: " ).append(this.getClass().getName()).append(" }\n");
        return sb.toString(); 
    }

    /**
     * Annotate some text -- what does this do? 
     * @param text
     * @return
     */
    public String annotate(String text) {
        if (text == null)
                return null;
        text = text.replace("&", "&").replace("<", "<").replaceAll(
                        "\\b(https?://[^\\s)>]+)", "$1");

        for (TestAction action: getTestActions()) {
                text = action.annotate(text);
        }
        return text;
    }
}