*/
    void onStdin(@Nullable StdinHandler handler);

    /**
     * Registers a handler for when this connection is disconnected unexpectedly.. The handler is notified at most once.
     *
     * The handler is not notified after any of the following occurs:
     * <ul>
     * <li>When the connection is closed using {@link #stop()}.</li>
     * </ul>
     *

        provider.get()

        then: "beforeValueObtained callback is notified"
        1 * computationListener.beforeValueObtained()

        then: "afterValueObtained callback is notified"
        1 * computationListener.afterValueObtained()

        then: "valueObtained is notified"
        obtainedValues.size() == 1
        obtainedValues[0].valueSourceType == EchoValueSource

 */
package org.gradle.internal.operations;

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope.Global;

/**
 * A listener that is notified as build operations are executed.
 *
 * Listeners must be registered via {@link BuildOperationListenerManager}, not ListenerManager.
 *

        }
        thread.blockUntil.notified

        then:
        1 * handler.endStream() >> {
            thread.blockUntil.signal
            instant.notified
        }
        0 * _._
    }

    def "notifies handler that the end of incoming messages has been reached when stop requested and end-of-stream reached for all connections"() {
        BoundedDispatch<String> handler = Mock()

        when:
        buildFile << """
            task t { doFirst { throw new Exception("!") } }
            notifier.notify {
                println "failure message: \${it.failure.cause.message}"
                System.err.println "notified"
            }
            // user logic registered _after_ listener registered
            gradle.projectsEvaluated {

		t.Error(err)
	}
	if handled != 0 {
		t.Errorf("notified workload handler %d times, want %d", handled, 0)
	}

	if err := f(nil, &v1.Pod{ObjectMeta: pod1, Status: v1.PodStatus{Conditions: readyCondition, PodIP: ip, Phase: v1.PodPending}}, model.EventUpdate); err != nil {
		t.Error(err)
	}
	if handled != 1 {
		t.Errorf("notified workload handler %d times, want %d", handled, 1)
	}

    }

    def "end of build listener is notified on success"() {
        when:
        succeeds succeedingTaskName

        then:
        plugin.assertEndOfBuildWithFailure(output, null)

        when:
        succeeds succeedingTaskName

        then:
        plugin.assertEndOfBuildWithFailure(output, null)
    }

    def "end of build listener is notified on failure"() {
        when:

        }

        private List<Dispatch<MethodInvocation>> startNotification(boolean includeLogger) {
            takeOwnership();

            if (!notified) {
                maybeAddPendingRegistrations(type);
                notified = true;
            }

            // Take a snapshot while holding lock
            List<Dispatch<MethodInvocation>> result = includeLogger ? allWithLogger : allWithNoLogger;

				// We need to translate this request into a signal that can be handled by the signal handler
				// handling shutdowns normally (currently apiserver/pkg/server/signal.go).
				// If we do not do this, our main threads won't be notified of the upcoming shutdown.
				// Since Windows services do not use any console, we cannot simply generate a CTRL_BREAK_EVENT
				// but need a dedicated notification mechanism.
				graceful := server.RequestShutdown()

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

package org.gradle.internal.featurelifecycle;

/**
 * Notified when a deprecated feature is used.
 *
 * <p>Implementations need not be thread-safe.
 */
public interface FeatureHandler<T extends FeatureUsage> {
    void featureUsed(T usage);