* framework agnostic.  Currently this interface can support feedback
 * from JUnit and TestNG tests.
 */
@EventScope(Scope.Build.class)
@DeprecatedInGradleScope
public interface TestListener {
    /**
     * Called before a test suite is started.
     * @param suite The suite whose tests are about to be executed.
     */
    void beforeSuite(TestDescriptor suite);

    /**

        }
        assertEquals(1, testListener.startCount);
        assertEquals(5, testListener.requestCount);
        assertEquals(5, testListener.exceptionCount);
        assertEquals(1, testListener.endCount);
        assertEquals(url, testListener.requestUrl);
        assertEquals(Constants.GET_METHOD, testListener.requestMethod);
        assertEquals(url, testListener.exceptionUrl);
        assertEquals(5, testClient.count);

        def listener = Mock(TestListener)

        when:
        services.addProvider(new ServiceRegistrationProvider() {
            @Provides
            TestListener createListener() {
                return listener
            }
        })
        services.get(TestListener)
        def broadcast = listenerManager.getBroadcaster(TestListener)

        then:
        0 * _

        when:

 protected:
  XlaActivityListenerTest() {
    auto listener = std::make_unique<TestListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  TestListener* listener() const { return listener_; }

 private:
  TestListener* listener_;
};

GraphDef CreateGraphDef() {
  Scope root = Scope::NewRootScope().ExitOnError().WithAssignedDevice(

        outputs.stdErr.readLines() == ["${tenAmFormatted} [ERROR] [category] error"]
    }

    def rendersLogEventsToStdOutListener() {
        def listener = new TestListener()

        when:
        renderer.enableUserStandardOutputListeners()
        renderer.addStandardOutputListener(listener)
        renderer.onOutput(event('info', LogLevel.INFO))

    }

    def 'ignores classes which do not implement any of the supported interfaces'() {
        given:
        def testListener = Mock(TestListener)

        expect:
        decorator.decorate('foo', TestListener, testListener) is testListener
        decorator.decorateUnknownListener('foo', testListener) is testListener
    }

    def 'decorates actions'() {
        given:
        def action = Mock(Action)

        Instantiator instantiator = getInstantiator();
        testLogging = instantiator.newInstance(DefaultTestLoggingContainer.class, instantiator);
        testListenerSubscriptions = new BroadcastSubscriptions<TestListener>(TestListener.class);
        testOutputListenerSubscriptions = new BroadcastSubscriptions<TestOutputListener>(TestOutputListener.class);
        binaryResultsDirectory = getProject().getObjects().directoryProperty();

		EdsConfig: &core.ConfigSource{
			ConfigSourceSpecifier: &core.ConfigSource_Ads{
				Ads: &core.AggregatedConfigSource{},
			},
		},
	},
	LbPolicy: cluster.Cluster_ROUND_ROBIN,
}

var testListener = &listener.Listener{
	Name: "test-listener",
	Address: &core.Address{
		Address: &core.Address_SocketAddress{
			SocketAddress: &core.SocketAddress{
				Protocol: core.SocketAddress_TCP,
				Address:  "0.0.0.0",

        file("build/tmp/test").exists() // ensure we extracted classes
    }

    private static String testListener() {
        return '''
            def listener = new TestListenerImpl()
            test {
                addTestListener(listener)
            }
            class TestListenerImpl implements TestListener {
                void beforeSuite(TestDescriptor suite) { println "START [$suite] [$suite.name]" }

     * <li>{@link org.gradle.BuildListener}
     * <li>{@link org.gradle.api.execution.TaskExecutionListener}
     * <li>{@link org.gradle.api.execution.TaskActionListener}
     * <li>{@link org.gradle.api.tasks.testing.TestListener}
     * <li>{@link org.gradle.api.tasks.testing.TestOutputListener}
     * </ul>
     *
     * @param listener The listener to add. Does nothing if this listener has already been added.
     */