| 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 <code>Result</code> 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 AtomicInteger assumptionFailureCount; |
| private final CopyOnWriteArrayList<Failure> 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(); |
| assumptionFailureCount = new AtomicInteger(); |
| failures = new CopyOnWriteArrayList<Failure>(); |
| runTime = new AtomicLong(); |
| startTime = new AtomicLong(); |
| } |
| |
| private Result(SerializedForm serializedForm) { |
| count = serializedForm.fCount; |
| ignoreCount = serializedForm.fIgnoreCount; |
| assumptionFailureCount = serializedForm.assumptionFailureCount; |
| failures = new CopyOnWriteArrayList<Failure>(serializedForm.fFailures); |
| runTime = new AtomicLong(serializedForm.fRunTime); |
| startTime = new AtomicLong(serializedForm.fStartTime); |
| } |
| |
| /** |
| * Returns the number of tests run |
| */ |
| public int getRunCount() { |
| return count.get(); |
| } |
| |
| /** |
| * Returns the number of tests that failed during the run |
| */ |
| public int getFailureCount() { |
| return failures.size(); |
| } |
| |
| /** |
| * Returns the number of milliseconds it took to run the entire suite to run |
| */ |
| public long getRunTime() { |
| return runTime.get(); |
| } |
| |
| /** |
| * Returns the {@link Failure}s describing tests that failed and the problems they encountered |
| */ |
| public List<Failure> getFailures() { |
| return failures; |
| } |
| |
| /** |
| * @return the number of tests ignored during the run |
| */ |
| public int getIgnoreCount() { |
| return ignoreCount.get(); |
| } |
| |
| /** |
| * Returns the number of tests skipped because of an assumption failure |
| * |
| * @throws UnsupportedOperationException if the result was serialized in a version before JUnit 4.13 |
| * @since 4.13 |
| */ |
| public int getAssumptionFailureCount() { |
| if (assumptionFailureCount == null) { |
| throw new UnsupportedOperationException( |
| "Result was serialized from a version of JUnit that doesn't support this method"); |
| } |
| return assumptionFailureCount.get(); |
| } |
| |
| /** |
| * @return <code>true</code> 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) { |
| assumptionFailureCount.getAndIncrement(); |
| } |
| } |
| |
| /** |
| * 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 AtomicInteger assumptionFailureCount; |
| private final List<Failure> fFailures; |
| private final long fRunTime; |
| private final long fStartTime; |
| |
| public SerializedForm(Result result) { |
| fCount = result.count; |
| fIgnoreCount = result.ignoreCount; |
| assumptionFailureCount = result.assumptionFailureCount; |
| fFailures = Collections.synchronizedList(new ArrayList<Failure>(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); |
| assumptionFailureCount = (AtomicInteger) fields.get("assumptionFailureCount", null); |
| fFailures = (List<Failure>) 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); |
| fields.put("assumptionFailureCount", assumptionFailureCount); |
| s.writeFields(); |
| } |
| |
| public static SerializedForm deserialize(ObjectInputStream s) |
| throws ClassNotFoundException, IOException { |
| ObjectInputStream.GetField fields = s.readFields(); |
| return new SerializedForm(fields); |
| } |
| } |
| } |