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

import org.gradle.internal.scan.UsedByScanPlugin;

@UsedByScanPlugin("test-distribution")
public class DefaultTestSuiteDescriptor extends AbstractTestDescriptor {

    @UsedByScanPlugin("test-distribution")
    public DefaultTestSuiteDescriptor(Object id, String name) {
        super(id, name);
    }

    @Override
    public String toString() {

    TestOutputRedirector redirector = Mock()
    @Subject processor = new CaptureTestOutputTestResultProcessor(target, redirector)

    def "starts capturing output"() {
        def suite = new DefaultTestSuiteDescriptor("1", "Foo")
        def event = new TestStartEvent(1)

        when:
        processor.started(suite, event)

        then: 1 * target.started(suite, event)
        then: 1 * redirector.setOutputOwner("1")

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

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

import org.gradle.api.internal.tasks.testing.DefaultTestSuiteDescriptor;
import org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor;
import org.gradle.api.internal.tasks.testing.TestClassProcessor;
import org.gradle.internal.time.Clock;

        failures[0].stackTrace.startsWith(failure2.rawFailure.toString())
    }

    def "reports suite failures"() {
        def root = new DefaultTestSuiteDescriptor("1", "Suite")
        def testWorker = new DefaultTestSuiteDescriptor("2", "Test Worker 1")

        when:
        //simulating a scenario with suite failing badly enough so that no tests are executed
        collector.beforeSuite(root)

        0 * _
    }

    void createsAnAggregateResultForTestSuiteWithNestedSuites() {
        given:
        def root = new DefaultTestSuiteDescriptor("root", "AllTests");
        def suite1 = new DefaultTestSuiteDescriptor("suite1", "FastTests");
        def suite2 = new DefaultTestSuiteDescriptor("suite2", "SlowTests");
        def ok = new DefaultTestDescriptor("ok", "DogTest", "shouldBarkAtStrangers");

        containsEvent(FINISHED, DefaultTestClassDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest')
        containsEvent(FINISHED, DefaultTestSuiteDescriptor, 'TestSuite > LightTest')
        containsEvent(STARTED, DefaultTestSuiteDescriptor, 'TestSuite > FullTest')
        containsEvent(STARTED, DefaultTestClassDescriptor, 'TestSuite > FullTest > org.company.SystemOutTest')

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

import spock.lang.Specification

class DefaultTestSuiteDescriptorTest extends Specification {
    def hasUsefulToString() {
        DefaultTestSuiteDescriptor descriptor = new DefaultTestSuiteDescriptor('id', '<suite-name>')

        expect:
        descriptor.toString() == "Test suite '<suite-name>'"
    }

        result == id
    }

    def "serializes DefaultTestSuiteDescriptor"() {
        def id = new CompositeIdGenerator.CompositeId(1L, 2L)
        def descriptor = new DefaultTestSuiteDescriptor(id, "some-test")

        when:
        def result = serialize(descriptor)

        then:
        result instanceof DefaultTestSuiteDescriptor
        result.id == id
        result.name == "some-test"
    }

 * limitations under the License.
 */

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

import org.gradle.api.internal.tasks.testing.DefaultTestSuiteDescriptor;
import org.gradle.api.internal.tasks.testing.TestClassProcessor;
import org.gradle.api.internal.tasks.testing.TestCompleteEvent;
import org.gradle.api.internal.tasks.testing.TestDescriptorInternal;

                    OperationIdentifier rootId = new OperationIdentifier(40L)
                    DefaultTestSuiteDescriptor rootDescr = new DefaultTestSuiteDescriptor(rootId, "MyCustomTestRoot")
                    testResultProcessor.started(rootDescr, new TestStartEvent(System.currentTimeMillis()))