import org.gradle.api.tasks.testing.TestResult.ResultType
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:

    public void completed(TestCompleteEvent event) {
        this.completeEvent = event;
        resultType = isFailed() ? TestResult.ResultType.FAILURE
                : event.getResultType() != null ? event.getResultType() : TestResult.ResultType.SUCCESS;

        if (!test.isComposite()) {
            testCount = 1;
            switch (resultType) {
                case SUCCESS:
                    successfulCount = 1;

    }

    def "completed calls stopNow on failure"() {
        testResult.resultType = TestResult.ResultType.FAILURE

        when:
        unit.completed(testDescriptor, testResult, completeEvent)

        then:
        1 * testExecuter.stopNow()
    }

    def "completed invokes delegate with result #result"() {
        testResult.resultType = result

        when:

        1 * listener.completed({it.descriptor == suite1}, { it.successfulTestCount == 1 && it.testCount == 1 && it.resultType == ResultType.SUCCESS}, _)
        1 * listener.completed({it.descriptor == suite2}, { it.successfulTestCount == 0 && it.testCount == 1 && it.resultType == ResultType.FAILURE}, _)

        0 * _
    }

    private final BlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(1);
    private final Class<T> resultType;
    private static final Object NULL = new Object();

    public BlockingResultHandler(Class<T> resultType) {
        this.resultType = resultType;
    }

    public T getResult() {
        Object result;
        try {
            result = queue.take();

        onTestFinished(iTestResult, TestResult.ResultType.SUCCESS);
    }

    @Override
    public void onTestFailure(ITestResult iTestResult) {
        onTestFinished(iTestResult, TestResult.ResultType.FAILURE);
    }

    @Override
    public void onTestSkipped(ITestResult iTestResult) {
        onTestFinished(iTestResult, TestResult.ResultType.SKIPPED);
    }

    @Override

import org.gradle.api.tasks.testing.TestResult

class BuildableTestMethodResult extends TestMethodResult {
    List<Throwable> exceptions = []

    TestResult.ResultType resultType = TestResult.ResultType.SUCCESS

    private final List<MethodTestOutputEvent> outputEvents

    BuildableTestMethodResult(String name, List<MethodTestOutputEvent> outputEvents, TestResult result) {
        super(name, result)

    }

    @Override
    public String getTitle() {
        return "Test " + name;
    }

    @Override
    public ResultType getResultType() {
        if (ignored) {
            return ResultType.SKIPPED;
        }
        return failures.isEmpty() ? ResultType.SUCCESS : ResultType.FAILURE;
    }

    @Override
    public long getDuration() {
        return duration;
    }

    @Override

  if (rhs_attr && is_valid_broadcasting(lhs_type, rhs_type, result_type)) {
    if (rhs_attr.isSplat() &&
        rhs_attr.getSplatValue<Attribute>() == identity_attr)
      return arithmetic_op.getX();
  }

  // Fold: Op(Identity, Operand) -> Operand for commutative operations.
  if (lhs_attr && is_commutative &&
      is_valid_broadcasting(rhs_type, lhs_type, result_type)) {
    if (lhs_attr.isSplat() &&

		p.matchingIsolateInitiator[i] = -1
	}

	for i := range p.matchingPDI {
		p.matchingPDI[i] = -1

		if t := p.resultTypes[i]; t.in(LRI, RLI, FSI) {
			depthCounter := 1
			for j := i + 1; j < p.Len(); j++ {
				if u := p.resultTypes[j]; u.in(LRI, RLI, FSI) {
					depthCounter++
				} else if u == PDI {
					if depthCounter--; depthCounter == 0 {
						p.matchingPDI[i] = j