/**
     * Reads a block from this store.
     */
    <T extends BlockPayload> T read(BlockPointer pos, Class<T> payloadType);

    /**
     * Writes a block to this store, adding the block if required.
     */
    void write(BlockPayload block);

    /**
     * Adds a new block to this store. Allocates space for the block, but does not write the contents of the block

        succeeds "verify"
        output.contains '''configured components.mylib.binaries.main.sources
before ss1
created ss1
configured ss1
after ss1
'''
    }

    def "reasonable error message when adding source set with unknown type"() {
        when:
        buildFile << """
interface UnregisteredSourceSetType extends LanguageSourceSet {}
model {
    components {
        mylib {
            binaries {

 * and has no actual tests but is still included on the jacoco aggregation classpath transitively,
 * it will cause the report aggregation to fail.
 *
 * This is due to that plugin adding attributes to the legacy `default` variant which cause it to match
 * the variant selection performed by the plugin when looking for aggregation data.  Without the fix for this issue (check file signature of

import org.gradle.plugin.use.PluginDependencySpec


/**
 * Receiver for the `plugins` block.
 *
 * This class exists for the sole purpose of marking the `plugins` block as a [GradleDsl] thus
 * hiding all members provided by the outer script scope.
 *
 * @see [PluginDependenciesSpec]
 */
@GradleDsl
open class PluginDependenciesSpecScope internal constructor(
    private val plugins: PluginDependenciesSpec

            if (markNotPending(key)) {
                return PendingState.NOT_PENDING_ACTIVATING;
            } else {
                return PendingState.NOT_PENDING;
            }
        }

        // Adding an optional dependency: see if we already have a hard dependency on the same module
        ModuleResolveState module = resolveState.getModule(key);
        boolean pending = module.isPending();

This sample shows how link:{userManualPath}/artifact_transforms.html[artifact transforms] can be utilised to turn traditional Java libraries into Java Modules by adding additional information to the corresponding Jars.
For that, a plugin called `extra-java-module-info` is defined in the `buildSrc` folder.

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)

            task.getLib().from((Callable<FileCollection>) () -> {
                // Ensure that deploy jars are not also added into lib folder.
                // Allows the user to get transitive dependencies for a bean artifact by adding it to both earlib and deploy but only having the file once in the ear.
                return project.getConfigurations().getByName(EARLIB_CONFIGURATION_NAME)

        where:
        action     | oldFile                                   | newFile                                    | recompileClasses | deletedClasses
        'adding'   | 'class A { } \nclass B { } \n'            | 'class A{}\nclass B{}\nclass C{}'          | ['A', 'B', 'C']  | []

        }

        when:
        def set = Actions.set(b, a, c, a, b)
        set.execute(called)

        then:
        called == ['b', 'a', 'c']
    }

    def "doesn't grow when adding a doNothing"() {
        when:
        def set = Actions.set(Actions.doNothing())

        then:
        set.empty
    }

    protected Spec spec(Closure spec) {
        spec as Spec
    }