private final String classDisplayName;
    private long startTime;
    private int failuresCount;
    private int skippedCount;
    private long id;

    public TestClassResult(long id, String className, long startTime) {
        this(id, className, null, startTime);
    }

    public TestClassResult(long id, String className, @Nullable String classDisplayName, long startTime) {
        if (id < 1) {

    private final List<TestFailure> failures;
    private final ResultType resultType;
    private final long startTime;
    private final long endTime;
    private final long testCount;
    private final long successfulCount;
    private final long failedCount;

    public DefaultTestResult(TestState state) {

 */
public class VersionHierarchy {
    private final long version;
    // We store the maximum version as a performance optimization, so we don't need
    // to query the children every time we query the version for a hierarchy.
    private final long maxVersionInHierarchy;
    private final ChildMap<VersionHierarchy> children;

    public static VersionHierarchy empty(long version) {

        this.id = id;
        this.name = name;
        this.displayName = displayName;
    }

    public TestMethodResult(long id, String name, TestResult.ResultType resultType, long duration, long endTime) {
        this(id, name, name, resultType, duration, endTime);
    }

      public long getLongLittleEndian(byte[] array, int offset) {
        long bigEndian = theUnsafe.getLong(array, (long) offset + BYTE_ARRAY_BASE_OFFSET);
        // The hardware is big-endian, so we need to reverse the order of the bytes.
        return Long.reverseBytes(bigEndian);
      }

      @Override
      public void putLongLittleEndian(byte[] array, int offset, long value) {

     */
    @Override
    public void iterate(final String sessionId, final AccessResultCallback<AccessResultImpl<Long>> accessResultCallback) {
        final Map<String, AccessResultImpl<Long>> arMap = dataHelper.getAccessResultMap(sessionId);
        for (final Map.Entry<String, AccessResultImpl<Long>> entry : arMap.entrySet()) {
            accessResultCallback.iterate(entry.getValue());
        }
    }

    /*
     * (non-Javadoc)

        this.delayMillisAtNoUrlInQueue = delayMillisAtNoUrlInQueue;
    }

    public long getDelayMillisBeforeProcessing() {
        return delayMillisBeforeProcessing;
    }

    public void setDelayMillisBeforeProcessing(final long delayMillisBeforeProcessing) {
        this.delayMillisBeforeProcessing = delayMillisBeforeProcessing;
    }

    private static final long serialVersionUID = 1L;

    private long totalHits;

    private long tookInMillis;

    public void setTotalHits(final long totalHits) {
        this.totalHits = totalHits;
    }

    public long getTotalHits() {
        return totalHits;
    }

    public void setTookInMillis(final long tookInMillis) {
        this.tookInMillis = tookInMillis;
    }

    private long physicalMemoryThresholdInBytes;
    private long virtualMemoryThresholdInBytes;
    private static final Logger LOGGER = Logging.getLogger(LowMemoryDaemonExpirationStrategy.class);

    // Reasonable default threshold bounds: between 384M and 1G
    public static final long MIN_THRESHOLD_BYTES = 384 * 1024 * 1024;
    public static final long MAX_THRESHOLD_BYTES = 1024 * 1024 * 1024;

    List<Throwable> exceptions = []
    Throwable exception = exceptions[0]
    List<TestFailure> failures
    long startTime = 0
    long endTime = startTime + 100
    long testCount = 1
    long successfulTestCount = 1
    long failedTestCount = 0
    long skippedTestCount = 0

    SimpleTestResult(long endTime = 100) {
        this.endTime = endTime
    }