}
            }
            """
        )
    }

    @Test
    fun `monomorphic named domain object container delegated properties`() {

        testConfigurationContainerVia(
            "delegated-properties",
            """

            val foo: Configuration by configurations.getting
            val bar: Configuration by configurations.getting {

            "help"
        )

        // when: both settings and project scripts asserting on delegated properties
        withSettings(requirePropertiesFromSettings())
        withBuildScript(requirePropertiesFromProject())

        // then:
        build(*buildArguments)

        // when: project script buildscript block asserting on delegated properties
        withSettings("")
        withBuildScript(
            """

		requestLatency,
	}
)

// RecordRequestTotal increments the total number of requests for the delegated authentication.
func RecordRequestTotal(ctx context.Context, code string) {
	requestTotal.WithContext(ctx).WithLabelValues(code).Inc()
}

// RecordRequestLatency measures request latency in seconds for the delegated authentication. Broken down by status code.
func RecordRequestLatency(ctx context.Context, code string, latency float64) {

rootProject.name = "containers-delegated-properties"...

	// but never false negative.
	time.Sleep(100 * time.Millisecond)
	select {
	case <-shutdownEndCh:
		t.Fatalf("Shutdown exited before delegated call ended")
	default:
	}

	// Wait for Shutdown to exit after delegated call has exited.
	close(delegatedCallEndCh)
	<-shutdownEndCh
}

func TestDelegateProcessEvents(t *testing.T) {
	for _, async := range []bool{true, false} {

    final ListenableFuture<? extends V> delegate;

    SetFuture(ListenableFuture<? extends V> delegate) {
      this.delegate = delegate;
    }

    @Override
    public void run() {
      if (isCancelled()) {
        return;
      }

      if (delegate instanceof AbstractFuture) {
        AbstractFuture<? extends V> other = (AbstractFuture<? extends V>) delegate;
        value = other.value;

// Using Kotlin delegated properties

val hello by tasks.registering {
    doLast {
        println("hello")
    }
}

val copy by tasks.registering(Copy::class) {
    from(file("srcDir"))
    into(buildDir)

// tag::gradle-properties[]
settingsEvaluated {
    // Using the API, provides a lazy Provider<String>
    println(providers.gradleProperty("gradlePropertiesProp").get())

    // Using Kotlin delegated properties on `settings`
    val gradlePropertiesProp: String by this
    println(gradlePropertiesProp)
}

rootProject.name = "define-as-kotlin-delegated-property"...

        access.listModuleVersions(dependency, result)

        then: 'work is delegated'
        1 * delegate.listModuleVersions(dependency, result)

        when: 'exception is thrown in resolution'
        repositoryBlacklister.getDisabledReason(REPOSITORY_ID) >> Optional.of(exception)
        effectiveRetries * delegate.listModuleVersions(dependency, result) >> { throw exception }