org.junit.runner.Result Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of junit Show documentation
Show all versions of junit Show documentation
JUnit is a unit testing framework for Java, created by Erich Gamma and Kent Beck.
package org.junit.runner;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
/**
* A Result
collects and summarizes information from running multiple tests.
* All tests are counted -- additional information is collected from tests that fail.
*
* @since 4.0
*/
public class Result implements Serializable {
private static final long serialVersionUID = 1L;
private static final ObjectStreamField[] serialPersistentFields =
ObjectStreamClass.lookup(SerializedForm.class).getFields();
private final AtomicInteger count;
private final AtomicInteger ignoreCount;
private final CopyOnWriteArrayList failures;
private final AtomicLong runTime;
private final AtomicLong startTime;
/** Only set during deserialization process. */
private SerializedForm serializedForm;
public Result() {
count = new AtomicInteger();
ignoreCount = new AtomicInteger();
failures = new CopyOnWriteArrayList();
runTime = new AtomicLong();
startTime = new AtomicLong();
}
private Result(SerializedForm serializedForm) {
count = serializedForm.fCount;
ignoreCount = serializedForm.fIgnoreCount;
failures = new CopyOnWriteArrayList(serializedForm.fFailures);
runTime = new AtomicLong(serializedForm.fRunTime);
startTime = new AtomicLong(serializedForm.fStartTime);
}
/**
* @return the number of tests run
*/
public int getRunCount() {
return count.get();
}
/**
* @return the number of tests that failed during the run
*/
public int getFailureCount() {
return failures.size();
}
/**
* @return the number of milliseconds it took to run the entire suite to run
*/
public long getRunTime() {
return runTime.get();
}
/**
* @return the {@link Failure}s describing tests that failed and the problems they encountered
*/
public List getFailures() {
return failures;
}
/**
* @return the number of tests ignored during the run
*/
public int getIgnoreCount() {
return ignoreCount.get();
}
/**
* @return true
if all tests succeeded
*/
public boolean wasSuccessful() {
return getFailureCount() == 0;
}
private void writeObject(ObjectOutputStream s) throws IOException {
SerializedForm serializedForm = new SerializedForm(this);
serializedForm.serialize(s);
}
private void readObject(ObjectInputStream s)
throws ClassNotFoundException, IOException {
serializedForm = SerializedForm.deserialize(s);
}
private Object readResolve() {
return new Result(serializedForm);
}
@RunListener.ThreadSafe
private class Listener extends RunListener {
@Override
public void testRunStarted(Description description) throws Exception {
startTime.set(System.currentTimeMillis());
}
@Override
public void testRunFinished(Result result) throws Exception {
long endTime = System.currentTimeMillis();
runTime.addAndGet(endTime - startTime.get());
}
@Override
public void testFinished(Description description) throws Exception {
count.getAndIncrement();
}
@Override
public void testFailure(Failure failure) throws Exception {
failures.add(failure);
}
@Override
public void testIgnored(Description description) throws Exception {
ignoreCount.getAndIncrement();
}
@Override
public void testAssumptionFailure(Failure failure) {
// do nothing: same as passing (for 4.5; may change in 4.6)
}
}
/**
* Internal use only.
*/
public RunListener createListener() {
return new Listener();
}
/**
* Represents the serialized output of {@code Result}. The fields on this
* class match the files that {@code Result} had in JUnit 4.11.
*/
private static class SerializedForm implements Serializable {
private static final long serialVersionUID = 1L;
private final AtomicInteger fCount;
private final AtomicInteger fIgnoreCount;
private final List fFailures;
private final long fRunTime;
private final long fStartTime;
public SerializedForm(Result result) {
fCount = result.count;
fIgnoreCount = result.ignoreCount;
fFailures = Collections.synchronizedList(new ArrayList(result.failures));
fRunTime = result.runTime.longValue();
fStartTime = result.startTime.longValue();
}
@SuppressWarnings("unchecked")
private SerializedForm(ObjectInputStream.GetField fields) throws IOException {
fCount = (AtomicInteger) fields.get("fCount", null);
fIgnoreCount = (AtomicInteger) fields.get("fIgnoreCount", null);
fFailures = (List) fields.get("fFailures", null);
fRunTime = fields.get("fRunTime", 0L);
fStartTime = fields.get("fStartTime", 0L);
}
public void serialize(ObjectOutputStream s) throws IOException {
ObjectOutputStream.PutField fields = s.putFields();
fields.put("fCount", fCount);
fields.put("fIgnoreCount", fIgnoreCount);
fields.put("fFailures", fFailures);
fields.put("fRunTime", fRunTime);
fields.put("fStartTime", fStartTime);
s.writeFields();
}
public static SerializedForm deserialize(ObjectInputStream s)
throws ClassNotFoundException, IOException {
ObjectInputStream.GetField fields = s.readFields();
return new SerializedForm(fields);
}
}
}