const (
		C1	T
		C2
	
		C3
	
		C4	int
	)

	// Constants with a single type that is not propagated. 
	const (
		Default		= 0644
		Useless		= 0312
		WideOpen	= 0777
	)

	// Constants with an imported type that is propagated. 
	const (
		M1	os.FileMode
		M2
		M3
	)

	// Package constants. 
	const (
		I1	int
		I2
	)


TYPES

        rootDir.createFile('unauthorized/file')
        rootDir.createDir('authorized')
        rootDir.file('unauthorized').mode = 0000
    }

    def cleanup() {
        rootDir.file('unauthorized').mode = 0777
    }

    def "excluded files' permissions should be ignored"() {
        when:
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet().exclude('unauthorized'), TestFiles.fileSystem(), false)

// factor this function out into a package to reduce duplication.
func overlayDir(dstRoot, srcRoot string) error {
	dstRoot = filepath.Clean(dstRoot)
	if err := os.MkdirAll(dstRoot, 0777); err != nil {
		return err
	}

	srcRoot, err := filepath.Abs(srcRoot)
	if err != nil {
		return err
	}

	return filepath.WalkDir(srcRoot, func(srcPath string, entry fs.DirEntry, err error) error {

	}
	defer robustio.RemoveAll(tmp)

	file := filepath.Join(tmp, "a.go")
	err = os.WriteFile(file, []byte{}, 0644)
	if err != nil {
		t.Fatal(err)
	}
	dir := filepath.Join(tmp, "dir")
	err = os.Mkdir(dir, 0777)
	if err != nil {
		t.Fatal(err)
	}

	noVolume := file[len(filepath.VolumeName(file)):]
	wrongPath := filepath.Join(dir, noVolume)
	cmd := testenv.Command(t, tg.goTool(), "build", noVolume)
	cmd.Dir = dir

	C3
	redQueen int = iota
	C4
)

// Constants with a single type that is not propagated.
const (
	zero     os.FileMode = 0
	Default              = 0644
	Useless              = 0312
	WideOpen             = 0777
)

// Constants with an imported type that is propagated.
const (
	zero os.FileMode = 0
	M1
	M2
	M3
)

// Package constants.
const (
	_ int = iota
	I1
	I2
)

			scriptfilename = "script.bat"
		}
		var cmd *exec.Cmd
		if runtime.GOOS == "windows" {
			scriptfile := filepath.Join(t.TempDir(), scriptfilename)
			if err := os.WriteFile(scriptfile, b.Bytes(), 0777); err != nil {
				t.Fatal(err)
			}
			cmd = testenv.Command(t, "cmd.exe", "/C", scriptfile)
		} else {
			cmd = testenv.Command(t, "sh", "-c", b.String())
		}
		out, err := cmd.Output()
		t.Log(string(out))

const bitSize16 = 2

func fileInfoFromStat(d *syscall.Dir) *fileStat {
	fs := &fileStat{
		name:    d.Name,
		size:    d.Length,
		modTime: time.Unix(int64(d.Mtime), 0),
		sys:     d,
	}
	fs.mode = FileMode(d.Mode & 0777)
	if d.Mode&syscall.DMDIR != 0 {
		fs.mode |= ModeDir
	}
	if d.Mode&syscall.DMAPPEND != 0 {
		fs.mode |= ModeAppend
	}
	if d.Mode&syscall.DMEXCL != 0 {
		fs.mode |= ModeExclusive
	}

	if err != nil {
		err = msgp.WrapError(err, "LimitInBytesPerSecond")
		return
	}
	// write "CurrentBandwidthInBytesPerSecond"
	err = en.Append(0xd9, 0x20, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x61, 0x6e, 0x64, 0x77, 0x69, 0x64, 0x74, 0x68, 0x49, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x50, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64)
	if err != nil {
		return
	}
	err = en.WriteFloat64(z.CurrentBandwidthInBytesPerSecond)

// For x >= 8, the asymptotic expansions of qone is
//      3/8 s - 105/1024 s**3 - ..., where s = 1/x.
// We approximate qone by
//      qone(x) = s*(0.375 + (R/S))
// where R = qr1*s**2 + qr2*s**4 + ... + qr5*s**10
//       S = 1 + qs1*s**2 + ... + qs6*s**12
// and
//      | qone(x)/s -0.375-R/S | <= 2**(-61.13)

// for x in [inf, 8] = 1/[0,0.125]
var q1R8 = [6]float64{
	0.00000000000000000000e+00,  // 0x0000000000000000

>>> Flow 1 (client to server)
00000000  16 03 01 00 39 01 00 00  35 03 01 eb 78 34 78 f6  |....9...5...x4x.|
00000010  8f 87 2f ee 5e da ee 37  5d 0a d5 79 d5 0e db b1  |../.^..7]..y....|
00000020  b7 03 37 1f 2d ce 04 b9  2d 65 d7 00 00 04 00 05  |..7.-...-e......|
00000030  00 ff 01 00 00 08 00 16  00 00 00 17 00 00        |..............|
>>> Flow 2 (server to client)
00000000  16 03 01 00 35 02 00 00  31 03 01 00 00 00 00 00  |....5...1.......|