".dotfile":      {Mode: 0644, Data: []byte("dotfile")},
				".dotfile.file": {Mode: 0644, Data: []byte("dotfile.file")},
			},
			success: true,
		},
		{
			name: "dotfiles mode",
			payload: map[string]FileProjection{
				"foo":           {Mode: 0407, Data: []byte("foo")},
				"bar":           {Mode: 0440, Data: []byte("bar")},
				".dotfile":      {Mode: 0777, Data: []byte("dotfile")},

		}
	}
}

func makeRouteFile(content string, t *testing.T) (*os.File, error) {
	routeFile, err := os.CreateTemp("", "route")
	if err != nil {
		return nil, err
	}

	if _, err := routeFile.Write([]byte(content)); err != nil {
		return routeFile, err
	}
	err = routeFile.Close()
	return routeFile, err
}

func TestFailGettingIPv4Routes(t *testing.T) {

_complete istio 2>/dev/null
`

		// Create the output file.
		outFile, err := os.Create(c.OutputDir + "/_" + root.Name())
		if err != nil {
			return fmt.Errorf("unable to create zsh completion file: %v", err)
		}
		defer func() { _ = outFile.Close() }()

		// Concatenate the head, initialization, generated bash, and tail to the file
		if _, err = outFile.WriteString(zshInitialization); err != nil {

		return false
	}
	switch err.(type) {
	case noRoutesError:
		return true
	default:
		return false
	}
}

var (
	v4File = RouteFile{name: ipv4RouteFile, parse: getIPv4DefaultRoutes}
	v6File = RouteFile{name: ipv6RouteFile, parse: getIPv6DefaultRoutes}
)

func (rf RouteFile) extract() ([]Route, error) {
	file, err := os.Open(rf.name)
	if err != nil {
		return nil, err
	}
	defer file.Close()

        def unitOfWork = builder.withOutputDirs(
            dir1: file("outDir1"),
            dir2: file("outDir2")
        ).withOutputFiles(
            "file1": file("parent1/outFile"),
            "file2": file("parent2/outFile")
        ).withWork { ->
            UnitOfWork.WorkResult.DID_WORK
        }.build()

        when:
        def result = execute(unitOfWork)

        then:

                                new File(unzipDir, entry.getName()).mkdirs()
                                continue
                            }
                            File outFile = new File(unzipDir, entry.getName())
                            outFile.withOutputStream { outputStream ->
                                copy(inputStream, outputStream)
                            }
                        }
                    }

            task resolve {
                def configuration = configurations.bar
                def outFile = file('bar')
                doFirst {
                    configuration.files
                    def failure = null
                    def thread = new Thread({
                        try {
                            outFile << configuration.files
                        } catch(Throwable t) {

    @Optional @InputDirectory
    final DirectoryProperty inDir = project.objects.directoryProperty()

    @Optional @OutputFile
    final RegularFileProperty outFile = project.objects.fileProperty()

    @Optional @OutputDirectory
    final DirectoryProperty outDir = project.objects.directoryProperty()

    @TaskAction
    def go() { }
}

	if f.IsDir() {
		return fs.ModeDir | 0555
	}
	return 0444
}

func (f *file) String() string {
	return fs.FormatFileInfo(f)
}

// dotFile is a file for the root directory,
// which is omitted from the files list in a FS.
var dotFile = &file{name: "./"}

// lookup returns the named file, or nil if it is not present.
func (f FS) lookup(name string) *file {
	if !fs.ValidPath(name) {

	args := []string{"verify", "-no_check_time"}

	rootsFile := writePEMsToTempFile(allCerts(t, roots))
	if debugOpenSSLFailure {
		println("roots file:", rootsFile.Name())
	} else {
		defer os.Remove(rootsFile.Name())
	}
	args = append(args, "-CAfile", rootsFile.Name())

	if intermediates.len() > 0 {