os.Exit(1) // second signal. Exit directly.
	}()

	return ctx
}

// RequestShutdown emulates a received event that is considered as shutdown signal (SIGTERM/SIGINT)
// This returns whether a handler was notified
func RequestShutdown() bool {
	if shutdownHandler != nil {
		select {
		case shutdownHandler <- shutdownSignals[0]:
			return true
		default:
		}
	}

	return false

import org.gradle.api.internal.artifacts.configurations.dynamicversion.Expiry;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

import java.util.Set;

/**
 * Notified of the use of changing values during dependency resolution, so this can be noted in the configuration cache inputs
 */
@EventScope(Scope.Build.class)
public interface ChangingValueDependencyResolutionListener {

 */
package org.gradle.api;

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

/**
 * <p>An {@code ProjectEvaluationListener} is notified when a project is evaluated. You add can add an {@code
 * ProjectEvaluationListener} to a {@link org.gradle.api.invocation.Gradle} using {@link

 */

package org.gradle.api.execution;

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

/**
 * <p>A {@code TaskExecutionGraphListener} is notified when the {@link TaskExecutionGraph} has been populated. You can
 * use this interface in your build file to perform some action based on the contents of the graph, before any tasks are
 * actually executed.</p>
 */

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

/**
 * <p>A {@code TaskExecutionListener} is notified of the execution of the tasks in a build.</p>
 *
 * <p>You can add a {@code TaskExecutionListener} to a build using {@link org.gradle.api.execution.TaskExecutionGraph#addTaskExecutionListener}
 *

		// holding when we synchronized.
		//
		// Start two goroutines that will race: one will broadcast on
		// the cond var, the other will wait on it.
		//
		// The new waiter may or may not get notified, but the first one
		// has to be notified.
		done := false
		go func() {
			cond.Broadcast()
		}()

		go func() {
			m.Lock()
			for !done {
				cond.Wait()
			}
			m.Unlock()
		}()

        Class<? extends ValueSource<T, P>> valueSourceType,
        @Nullable Class<P> parametersType,
        @Nullable P parameters
    );

    /**
     * The listener that is notified when the value of the {@code ValueSource} is computed. There is no ordering guarantees with the
     * {@link ValueListener#valueObtained(ValueListener.ObtainedValue, ValueSource)}.
     */
    @EventScope(Scope.Build.class)

        and:
        1 * callback1.run() >> { throw ex1 }
        1 * callback2.run() >> { throw ex2 }
        1 * callback3.run()
    }

    def 'removed callback is not notified'() {
        def token = new DefaultBuildCancellationToken()

        def callback = Mock(Runnable)
        token.addCallback(callback)
        token.removeCallback(callback)

        when:

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

package org.gradle.tooling.events;

/**
 * A listener which is notified when operations that are executed as part of running a build make progress.
 *
 * @see org.gradle.tooling.LongRunningOperation#addProgressListener(ProgressListener)

     * Process the specified file or directory.  If it is a directory, then its contents
     * (but not the directory itself) will be checked with {@link #isAllowed(FileTreeElement, Spec)} and notified to
     * the listener.  If it is a file, the file will be checked and notified.
     */
    public void visitFrom(FileVisitor visitor, File fileOrDirectory, RelativePath path, AtomicBoolean stopFlag) {
        Spec<FileTreeElement> spec = patternSet.getAsSpec();