/**
     * Registers a resource lock that has been unlocked during the transform so that the coordination service can
     * notify threads waiting on a lock.
     */
    void registerUnlocked(ResourceLock resourceLock);

    /**
     * Release any locks that have been acquired during the transform.
     */
    void releaseLocks();

tasks.register("task3"){
    println("REGISTER TASK3: This is executed during the configuration phase")
}

tasks.named("task3"){
    println("NAMED TASK3: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK3 - doFirst: This is executed during the execution phase")
    }
    doLast {
        println("NAMED TASK3 - doLast: This is executed during the execution phase")
    }
}
----
=====

	// really know what the return type is during compilation. Strict type checking
	// is done during evaluation.
	return []*celgo.Type{celgo.AnyType}
}

var _ ExpressionAccessor = &UserValidationCondition{}

// UserValidationCondition is a CEL expression that validates a User.
type UserValidationCondition struct {
	Expression string
	Message    string
}

    /**
     * Gets the problems that were encountered during the project building.
     *
     * @return the problems that were encountered during the project building, can be empty but never {@code null}
     */
    @Nonnull
    List<ModelProblem> getProblems();

    /**
     * Creates a human readable representation of these errors.
     */
    String toString();

        output.count("The remote build cache was disabled during the build due to errors.") == 1

        when:
        cleanBuildDir()
        succeeds "secondTask"

        then: "build cache is still enabled during next build"
        !output.contains("The remote build cache was disabled during the build")
        output.count("> Attempting load") == 2

import org.gradle.nativeplatform.fixtures.app.CppLib

class SwiftPackageManagerCppBuildExportIntegrationTest extends AbstractSwiftPackageManagerExportIntegrationTest {
    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "produces manifest for single project C++ library that defines only the production targets"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'

     */
    void prepareValue();

    /**
     * Called after the completion of the unit of work, regardless of the outcome. The property implementation can release any state that was cached during execution.
     */
    void cleanupValue();

	}
	pkgs := strings.Split(strings.TrimSpace(string(out)), "\n")

	cmd = exec.Command(testenv.GoToolPath(t), "tool", "dist", "list")
	cmd.Stderr = os.Stderr
	out, err = cmd.Output()
	if err != nil {
		log.Fatalf("loading architecture list: %v\n%s", err, out)
	}
	allGOARCH := make(map[string]bool)
	for _, pair := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		GOARCH := strings.Split(pair, "/")[1]

 * <p>
 * This is currently especially for ignoring configuration inputs that are handled differently in the
 * Develocity plugin.
 */
@ServiceScope(Scope.BuildTree.class)
public interface DevelocityPluginUnsafeConfigurationService {
    /**
     * Run some code without tracking its inputs.
     * <p>

    /**
     * Returns the metadata stored at the absolute path if it exists.
     */
    Optional<MetadataSnapshot> findMetadata(String absolutePath);

    /**
     * Returns the snapshot stored at the absolute path if one exists.
     */
    default Optional<FileSystemLocationSnapshot> findSnapshot(String absolutePath) {
        return findMetadata(absolutePath)
            .filter(FileSystemLocationSnapshot.class::isInstance)