def "abbreviates long java packages"() {
        expect:
        JavaClassNameFormatter.abbreviateJavaPackage("", 60) == ""
        JavaClassNameFormatter.abbreviateJavaPackage("org.gradle.FooTest", 60) == "org.gradle.FooTest"
        JavaClassNameFormatter.abbreviateJavaPackage("TestNoPackageFunctionalIntegrationTestWithAReallyReallyLongName", 60) == "TestNoPackageFunctionalIntegrationTestWithAReallyReallyLongName"

    }

    @Override
    protected void setupProjectInOriginalLocation() {
        file("src/main/java/Foo.java") << "public class Foo {}"
        file("src/test/java/FooTest.java") << """
            import org.junit.*;

            public class FooTest {
                @Test
                public void test() {
                    new Foo();
                }
            }
        """

<?xml version="1.0" encoding="UTF-8"?>


<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="SimpleSuite">
    <test name="SimpleTest">
        <classes>
            <class name="org.gradle.FooTest"/>
            <class name="org.gradle.BarTest"/>
        </classes>
    </test>

        assert suiteTestTestOps.size() == 3
        assert suiteTestTestOps*.details.testDescriptor.name == ["fail", "ok", "anotherOk"]
        assert suiteTestTestOps*.details.testDescriptor.className == ["org.gradle.FooTest", "org.gradle.FooTest", "org.gradle.BarTest"]
        assert suiteTestTestOps*.details.testDescriptor.composite == [false, false, false]

        def testOutput = suiteTestTestOps[1].progress
        assert testOutput.size() == 2

import spock.lang.Specification

public class DefaultTestResultTest extends Specification {

    def "construct itself from the state"() {
        expect:
        def state = new TestState(new DefaultTestDescriptor("12", "FooTest", "shouldWork"), new TestStartEvent(100L), new HashMap());
        state.completed(new TestCompleteEvent(200L, ResultType.SKIPPED))

        when:
        def result = new DefaultTestResult(state)

        then:

                return StringUtils.normalizeSpace("hi  there!");
              }
            }
        """
        targetDir.file("src/test/java/FooTest.java") << """
            import org.junit.Test;

            public class FooTest {
              @Test public void test() {
                assert false: "test failure";
              }
            }
        """
    }

        then:
        0 * exitHandler.run()
        !outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-reports.html.destination/classes/FooTest.html", false, exitHandler)
        then:
        0 * exitHandler.run()
        !outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-reports.html.destination/css/", true, exitHandler)

type delayTask struct {
	do      func() error
	runAt   time.Time
	retries int
}

const maxTaskRetry = 3

var _ heap.Interface = &pq{}

// pq implements an internal priority queue so that tasks with the soonest expiry will be run first.
// Methods on pq are not threadsafe, access should be protected.
// much of this is taken from the example at https://golang.org/pkg/container/heap/
type pq []*delayTask

func (q pq) Len() int {

	retryTime := bfr.timer.Now().Add(interval)

	// We can't just write retryTime to a channel because there could be multiple
	// RetryAfter calls before Loop gets a chance to read from the channel. So we
	// record the soonest requested retry time in bfr.retryTime and then only signal
	// the Loop thread once, just like Run does.
	bfr.retryMu.Lock()
	defer bfr.retryMu.Unlock()
	if !bfr.retryTime.IsZero() && bfr.retryTime.Before(retryTime) {