import javax.annotation.Nullable;

@UsedByScanPlugin
public class TestCompleteEvent {
    private final long endTime;
    private final TestResult.ResultType resultType;

    @UsedByScanPlugin("test-distribution")
    public TestCompleteEvent(long endTime) {
        this(endTime, null);
    }

    @UsedByScanPlugin("test-distribution")
    public TestCompleteEvent(long endTime, TestResult.ResultType resultType) {

        def testStartEvent = new TestStartEvent(100L, "suiteId")
        def testCompleteEvent = new TestCompleteEvent(200L)
        def completeEvent = new TestCompleteEvent(300L)

        when:
        adapter.started(suite, startEvent)
        adapter.started(test, testStartEvent)
        adapter.completed('testId', testCompleteEvent)
        adapter.completed('suiteId', completeEvent)

        then:

            processor.started(suiteDescriptor, startEvent)
            processor.completed(testId, Stub(TestCompleteEvent) {
                getResultType() >> TestResult.ResultType.FAILURE
            })
            processor.started(suiteDescriptor, startEvent)
            processor.completed(testId, Stub(TestCompleteEvent) {
                getResultType() >> TestResult.ResultType.SUCCESS
            })
        }
    }

                    resultProcessor.completed(initializationError.getId(), new TestCompleteEvent(now));
                } else {
                    for (Object test : currentTests) {
                        resultProcessor.failure(test, failure);
                        resultProcessor.completed(test, new TestCompleteEvent(now));
                    }
                }
            }

    }

    def "serializes TestCompleteEvent"() {
        def event1 = new TestCompleteEvent(123L, TestResult.ResultType.SUCCESS)
        def event2 = new TestCompleteEvent(123L, null)

        when:
        def result1 = serialize(event1)
        def result2 = serialize(event2)

        then:
        result1 instanceof TestCompleteEvent
        result1.endTime == 123L

    TestDescriptorInternal parentTestDescriptorInternal = Mock()
    TestDescriptorInternal testDescriptorInternal = Mock()
    TestStartEvent testStartEvent = Mock()
    TestCompleteEvent testCompleteEvent = Mock()
    TestResult testResult = Mock()

    def setup() {
        _ * testDescriptorInternal.getParent() >> parentTestDescriptorInternal
    }

    def "tests are exposed"() {
        setup:

        resultProcessorAdapter.onAfterClass(testClass)

        then:
        1 * resultProcessor.completed(TEST_CLASS_ID, _ as TestCompleteEvent)

        when:
        resultProcessorAdapter.onAfterClass(testClass)

        then:
        0 * resultProcessor.completed(_, _ as TestCompleteEvent)
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package org.gradle.api.internal.tasks.testing.results

import org.gradle.api.internal.tasks.testing.TestCompleteEvent
import org.gradle.api.internal.tasks.testing.TestDescriptorInternal
import org.gradle.api.internal.tasks.testing.TestResultProcessor
import org.gradle.api.internal.tasks.testing.TestStartEvent
import spock.lang.Specification

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.tasks.testing.results;

import org.gradle.api.internal.tasks.testing.TestCompleteEvent;
import org.gradle.api.internal.tasks.testing.TestDescriptorInternal;
import org.gradle.api.internal.tasks.testing.TestStartEvent;
import org.gradle.api.tasks.testing.TestFailure;

    def "when test completes its parent will be the owner of output"() {
        def test = new DefaultTestDescriptor("2", "Bar", "Baz")
        def testEvent = new TestStartEvent(2, "99")
        def complete = new TestCompleteEvent(1)

        processor.started(new DefaultTestSuiteDescriptor("1", "Foo"), new TestStartEvent(1))
        processor.started(test, testEvent)

        when: processor.completed("2", complete)

        then: