// That is, it tests for the [ModeDir] bit being set in m.
func (m FileMode) IsDir() bool {
	return m&ModeDir != 0
}

// IsRegular reports whether m describes a regular file.
// That is, it tests that no mode type bits are set.
func (m FileMode) IsRegular() bool {
	return m&ModeType == 0
}

// Perm returns the Unix permission bits in m (m & [ModePerm]).
func (m FileMode) Perm() FileMode {

import "p"

type _ = int
type a = struct{ x int }
type b = p.B

type (
	_ = chan<- int
	aa = interface{}
	bb = p.BB
)

// TODO(gri) We may want to put the '=' into a separate column if
// we have mixed (regular and alias) type declarations in a group.
type (
	_ chan<- int
	_ = chan<- int
	aa0 interface{}
	aaa = interface{}
	bb0 p.BB
	bbb = p.BB

        dirVar.set((File) null)
        !dirVar.present
        dirVar.getOrNull() == null
        !fileProvider.present
        fileProvider.getOrNull() == null
    }

    def "can create regular file property"() {
        def pathProvider = Stub(ProviderInternal)
        _ * pathProvider.get() >> { "../some-file" }
        _ * pathProvider.present >> true
        def otherFile = tmpDir.file("some-file")

			}
		}
		for lab := range s.NumLabel {
			if matchRemove(lab) {
				delete(s.NumLabel, lab)
			}
		}
	}
	return
}

// matchesName returns whether the location matches the regular
// expression. It checks any available function names, file names, and
// mapping object filename.
func (loc *Location) matchesName(re *regexp.Regexp) bool {
	for _, ln := range loc.Line {

 */
@FunctionalInterface
public interface IoRunnable {
    void run() throws IOException;

    /**
     * Wraps an {@link IOException}-throwing {@link IoRunnable} into a regular {@link Runnable}.
     *
     * Any {@code IOException}s are rethrown as {@link UncheckedIOException}.
     */
    static Runnable wrap(IoRunnable runnable) {
        return () -> {
            try {

import org.gradle.internal.service.scopes.Scope;

import java.io.File;

@EventScope(Scope.Build.class)
public interface FileResourceListener {
    /**
     * Called when a file system resource is accessed as a regular file.
     */
    void fileObserved(File file);

    /**
     * Called when the children of a file system resource are listed.
     */
    void directoryChildrenObserved(File file);

	switch s {
	default:
		name = "unrecognized"
	case Small:
		name = "small"
	case Large:
		name = "large"
	}
	return []byte(name), nil
}

func Example_textMarshalJSON() {
	blob := `["small","regular","large","unrecognized","small","normal","small","large"]`
	var inventory []Size
	if err := json.Unmarshal([]byte(blob), &inventory); err != nil {
		log.Fatal(err)
	}

	counts := make(map[Size]int)

		description string
		path        *field.Path
		haveSpec    *api.PodSpec
		wantNames   []string
	}{
		{
			"empty podspec",
			field.NewPath("spec"),
			&api.PodSpec{},
			[]string{},
		},
		{
			"regular containers",
			field.NewPath("spec"),
			&api.PodSpec{
				Containers: []api.Container{
					{Name: "c1"},
					{Name: "c2"},
				},
			},
			[]string{"spec.containers[0]", "spec.containers[1]"},
		},
		{

			// raw device files on Linux, POSIX FIFO special files, and so on), so
			// to avoid files changing unpredictably from regular to irregular we will
			// consider DEDUP files to be close enough to regular to treat as such.
		default:
			m |= ModeIrregular
		}
	}
	return
}

// modePreGo1_23 returns the FileMode for the fileStat, using the pre-Go 1.23

	if err == nil {
		msg += ": OK\n"
	} else {
		msg += fmt.Sprintf(": %v\n", err)
	}
	scope.Debug(msg)
}

// match compiles the string to a regular expression.
var match = regexp.MustCompile

// literal compiles s into a literal regular expression, escaping any regexp
// reserved characters.
func literal(s string) *regexp.Regexp {
	re := match(regexp.QuoteMeta(s))