*/

package org.gradle.api.internal.project;

import org.gradle.api.Project;
import org.gradle.api.Task;

import java.util.Collection;

/**
 * Service to provide all tasks in a project including both regular tasks,
 * and implicit tasks.
 */
public interface ProjectTaskLister {
    Collection<Task> listProjectTasks(Project project);

@ExtensionAnnotation(UnsupportedWithConfigurationCacheExtension.class)
public @interface UnsupportedWithConfigurationCache {

    String because() default "";

    String[] bottomSpecs() default {};

    /**
     * Declare regular expressions matching the iteration name.
     * Defaults to an empty array, meaning this annotation applies to all iterations of the annotated feature.
     */
    String[] iterationMatchers() default {};

        allowFileSystemAccess(false)
        def subDir = someDir.file("sub")
        snapshot = read(subDir)
        then:
        assertIsDirectorySnapshot(snapshot, subDir)
    }

    def "invalidate regular file"() {
        def parentDir = temporaryFolder.file("in/some")
        def someFile = parentDir.file("directory/somefile.txt").createFile()
        when:
        allowFileSystemAccess(true)

			allowed:        true,
		},
		{
			// CVE-2022-1996: regular expression 'example.com' matches
			// 'example.com.hacker.org' because it does not pin to the start
			// and end of the host.
			// The CVE should not occur in a real kubernetes cluster since we
			// validate the regular expression specified in --cors-allowed-origins
			// to ensure that it pins to the start and end of the host name.

limitations under the License.
*/

package volumepathhandler

import (
	"fmt"

	"k8s.io/apimachinery/pkg/types"
)

// AttachFileDevice takes a path to a regular file and makes it available as an
// attached block device.
func (v VolumePathHandler) AttachFileDevice(path string) (string, error) {
	return "", fmt.Errorf("AttachFileDevice not supported for this build.")
}

// This test is likely to become stale because the leak depends
// on a spurious-escape bug -- return an interface as a named
// output parameter appears to cause the called closure to escape,
// where returning it as a regular type does not.

package main

import (
	"fmt"
)

type closure func(i, j int) ent

type ent int

func (e ent) String() string {

[short] skip

go test flag_test.go -v -args -v=7 # Two distinct -v flags
go test -v flag_test.go -args -v=7 # Two distinct -v flags

# Using a custom flag mixed with regular 'go test' flags should be OK.
go test -count=1 -custom -args -v=7

# However, it should be an error to use custom flags when -c is used,
# since we know for sure that no test binary will run at all.
! go test -c -custom
stderr '^go: unknown flag -custom cannot be used with -c$'

    /**
     * Called before visiting the contents of a directory.
     */
    default void enterDirectory(DirectorySnapshot directorySnapshot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot);

    /**

[!GOOS:windows] env GOTMPDIR=$WORK/my-favorite-tmpdir
[GOOS:windows] env GOTMPDIR=$WORK\my-favorite-tmpdir
mkdir $GOTMPDIR
go build -x hello.go
stderr ^WORK=.*my-favorite-tmpdir

# Make GOTMPDIR a regular file. This prevents the creation of work directories,
# so we can check that certain commands don't create them.
# This simulates running on a full disk or a read-only volume.
rm $GOTMPDIR
cp hello.go $GOTMPDIR # any file will do

     * If {@code true}, each locked dependency is added as a strict constraint,
     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *
     * @return {@code true} if lock state was found, {@code false} otherwise
     */