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

package org.gradle.integtests.fixtures

import groovy.transform.SelfType

/**
 * Allows adding methods to the test class that are useful for testing configuration usage changes.
 */
@SelfType(AbstractIntegrationSpec)
trait ConfigurationUsageChangingFixture {

        given:
        def logFile = log("""\
            line1
            line2
            line3""")

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "input-ending eoln is ignored"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3
        """)

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"

A web-based, searchable dependency report is available by adding the --scan option.

BUILD SUCCESSFUL in 0s

You can provide configuration for your plugin by adding an extension object to this container.

Let's update our `greetings` example:

====
include::sample[dir="snippets/plugins/greeting/kotlin", files="buildSrc/src/main/kotlin/greetings.gradle.kts[tags=create-extension]"]

 * <pre class='autoTested'>
 * plugins {
 *     id 'java' // so that I can use 'implementation', 'testImplementation' configurations
 * }
 *
 * configurations {
 *   //adding a configuration:
 *   myConfiguration
 *
 *   //adding a configuration that extends existing configuration:
 *   //(testImplementation was added by the java plugin)
 *   myIntegrationTestsCompile.extendsFrom(testImplementation)
 *

/**
 * Represents the target that a plugin should be applied to, such as a Gradle, Settings or Project object.
 * This is used to apply a plugin to a target in a way that is appropriate for that target, such as adding
 * additional functionality specific to the target or disallowing certain types of plugins to be applied.
 */
public interface PluginTarget {

        val valueContainer = currentValues.computeIfAbsent(key) { k ->
            createContainer(k, creator)
        }

        // Calculate the value after adding the entry to the map, so that the value container can take care of thread synchronization
        valueContainer.finalizeIfNotAlready()
        return valueContainer.get()
    }

    private

import org.gradle.scripts.ScriptingLanguage;

/**
 * Selects a {@link ScriptPluginFactory} suitable for handling a given build script based
 * on its file name. Build script file names ending in ".gradle" are supported by the
 * {@link DefaultScriptPluginFactory}. Other files are delegated to the first available
 * matching implementation of the {@link ScriptingLanguage} SPI. If no provider

import org.gradle.internal.service.scopes.ServiceScope
import spock.lang.Specification

class ScopedServiceRegistryTest extends Specification {

    def "fails when registering a service by adding #method in a wrong scope"() {
        given:
        def registry = scopedRegistry(Scope.Build)

        when:
        registration(registry)

        then:
        def exception = thrown(IllegalArgumentException)

        }
        return displayName
    }

    Collection<BaselineVersion> getBaselineVersions() {
        return baselineVersions.values()
    }

    /**
     * Locates the given baseline version, adding it if not present.
     */
    BaselineVersion baseline(String version) {
        def baselineVersion = baselineVersions[version]
        if (baselineVersion == null) {