nanos: Long,
        ) {
          taskRunner.assertThreadHoldsLock()
          check(waitingCoordinatorTask == null)
          if (nanos == 0L) return

          // Yield until notified, interrupted, or the duration elapses.
          val waitUntil = nanoTime + nanos
          val self = currentTask
          waitingCoordinatorTask = self
          waitingCoordinatorNotified = false

        outputContains("the action must be tested")
        if (testExcludes) {
            outputContains("${BAZ_GROUP}:${BAZ_NAME}")
        }

        where:
        // Keeping it simpler here, since modifiers are all the same, and multi-string + named args are also the same
        expression                                                     | testExcludes
        singleString(FOO_GROUP, FOO_NAME, FOO_VERSION)                 | true

        TestClassInfo classInfo;
        synchronized (lock) {
            if (!failedConfigurations.add(testResult)) {
                // workaround for bug in TestNG 6.2 (apparently fixed in some 6.3.x): listener is notified twice per event
                return;
            }
            classInfo = this.testClassInfo.get(testClass);
        }
        // Synthesise a test for the broken configuration method

			if err != nil {
				t.Fatalf("failed creating the server: %v", err)
			}

			// add poststart hook to know when the server is up.
			startedCh := make(chan struct{})
			s.AddPostStartHookOrDie("test-notifier", func(context server.PostStartHookContext) error {
				close(startedCh)
				return nil
			})
			preparedServer := s.PrepareRun()
			preparedServerErrors := make(chan error)
			go func() {

import org.jetbrains.kotlin.analysis.api.impl.base.KaMapBackedSubstitutor
import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KaDeclarationRendererForSource
import org.jetbrains.kotlin.analysis.api.renderer.declarations.modifiers.renderers.KaRendererKeywordFilter
import org.jetbrains.kotlin.analysis.api.resolution.KaApplicableCallCandidateInfo
import org.jetbrains.kotlin.analysis.api.resolution.KaCall

            }

        @Synchronized
        override fun onReuse() {
            scope?.let {
                // Recreate the script scope and ClassLoader, so that things that use scopes are notified that the scope exists
                it.onReuse()
                require(loadedClass!!.classLoader == it.localClassLoader)
            }
        }

        private
        fun prepareClassLoaderScope() =

	Prefix     string                      `yaml:"prefix" json:"prefix"`
	Encryption BatchJobKeyRotateEncryption `yaml:"encryption" json:"encryption"`
}

// Notify notifies notification endpoint if configured regarding job failure or success.
func (r BatchJobKeyRotateV1) Notify(ctx context.Context, ri *batchJobInfo) error {
	return notifyEndpoint(ctx, ri, r.Flags.Notify.Endpoint, r.Flags.Notify.Token)

        2 * onAccess.accept('existing', 'existingValue')
        then:
        1 * onChange.accept('existing', 'newValue')
        then:
        0 * onChange._
    }

    def "method clear() notifies listener and changes map"() {
        def map = getMapUnderTestToWrite()
        when:
        map.clear()

        then:
        map.isEmpty()
        1 * onClear.run()
        0 * onAccess._

     */
    @Deprecated
    void buildFinished(Action<? super BuildResult> action);

    /**
     * Adds a {@link BuildListener} to this Build instance.
     *
     * The listener is notified of events which occur during the execution of the build.
     *
     * @param buildListener The listener to add.
     */
    void addBuildListener(BuildListener buildListener);

    /**

import org.gradle.api.internal.DocumentationRegistry
import org.gradle.jvm.toolchain.JavaLanguageVersion
import org.gradle.test.fixtures.file.TestFile

import static org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl.GROOVY

class BuildScriptBuilderGroovyTest extends AbstractBuildScriptBuilderTest {
    def builder = new BuildScriptBuilderFactory(new DocumentationRegistry()).scriptForNewProjectsWithoutVersionCatalog(GROOVY,