// tag::declare-task[]
tasks.register<Copy>("myCopy")
// end::declare-task[]

// tag::configure[]
// Configure task using Kotlin delegated properties and a lambda
val myCopy by tasks.existing(Copy::class) {
    from("resources")
    into("target")
}
myCopy {
    include("**/*.txt", "**/*.xml", "**/*.properties")
}

}

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

// RecordRequestLatency measures request latency in seconds for the delegated authorization. Broken down by status code.

    if (isEmpty()) return

    // One of the compiler lowerings, namely `PropertyReferenceLowering`,
    // optimizes usages of property references in some cases,
    // and if a containing delegated property accessor is inline,
    // it might need this accessor's bytecode.
    //
    // If an accessor function is defined in a different module,
    // IDE tries to acquire its bytecode via the index, however,

rootProject.name = "properties"

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

// Using Kotlin delegated properties on `settings`
val gradlePropertiesProp: String by settings
println(gradlePropertiesProp)
// end::gradle-properties[]

// tag::properties-with-dots[]
// In Kotlin scripts, using the API is the only way

                }
            }
            """
        )
    }

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

        testTaskContainerVia(
            "delegated-properties", before = beforeDelegatedProperties,
            script = """

            fun untyped() {

                val foo: Task by tasks.getting

 * `getValue` operator based on the static type of the delegate.
 */
class ExistingDomainObjectDelegate<T>
private constructor(
    internal val delegate: T
) {
    companion object {
        fun <T> of(delegate: T) =
            ExistingDomainObjectDelegate(delegate)
    }
}


/**
 * Gets the delegate value.
 */

kind: bug-fix
area: security
issue:
- 46951
releaseNotes:
- |

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

// Using Kotlin delegated properties on `project`
val gradlePropertiesProp: String by project
println(gradlePropertiesProp)
// end::gradle-properties[]

abstract class PrintValue : DefaultTask() {
    @get:Input abstract val inputValue: Property<String>
    @TaskAction fun action() { println(inputValue.get()) }

import org.hamcrest.CoreMatchers.sameInstance
import org.hamcrest.MatcherAssert.assertThat

import org.junit.Test


class ConfigurableFileCollectionExtensionsTest {

    @Test
    fun `assignment to delegated property means #setFrom`() {

        val fileCollection = mock<ConfigurableFileCollection>()
        var delegatedProperty by fileCollection

        val value = mock<ConfigurableFileCollection>()

limitations under the License.
*/

// Package kubeapiserver holds code that is common to both the kube-apiserver
// and the federation-apiserver, but isn't part of a generic API server.
// For instance, the non-delegated authorization options are used by those two
// servers, but no generic API server is likely to use them.