# safe - no methods called
github.com/51reboot/golang-02-homework@v0.0.0-20180203014111-70b045a3c800/lesson3/binggan/dir.go:22:
	>>		infos, err = f.Readdir(-1)
		}

# safe - more than Name and IsDir
github.com/henvic/vendorlicenses@v0.0.0-20171001071611-9fb760c55859/vendorlicenses.go:161:
	>>		fis, err := ioutil.ReadDir(dir)

			if err != nil {
				return false, err
			}

			for _, fi := range fis {
				if fi.IsDir() || fi.Size() == 0 {
					continue
				}

				if !strings.HasPrefix(fi.Name(), ".") {
					return true, nil
				}
			}

			return false, nil
		}

# safe - Name and IsDir only
github.com/logV/sybil@v0.5.0/src/lib/table_recover_info.go:93:
	>>	files, _ := ioutil.ReadDir(path.Join(*FLAGS.DIR, t.Name))

		var wg sync.WaitGroup
		t.init_data_structures()

		saved_table := Table{Name: t.Name}
		saved_table.init_data_structures()

		this_block := 0
		m := &sync.Mutex{}

		type_counts := make(map[string]map[int]int)

		broken_mutex := sync.Mutex{}
		broken_blocks := make([]string, 0)
		for f := range files {

			v := files[f]
			if v.IsDir() && file_looks_like_block(v) {
				filename := path.Join(*FLAGS.DIR, t.Name, v.Name())
				this_block++

# safe - more than Name and IsDir
github.com/ehazlett/caddy@v0.11.0/caddytls/filestorage.go:261:
	>>		userDirs, err := ioutil.ReadDir(s.users())
			if err != nil {
				return ""
			}
			var mostRecent os.FileInfo
			for _, dir := range userDirs {
				if !dir.IsDir() {
					continue
				}
				if mostRecent == nil || dir.ModTime().After(mostRecent.ModTime()) {
					mostRecent = dir
				}
			}
			if mostRecent != nil {
				return mostRecent.Name()
			}
			return ""
		}

		// fileSafe standardizes and sanitizes str for use in a file path.
		func fileSafe(str string) string {

# safe - no methods called
github.com/dotcloud/docker@v0.0.0-20190607191414-238f8eaa31aa/daemon/graphdriver/aufs/aufs_test.go:693:
	>>		files, err := ioutil.ReadDir(point)
			assert.NilError(t, err)
			assert.Check(t, is.Len(files, expected))
		}

		func TestMountMoreThan42Layers(t *testing.T) {
			defer os.RemoveAll(tmpOuter)
			testMountMoreThan42Layers(t, tmp)
		}

		func TestMountMoreThan42LayersMatchingPathLength(t *testing.T) {
			defer os.RemoveAll(tmpOuter)
			zeroes := "0"
			for {
				// This finds a mount path so that when combined into aufs mount options
				// 4096 byte boundary would be in between the paths or in permission
				// section. For '/tmp' it will use '/tmp/aufs-tests/00000000/aufs'
				mountPath := path.Join(tmpOuter, zeroes, "aufs")
				pathLength := 77 + len(mountPath)

				if mod := 4095 % pathLength; mod == 0 || mod > pathLength-2 {

# safe - Name and IsDir only
github.com/kubernetes/helm@v2.16.5+incompatible/internal/third_party/dep/fs/fs.go:122:
	>>	entries, err := ioutil.ReadDir(src)
		if err != nil {
			return errors.Wrapf(err, "cannot read directory %s", dst)
		}

		for _, entry := range entries {
			srcPath := filepath.Join(src, entry.Name())
			dstPath := filepath.Join(dst, entry.Name())

			if entry.IsDir() {
				if err = CopyDir(srcPath, dstPath); err != nil {
					return errors.Wrap(err, "copying directory failed")
				}
			} else {
				// This will include symlinks, which is what we want when
				// copying things.
				if err = copyFile(srcPath, dstPath); err != nil {
					return errors.Wrap(err, "copying file failed")
				}
			}
		}

# safe - Name only
github.com/wawa0210/kubernetes@v1.17.0-alpha.0/pkg/kubelet/kubelet_getters.go:301:
	>>		volumePluginDirs, err := ioutil.ReadDir(podVolDir)
			if err != nil {
				klog.Errorf("Could not read directory %s: %v", podVolDir, err)
				return volumes, err
			}
			for _, volumePluginDir := range volumePluginDirs {
				volumePluginName := volumePluginDir.Name()
				volumePluginPath := filepath.Join(podVolDir, volumePluginName)
				volumeDirs, err := utilpath.ReadDirNoStat(volumePluginPath)
				if err != nil {
					return volumes, fmt.Errorf("Could not read directory %s: %v", volumePluginPath, err)
				}
				for _, volumeDir := range volumeDirs {
					volumes = append(volumes, filepath.Join(volumePluginPath, volumeDir))
				}
			}
			return volumes, nil
		}

		func (kl *Kubelet) getMountedVolumePathListFromDisk(podUID types.UID) ([]string, error) {
			mountedVolumes := []string{}

# safe - no methods called
github.com/kubernetes/utils@v0.0.0-20191218082557-f07c713de883/mount/mount_helper_test.go:131:
	>>		_, err := ioutil.ReadDir(dir)
			if os.IsNotExist(err) {
				return nil
			}
			if err != nil {
				return err
			}
			return fmt.Errorf("dir %q still exists", dir)
		}

# safe - Name only
github.com/ironstar-io/tokaido@v0.0.0-20191125110708-9beb33da8ed0/system/fs/project_root.go:29:
	>>		files, err := ioutil.ReadDir(path)
			if err != nil {
				log.Fatal(err)
			}

			for _, f := range files {
				if f.Name() == constants.GitDirectory || f.Name() == constants.DockerComposeTokFile {
					return true
				}
			}

			return false
		}

		// ScanUp ...
		func ScanUp(path string) string {
			sd := filepath.Dir(path)

			if IsProjectRoot(sd) == true {
				return sd
			}

# safe - Name only
github.com/fe0b6/imgopti@v0.0.0-20190620071027-37adaab71138/go/main.go:297:
	>>	files, err := ioutil.ReadDir(path)
		if err != nil {
			log.Println("[error]", err)
			w.WriteHeader(500)
			w.Write([]byte(err.Error()))
			return
		}

		ans := []fileData{}
		for _, f := range files {
			b, err := ioutil.ReadFile(path + f.Name())
			if err != nil {
				log.Println("[error]", err)
				w.WriteHeader(500)
				w.Write([]byte(err.Error()))
				return
			}

			d := strings.Split(f.Name(), ".")

			fd := fileData{

# safe - Name and IsDir only
github.com/xuperchain/xuperunion@v0.0.0-20191217122640-70bbc0e10f66/cmd/cli/comm_trans.go:481:
	>>	dir, err := ioutil.ReadDir(path)
		if err != nil {
			return nil, err
		}
		for _, fi := range dir {
			if fi.IsDir() {
				sk, err := readPrivateKey(path + "/" + fi.Name())
				if err != nil {
					return nil, err
				}
				pk, err := readPublicKey(path + "/" + fi.Name())
				if err != nil {
					return nil, err
				}
				signTx, err := txhash.ProcessSignTx(cryptoClient, tx, []byte(sk))
				if err != nil {
					return nil, err
				}
				signInfo := &pb.SignatureInfo{
					PublicKey: pk,
					Sign:      signTx,

# safe - Name and IsDir only
github.com/schollz/gojot@v4.0.0+incompatible/src/gojot.go:145:
	>>		files, err := ioutil.ReadDir(cacheFolder)
			if err != nil {
				return
			}
			for _, f := range files {
				p := path.Join(cacheFolder, f.Name())
				fi, err2 := os.Stat(p)
				if err2 != nil {
					err = err2
					return
				}
				if fi.IsDir() {
					repo, err := gogit.GetRemoteOriginURL(p)
					if err != nil {
						continue
					}
					repos[repo] = p
				}
			}
			return
		}

# safe - Name and IsDir only
github.com/pathcl/containerd@v1.3.2/runtime/v1/linux/runtime.go:277:
	>>	dir, err := ioutil.ReadDir(r.state)
		if err != nil {
			return nil, err
		}
		var o []*Task
		for _, namespace := range dir {
			if !namespace.IsDir() {
				continue
			}
			name := namespace.Name()
			// skip hidden directories
			if len(name) > 0 && name[0] == '.' {
				continue
			}
			log.G(ctx).WithField("namespace", name).Debug("loading tasks in namespace")
			tasks, err := r.loadTasks(ctx, name)
			if err != nil {
				return nil, err
			}
			o = append(o, tasks...)
		}

# safe - no methods called
github.com/DataDog/nats-streaming-server@v0.16.2-1/server/clustering_test.go:6363:
	>>	snaps, err := ioutil.ReadDir(filepath.Join(defaultRaftLog, "c", clusterName, "snapshots"))
		if err != nil {
			t.Fatalf("Error reading snapshots directory: %v", err)
		}
		if len(snaps) == 0 {
			t.Skip("Snapshot was not installed, skipping test")
		}

		// Shutdown all servers, then restart s3.
		s1.Shutdown()
		s2.Shutdown()
		s3.Shutdown()

		// Since s3 will have made a snapshot of its own, the only way it
		// would get stuck waiting for a leader is if its store is not
		// consistent with the snapshot info. So remove s3's message dat file.
		if err := os.Remove(filepath.Join(defaultDataStore, "c", "foo", "msgs.1.dat")); err != nil {
			t.Fatalf("error removing file: %v", err)
		}

		errCh := make(chan error, 1)

# safe - Name only
github.com/majestrate/nntpchan@v3.1.0+incompatible/contrib/backends/srndv2/src/srnd/store.go:749:
	>>		infos, err := ioutil.ReadDir(self.spamdir)
			if err == nil {
				for idx := range infos {
					err = v(infos[idx])
					if err != nil {
						break
					}
				}
			}
			return err
		}

		func (self *articleStore) IterSpam(v func(string) error) error {
			return self.iterSpamFiles(func(i os.FileInfo) error {
				fname := i.Name()
				if ValidMessageID(fname) {
					return v(fname)
				}
				return nil
			})
		}

# safe - Name and IsDir only
github.com/superhasty/kratos@v0.1.0/pkg/conf/paladin/file.go:165:
	>>		files, err := ioutil.ReadDir(base)
			if err != nil {
				return nil, fmt.Errorf("paladin: read dir %s error: %s", base, err)
			}
			for _, file := range files {
				if !file.IsDir() {
					paths = append(paths, path.Join(base, file.Name()))
				}
			}
		} else {
			paths = append(paths, base)
		}
		if len(paths) == 0 {
			return nil, errors.New("empty config path")
		}
		values := make(map[string]*Value, len(paths))
		for _, fpath := range paths {
			if values[path.Base(fpath)], err = loadValue(fpath); err != nil {
				return nil, err
			}
		}

# safe - Name and IsDir only
simonwaldherr.de/go/golibs@v0.10.0/file/file.go:254:
	>>		list, err := file.Readdir(-1)

			if err != nil {
				return err
			}
			for _, fi := range list {
				path, _ := filepath.Abs(dirname + string(os.PathSeparator) + fi.Name())
				isDir := fi.IsDir()
				split := strings.Split(fi.Name(), ".")
				suffix := split[len(split)-1:][0] // if you want the real filetype, use http.DetectContentType
				fnc(fi.Name(), suffix, path, isDir, fi)
				if recursive && isDir {
					err = Each(path, recursive, fnc)
					if err != nil {
						return err
					}
				}
			}
			return nil
		}

# safe - more than Name and IsDir
github.com/hashicorp/runc@v1.0.0-rc5/list.go:126:
	>>	list, err := ioutil.ReadDir(absRoot)
		if err != nil {
			fatal(err)
		}

		var s []containerState
		for _, item := range list {
			if item.IsDir() {
				// This cast is safe on Linux.
				stat := item.Sys().(*syscall.Stat_t)
				owner, err := user.LookupUid(int(stat.Uid))
				if err != nil {

# safe - more than Name and IsDir
github.com/golang/go/src@v0.0.0-20191231121124-bbd25d26c0a8/go/build/build.go:191:
	>>		return ioutil.ReadDir(path)
		}

		// openFile calls ctxt.OpenFile (if not nil) or else os.Open.
		func (ctxt *Context) openFile(path string) (io.ReadCloser, error) {
			if fn := ctxt.OpenFile; fn != nil {
				return fn(path)
			}

			f, err := os.Open(path)
			if err != nil {
				return nil, err // nil interface
			}
			return f, nil
		}

		// isFile determines whether path is a file by trying to open it.
		// It reuses openFile instead of adding another function to the
		// list in Context.
		func (ctxt *Context) isFile(path string) bool {
			f, err := ctxt.openFile(path)

# safe - Name and IsDir only
github.com/rancher/kubernetes@v1.18.0-k3s.1/cmd/kubeadm/app/util/kustomize/kustomize.go:154:
	>>		files, err := ioutil.ReadDir(ldr.Root())
			if err != nil {
				return err
			}
			for _, fileInfo := range files {
				if fileInfo.IsDir() {
					continue
				}

				smp, err := newStrategicMergeSliceFromFile(ldr, fileInfo.Name())
				if err != nil {
					return err
				}
				km.strategicMergePatches = append(km.strategicMergePatches, smp...)
			}
			return nil
		}

		// Kustomize apply a set of patches to a resource.
		// Portions of the kustomize logic in this function are taken from the kubernetes-sigs/kind project
		func (km *Manager) Kustomize(data []byte) ([]byte, error) {

# safe - Name only
github.com/stevenh/docker@v1.9.1-rc1/integration-cli/docker_cli_save_load_test.go:249:
	>>	dirs, err := ioutil.ReadDir(extractionDirectory)
		c.Assert(err, checker.IsNil, check.Commentf("failed to get a listing of the layer directories: %s", err))

		found := false
		for _, entry := range dirs {
			var entriesSansDev []string
			if entry.IsDir() {
				layerPath := filepath.Join(extractionDirectory, entry.Name(), "layer.tar")

				f, err := os.Open(layerPath)
				c.Assert(err, checker.IsNil, check.Commentf("failed to open %s: %s", layerPath, err))

				entries, err := listTar(f)
				for _, e := range entries {
					if !strings.Contains(e, "dev/") {
						entriesSansDev = append(entriesSansDev, e)
					}
				}
				c.Assert(err, checker.IsNil, check.Commentf("encountered error while listing tar entries: %s", err))

				if reflect.DeepEqual(entriesSansDev, layerEntries) || reflect.DeepEqual(entriesSansDev, layerEntriesAUFS) {

# safe - Name only
github.com/Bytom/bytom@v0.0.0-20190731114839-aa9dc6633119/crypto/sm2/cert_pool.go:77:
	>>			fis, err := ioutil.ReadDir(directory)
				if err != nil {
					if firstErr == nil && !os.IsNotExist(err) {
						firstErr = err
					}
					continue
				}
				rootsAdded := false
				for _, fi := range fis {
					data, err := ioutil.ReadFile(directory + "/" + fi.Name())
					if err == nil && roots.AppendCertsFromPEM(data) {
						rootsAdded = true
					}
				}
				if rootsAdded {
					return roots, nil
				}
			}

			return nil, firstErr
		}

# safe - Name only
github.com/srijeet0406/trickster@v0.0.13/filesystem.go:92:
	>>	files, err := ioutil.ReadDir(c.Config.CachePath)
		if err == nil {
			for _, file := range files {
				if strings.HasSuffix(file.Name(), ".expiration") {
					cacheKey := strings.Replace(file.Name(), ".expiration", "", 1)
					expFile, dataFile := c.getFileNames(cacheKey)
					mtx := c.getMutex(cacheKey)
					mtx.Lock()
					content, err := ioutil.ReadFile(expFile)
					if err == nil {
						expiration, err := strconv.ParseInt(string(content), 10, 64)
						if err != nil || expiration < now {
							level.Debug(c.T.Logger).Log("event", "filesystem cache reap", "key", cacheKey, "dataFile", dataFile)

							// Get a lock
							c.T.ChannelCreateMtx.Lock()

							// Delete the key
							os.Remove(expFile)
							os.Remove(dataFile)


# safe - no methods called
github.com/hanwen/go-fuse@v0.0.0-20190726130028-2f298055551b/posixtest/test.go:152:
	>>			infos, err := ioutil.ReadDir("/proc/self/fd")
				if err != nil {
					t.Errorf("ReadDir %v", err)
				}

				if len(infos) > 15 {
					t.Errorf("found %d open file descriptors for 100x ReadFile", len(infos))
				}
			}
		}

		func MkdirRmdir(t *testing.T, mnt string) {
			fn := mnt + "/dir"

			if err := os.Mkdir(fn, 0755); err != nil {
				t.Fatalf("Mkdir: %v", err)
			}

			if fi, err := os.Lstat(fn); err != nil {
				t.Fatalf("Lstat %v", err)
			} else if !fi.IsDir() {

# safe - Name and IsDir only
github.com/diamanticom/kubernetes@v1.9.9/pkg/kubelet/volumemanager/reconciler/reconciler.go:618:
	>>	podsDirInfo, err := ioutil.ReadDir(podDir)
		if err != nil {
			return nil, err
		}
		volumes := []podVolume{}
		for i := range podsDirInfo {
			if !podsDirInfo[i].IsDir() {
				continue
			}
			podName := podsDirInfo[i].Name()
			podDir := path.Join(podDir, podName)

			// Find filesystem volume information
			// ex. filesystem volume: /pods/{podUid}/volume/{escapeQualifiedPluginName}/{volumeName}
			volumesDirs := map[v1.PersistentVolumeMode]string{
				v1.PersistentVolumeFilesystem: path.Join(podDir, config.DefaultKubeletVolumesDirName),
			}
			// TODO: remove feature gate check after no longer needed
			if utilfeature.DefaultFeatureGate.Enabled(features.BlockVolume) {
				// Find block volume information
				// ex. block volume: /pods/{podUid}/volumeDevices/{escapeQualifiedPluginName}/{volumeName}

# safe - no methods called
github.com/mikeraimondi/gurnel@v1.2.0/internal/gurnel/start_test.go:92:
	>>					files, _ = ioutil.ReadDir(dir)
					}

					defer test.WriteFile(t, filepath.Join(dir, file.Name()), tC.input)()

					err := <-errC
					test.CheckErr(t, tC.err, err)

					test.CheckOutput(t, tC.out, out.String())
				})
			}
		}

# safe - Name only
github.com/ahornerr/handlers@v1.4.3-0.20200130185927-f91c10b71af5/logging_test.go:71:
	>>	tmpFiles, err := ioutil.ReadDir(os.TempDir())
		if err != nil {
			t.Fatalf("Failed to list %s: %v", os.TempDir(), err)
		}

		var tmpFile string
		for _, f := range tmpFiles {
			if !strings.HasPrefix(f.Name(), "multipart-") {
				continue
			}

			path := filepath.Join(os.TempDir(), f.Name())
			switch b, err := ioutil.ReadFile(path); {
			case err != nil:
				t.Fatalf("Failed to read %s: %v", path, err)
			case string(b) != contents:
				continue
			default:
				tmpFile = path
				break
			}

# safe - Name only
github.com/themester/afero@v1.1.0/afero_test.go:610:
	>>			subInfo, err := sub.Readdir(-1)
				if err != nil {
					t.Fatal(err)
				}
				var namesSub = []string{}
				for _, e := range subInfo {
					namesSub = append(namesSub, e.Name())
				}

				findNames(fs, t, tDir, testSubDir, namesRoot, namesSub)
			}
		}

		func findNames(fs Fs, t *testing.T, tDir, testSubDir string, root, sub []string) {
			var foundRoot bool
			for _, e := range root {
				f, err := fs.Open(filepath.Join(tDir, e))
				if err != nil {
					t.Error("Open", filepath.Join(tDir, e), ":", err)
				}
				defer f.Close()

# safe - more than Name and IsDir
github.com/czxichen/configmanage@v0.0.0-20180425054600-ccc950611237/server/getconfig.go:21:
	>>	info, err := F.Readdir(-1)
		if err != nil {
			return err
		}
		var list infos
		for _, i := range info {
			if strings.Contains(i.Name(), "server_") && strings.Contains(i.Name(), ".zip") {
				list = append(list, i)
			}
		}
		if len(list) <= 0 {
			return errors.New("Not found valid server package")
		}
		sort.Sort(list)
		spkg := list[0].Name()
		str := strings.TrimLeft(spkg, "server_")
		str = strings.TrimRight(str, ".zip")
		m, err := getmd5(Templatedir + spkg)
		if err != nil {
			return err
		}

# safe - Name only
github.com/janbernloehr/jfrog-client-go@v0.1.3/utils/io/fileutils/files.go:138:
	>>	files, _ := ioutil.ReadDir(path)
		path = strings.TrimPrefix(path, "."+sep)

		for _, f := range files {
			filePath := path + f.Name()
			exists, err := IsFileExists(filePath, false)
			if err != nil {
				return nil, err
			}
			if exists || IsPathSymlink(filePath) {
				fileList = append(fileList, filePath)
			} else if includeDirs {
				isDir, err := IsDirExists(filePath, false)
				if err != nil {
					return nil, err
				}
				if isDir {
					fileList = append(fileList, filePath)
				}
			}
		}

# safe - Name only
github.com/yousong/tools@v0.0.0-20191028041046-a3599409985d/internal/imports/fix.go:111:
	>>	packageFileInfos, err := ioutil.ReadDir(srcDir)
		if err != nil {
			return nil
		}

		var files []*ast.File
		for _, fi := range packageFileInfos {
			if fi.Name() == fileBase || !strings.HasSuffix(fi.Name(), ".go") {
				continue
			}
			if !considerTests && strings.HasSuffix(fi.Name(), "_test.go") {
				continue
			}

			f, err := parser.ParseFile(fset, filepath.Join(srcDir, fi.Name()), nil, 0)
			if err != nil {
				continue
			}

			files = append(files, f)
		}

# safe - Name only
github.com/szli/influxdb@v1.6.204/tsdb/engine/tsm1/file_store.go:481:
	>>	tmpfiles, err := ioutil.ReadDir(f.dir)
		if err != nil {
			return err
		}
		ext := fmt.Sprintf(".%s", TmpTSMFileExtension)
		for _, fi := range tmpfiles {
			if fi.IsDir() && strings.HasSuffix(fi.Name(), ext) {
				ss := strings.Split(filepath.Base(fi.Name()), ".")
				if len(ss) == 2 {
					if i, err := strconv.Atoi(ss[0]); err != nil {
						if i > f.currentTempDirID {
							f.currentTempDirID = i
						}
					}
				}
			}
		}

		files, err := filepath.Glob(filepath.Join(f.dir, fmt.Sprintf("*.%s", TSMFileExtension)))
		if err != nil {
			return err

# safe - no methods called
gitlab.com/svenfinke/edm@v0.0.2/manager/type_zip_test.go:43:
	>>		files, _ := ioutil.ReadDir("/tmp/edm")
			var numberOfFilesBefore = len(files)

			if err := dep.Fetch(); err != nil {
				t.Errorf("Fetch failed: %s", err)
			}

			files, _ = ioutil.ReadDir("/tmp/edm")
			var numberOfFilesAfter = len(files)

			if _, err := os.Stat(targetPath + "/bar.txt"); err != nil {
				t.Errorf("File bar.txt not found in %s", targetPath)
			}
			if _, err := os.Stat(targetPath + "/foo.txt"); err != nil {
				t.Errorf("File foo.txt not found in %s", targetPath)
			}

			if numberOfFilesBefore < numberOfFilesAfter {
				t.Errorf("The tmp file has not been deleted")
			}
		})

# safe - Name only
github.com/youzan/nsq@v0.3.7-HA.1.9.9/nsqd/diskqueue_writer_test.go:140:
	>>		files, err := ioutil.ReadDir(tmpDir)
			if err != nil {
				panic(err)
			}

			for _, file := range files {
				fileName := file.Name()
				if strings.Contains(fileName, ".offsetmate.dat") {
					num, _ := strconv.Atoi(strings.Split(fileName, ".")[2])
					assert(t, num >= 100, "Offset metadata which not larger than 100 is not clean.")
				}
			}
		}

		type customeOffset struct {
			offset int64
		}

		func (co *customeOffset) Offset() BackendOffset {
			return BackendOffset(co.offset)
		}

# safe - Name and IsDir only
github.com/osuripple/cheesegull@v1.2.0/cmd/cheesegull-migrate-mirror/main.go:63:
	>>	files, err := ioutil.ReadDir("data/s/")
		if err != nil {
			return err
		}

		bar := pb.StartNew(len(files))
		bar.Start()

		for _, file := range files {
			bar.Increment()
			if file.IsDir() {
				continue
			}
			f, err := ioutil.ReadFile("data/s/" + file.Name())
			if err != nil {
				return err
			}

			var s cheesegull.BeatmapSet
			err = json.Unmarshal(f, &s)
			if err != nil {

# safe - Name only
github.com/lonelycode/tyk@v1.9.2-0.20191211121100-99e2a7cbfecd/gateway/coprocess_python.go:214:
	>>		bundles, _ := ioutil.ReadDir(bundlePath)
			for _, f := range bundles {
				if f.IsDir() {
					fullPath := filepath.Join(bundlePath, f.Name())
					directories = append(directories, fullPath)
				}
			}
			return directories
		}

		// NewPythonDispatcher wraps all the actions needed for this CP.
		func NewPythonDispatcher() (dispatcher coprocess.Dispatcher, err error) {
			workDir := config.Global().CoProcessOptions.PythonPathPrefix
			if workDir == "" {
				tykBin, _ := os.Executable()
				workDir = filepath.Dir(tykBin)
				log.WithFields(logrus.Fields{
					"prefix": "coprocess",
				}).Debugf("Python path prefix isn't set, using '%s'", workDir)
			}
			dispatcherPath := filepath.Join(workDir, "coprocess", "python")

# safe - Name and IsDir only
istio.io/operator@v1.3.0/pkg/vfs/vfs.go:95:
	>>		fs, err := dir.Readdir(-1)
			if err != nil {
				return nil, err
			}
			var out []string
			for _, f := range fs {
				if !f.IsDir() {
					out = append(out, filepath.Join(prefix, f.Name()))
					continue
				}
				nfs, err := getFilesRecursive(prefix, f)
				if err != nil {
					return nil, err
				}
				out = append(out, nfs...)
			}
			return out, nil
		}

# safe - Name and IsDir only
github.com/chennqqi/goutils@v0.1.3/utils/file.go:55:
	>>		dir, err := ioutil.ReadDir(dirPth)
			if err != nil { //忽略错误
				return nil
			}
			PthSep := string(os.PathSeparator)

			for _, fi := range dir {
				if fi.IsDir() { // 忽略目录
					continue
				}
				newFile := dirPth + PthSep + fi.Name()
				if !checkSuffix(newFile) {
					continue
				}
				if f(newFile, fi.Name()) != nil {
					return errors.New("user quit")
				}
			}
			return nil
		}

# safe - Name and IsDir only
github.com/runner-mei/ql@v1.1.0/httpfs_test.go:177:
	>>	list, err = d.Readdir(0)
		if err != nil {
			t.Fatal(err)
		}

		if g, e := len(list), 3; g != e {
			t.Fatal(g, e)
		}

		var aB, a5, a6 bool
		for _, v := range list {
			switch v.IsDir() {
			case true:
				switch v.Name() {
				case "b":
					aB = true
				default:
					t.Fatal(v.Name())
				}
			default:
				switch v.Name() {

# safe - no methods called
github.com/davidjfarr/gomplate@v3.5.0+incompatible/tests/integration/inputdir_test.go:63:
	>>	files, err = ioutil.ReadDir(s.tmpDir.Join("out", "inner"))
		assert.NilError(c, err)
		tassert.Len(c, files, 1)

		testdata := []struct {
			path    string
			mode    os.FileMode
			content string
		}{
			{s.tmpDir.Join("out", "eins.txt"), 0644, "eins"},
			{s.tmpDir.Join("out", "inner", "deux.txt"), 0444, "deux"},

# safe - more than Name and IsDir
github.com/ethersphere/swarm@v0.0.0-20190613131100-4744b7c9d747/cmd/swarm/upload_test.go:253:
	>>	files, err := ioutil.ReadDir(tmpDownload)
		for _, v := range files {
			fi, err := os.Stat(path.Join(tmpDownload, v.Name()))
			if err != nil {
				t.Fatalf("got an error: %v", err)
			}

			switch mode := fi.Mode(); {
			case mode.IsRegular():
				if file, err := swarmapi.Open(path.Join(tmpDownload, v.Name())); err != nil {
					t.Fatalf("encountered an error opening the file returned from the CLI: %v", err)
				} else {
					ff := make([]byte, len(data))
					io.ReadFull(file, ff)
					buf := bytes.NewBufferString(data)

					if !bytes.Equal(ff, buf.Bytes()) {
						t.Fatalf("retrieved data and posted data not equal!")
					}
				}
			default:

# safe - Name and IsDir only
github.com/runner-mei/ekanite@v1.3.1/loader.go:130:
	>>	fis, err := d.Readdir(0)
		if err != nil {
			return err
		}
		d.Close()

		// Open all loaders.
		for _, fi := range fis {
			if !fi.IsDir() || strings.HasPrefix(fi.Name(), ".") {
				continue
			}
			indexPath := filepath.Join(pa, fi.Name())
			i, err := OpenLazyIndex(indexPath)
			if err != nil {
				return fmt.Errorf("engine failed to open at index %s: %s", indexPath, err.Error())
			}
			il.idSeed++
			i.loader = il
			i.id = il.idSeed
			log.Printf("engine opened index at %s", indexPath)
			il.allIndexes = append(il.allIndexes, i)

# safe - Name and IsDir only
github.com/kubenext/kubefun@v0.0.2/internal/modules/localcontent/localcontent.go:114:
	>>	fis, err := ioutil.ReadDir(l.root)
		if err != nil {
			return errors.Wrapf(err, "read %s", l.root)
		}

		for _, fi := range fis {
			if fi.IsDir() {
				continue
			}

			ext := filepath.Ext(fi.Name())
			if ext != ".json" {
				continue
			}

			content, err := l.content(fi.Name())
			if err != nil {
				return err
			}

			base := strings.TrimSuffix(fi.Name(), ext)

# safe - no methods called
github.com/jfrog/jfrog-cli-go@v1.22.1-0.20200318093948-4826ef344ffd/buildinfo_test.go:131:
	>>		files, _ := ioutil.ReadDir(buildDir)
			assert.Zero(t, len(files), "'rt bad' command with dry-run failed. The dry-run option has no effect.")

			inttestutils.DeleteBuild(artifactoryDetails.Url, tests.BuildAddDepsBuildName, artHttpDetails)
			os.Chdir(wd)
			cleanArtifactoryTest()
		}

		func TestBuildAddDependencies(t *testing.T) {
			initArtifactoryTest(t)
			// Clean old build tests if exists
			inttestutils.DeleteBuild(artifactoryDetails.Url, tests.BuildAddDepsBuildName, artHttpDetails)

			allFiles := []string{"a1.in", "a2.in", "a3.in", "b1.in", "b2.in", "b3.in", "c1.in", "c2.in", "c3.in"}
			var badTests = []buildAddDepsBuildInfoTestParams{
				{description: "'rt bad' simple cli", commandArgs: []string{"testsdata/a/*"}, expectedDependencies: allFiles},
				{description: "'rt bad' single file", commandArgs: []string{"testsdata/a/a1.in"}, expectedDependencies: []string{"a1.in"}},
				{description: "'rt bad' none recursive", commandArgs: []string{"testsdata/a/*", "--recursive=false"}, expectedDependencies: []string{"a1.in", "a2.in", "a3.in"}},
				{description: "'rt bad' special chars recursive", commandArgs: []string{getSpecialCharFilePath()}, expectedDependencies: []string{"a1.in"}},
				{description: "'rt bad' exclude command line wildcards", commandArgs: []string{"testsdata/a/*", "--exclude-patterns=*a2*;*a3.in"}, expectedDependencies: []string{"a1.in", "b1.in", "b2.in", "b3.in", "c1.in", "c2.in", "c3.in"}},
				{description: "'rt bad' spec", commandArgs: []string{"--spec=" + tests.GetFilePathForArtifactory(tests.BuildAddDepsSpec)}, expectedDependencies: allFiles},

# safe - no methods called
github.com/elastic/gosigar@v0.0.0-20180123065306-16df19fe5efe/sigar_linux.go:63:
	>>		fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
			if err != nil {
				return err
			}
			self.Open = uint64(len(fds))
			return nil
		}

		func parseCpuStat(self *Cpu, line string) error {
			fields := strings.Fields(line)

			self.User, _ = strtoull(fields[1])
			self.Nice, _ = strtoull(fields[2])
			self.Sys, _ = strtoull(fields[3])
			self.Idle, _ = strtoull(fields[4])
			self.Wait, _ = strtoull(fields[5])
			self.Irq, _ = strtoull(fields[6])
			self.SoftIrq, _ = strtoull(fields[7])
			self.Stolen, _ = strtoull(fields[8])

			return nil

# safe - Name only
github.com/go-rtc/stun@v1.22.1/fuzz_test.go:32:
	>>		list, err := f.Readdir(-1)
			if err != nil {
				t.Fatal(err)
			}
			for _, d := range list {
				if strings.Contains(d.Name(), ".") {
					// Skipping non-raw files.
					continue
				}
				df, err := os.Open(filepath.Join(p, d.Name()))
				if err != nil {
					t.Fatal(err)
				}
				buf := make([]byte, 5000)
				n, _ := df.Read(buf)
				data = append(data, buf[:n])
				df.Close()
			}
			return data
		}

# safe - Name only
github.com/wuka1/cli@v0.0.0-20200310094236-c13163327ea1/cli/command/trust/key_generate_test.go:82:
	>>	keyFiles, err := ioutil.ReadDir(expectedPrivKeyDir)
		assert.NilError(t, err)
		assert.Check(t, is.Len(keyFiles, 1))
		privKeyFilePath := filepath.Join(expectedPrivKeyDir, keyFiles[0].Name())

		// verify the key content
		privFrom, _ := os.OpenFile(privKeyFilePath, os.O_RDONLY, notary.PrivExecPerms)
		defer privFrom.Close()
		fromBytes, _ := ioutil.ReadAll(privFrom)
		privKeyPEM, _ := pem.Decode(fromBytes)
		assert.Check(t, is.Equal(keyName, privKeyPEM.Headers["role"]))
		// the default GUN is empty
		assert.Check(t, is.Equal("", privKeyPEM.Headers["gun"]))
		// assert encrypted header
		assert.Check(t, is.Equal("ENCRYPTED PRIVATE KEY", privKeyPEM.Type))
		// check that the passphrase matches
		_, err = tufutils.ParsePKCS8ToTufKey(privKeyPEM.Bytes, []byte(passwd))
		assert.NilError(t, err)

		// check that the public key exists at the correct path if we use the helper:
		returnedPath, err := writePubKeyPEMToDir(pubKeyPEM, keyName, pubKeyCWD)

# safe - more than Name and IsDir
github.com/grailbio/reflow@v0.0.0-20200123221023-5e02dc357ccc/ec2cluster/volume/volume.go:374:
	>>	fileInfoList, err := dir.Readdir(0)
		if err != nil {
			return nil, err
		}
		byDevice := make(map[string]string)
		for _, fileInfo := range fileInfoList {
			if fileInfo.Mode()&os.ModeSymlink != os.ModeSymlink {
				continue
			}
			name := fileInfo.Name()
			resolved, err := filepath.EvalSymlinks(filepath.Join(devDir, name))
			if err != nil {
				return nil, err
			}
			if strings.HasPrefix(name, "nvme-Amazon_Elastic_Block_Store_vol") {
				id := strings.TrimPrefix(name, "nvme-Amazon_Elastic_Block_Store_vol")
				byDevice[resolved] = "vol-" + id
			}
		}
		volIds, missing := make([]string, 0, len(devices)), make([]string, 0, len(devices))
		for _, dev := range devices {

# safe - Name only
github.com/mhilton/juju-juju@v0.0.0-20200306113540-bbcb8d9711a2/worker/uniter/relation/state.go:148:
	>>	fis, err := ioutil.ReadDir(d.path)
		if err != nil {
			return nil, err
		}
		for _, fi := range fis {
			// Entries with names ending in "-" followed by an integer must be
			// files containing valid unit data; all other names are ignored.
			name := fi.Name()
			i := strings.LastIndex(name, "-")
			if i == -1 {
				continue
			}
			svcName := name[:i]
			unitId := name[i+1:]
			isApp := false
			unitOrAppName := ""
			if unitId == "app" {
				isApp = true
				unitOrAppName = svcName
			} else {
				if _, err := strconv.Atoi(unitId); err != nil {

# safe - no methods called
github.com/charlievieth/fs@v0.0.0-20170613215519-7dc373669fa1/fs_test.go:1384:
	>>		{"Readdir", func(f *os.File) error { _, err := f.Readdir(1); return err }},
			{"Readdirnames", func(f *os.File) error { _, err := f.Readdirnames(1); return err }},
			{"Seek", func(f *os.File) error { _, err := f.Seek(0, 0); return err }},
			{"Stat", func(f *os.File) error { _, err := f.Stat(); return err }},
			{"Sync", func(f *os.File) error { return f.Sync() }},
			{"Truncate", func(f *os.File) error { return f.Truncate(0) }},
			{"Write", func(f *os.File) error { _, err := f.Write(make([]byte, 0)); return err }},
			{"WriteAt", func(f *os.File) error { _, err := f.WriteAt(make([]byte, 0), 0); return err }},
			{"WriteString", func(f *os.File) error { _, err := f.WriteString(""); return err }},
		}

		// Test that all File methods give ErrInvalid if the receiver is nil.
		func TestNilFileMethods(t *testing.T) {
			for _, tt := range nilFileMethodTests {
				var file *os.File
				got := tt.f(file)
				if got != os.ErrInvalid {
					t.Errorf("%v should fail when f is nil; got %v", tt.name, got)
				}
			}
		}

# safe - Name only
github.com/anpingli/origin@v1.5.1/pkg/build/builder/cmd/builder.go:187:
	>>		secretFiles, err := ioutil.ReadDir(secretTmpDir)
			if err != nil {
				return "", err
			}
			for _, file := range secretFiles {
				if err := os.Chmod(filepath.Join(secretTmpDir, file.Name()), 0600); err != nil {
					return "", err
				}
			}
			return secretTmpDir, nil
		}

		type dockerBuilder struct{}

		// Build starts a Docker build.
		func (dockerBuilder) Build(dockerClient bld.DockerClient, sock string, buildsClient client.BuildInterface, build *api.Build, gitClient bld.GitClient, cgLimits *s2iapi.CGroupLimits) error {
			return bld.NewDockerBuilder(dockerClient, buildsClient, build, gitClient, cgLimits).Build()
		}

		type s2iBuilder struct{}

# safe - Name and IsDir only
github.com/Fractal-tributary/freegeoip@v0.1.0/utils/gzip_tool_good.go:195:
	>>	fis, err := dir.Readdir(0)
		if err != nil {
			return err
		}

		for _, fi := range fis {
			// Append path
			curPath := srcDir + "/" + fi.Name()

			err := tarGzFile(curPath, recPath+"/"+fi.Name(), tw, fi)
			if err != nil {
				return err
			}

			// Check it is directory or file
			if fi.IsDir() {
				// Directory
				// (Directory won't add unitl all subfiles are added)
				err := tarGzDir(curPath, recPath+"/"+fi.Name(), tw)
				if err != nil {
					return err

# safe - Name and IsDir only
github.com/swiftstack/ProxyFS@v0.0.0-20200305204747-bf0bcb714e68/pfs-restart-test/main.go:361:
	>>	srcDirEntryList, err = ioutil.ReadDir(srcDirPath)
		if nil != err {
			log.Fatalf("unable to read srcDirPath (\"%s\"): %v", srcDirPath, err)
		}
		dstDirEntryList, err = ioutil.ReadDir(dstDirPath)
		if nil != err {
			log.Fatalf("unable to read dstDirPath (\"%s\"): %v", dstDirPath, err)
		}

		srcDirEntryListPruned = make([]os.FileInfo, 0, len(srcDirEntryList))
		dstDirEntryListPruned = make([]os.FileInfo, 0, len(dstDirEntryList))

		for _, srcDirEntry = range srcDirEntryList {
			if ".fseventsd" != srcDirEntry.Name() {
				srcDirEntryListPruned = append(srcDirEntryListPruned, srcDirEntry)
			}
		}
		for _, dstDirEntry = range dstDirEntryList {
			if ".fseventsd" != dstDirEntry.Name() {
				dstDirEntryListPruned = append(dstDirEntryListPruned, dstDirEntry)
			}

# safe - Name only
github.com/arbelt/afero@v1.0.0/unionFile.go:165:
	>>		rfi, err := f.Readdir(c)
			if err != nil {
				return nil, err
			}
			var names []string
			for _, fi := range rfi {
				names = append(names, fi.Name())
			}
			return names, nil
		}

		func (f *UnionFile) Stat() (os.FileInfo, error) {
			if f.layer != nil {
				return f.layer.Stat()
			}
			if f.base != nil {
				return f.base.Stat()
			}
			return nil, BADFD
		}

# safe - more than Name and IsDir
github.com/zgfh/kubectl@v0.18.0-alpha.2/pkg/generate/versioned/secret.go:210:
	>>			fileList, err := ioutil.ReadDir(filePath)
				if err != nil {
					return fmt.Errorf("error listing files in %s: %v", filePath, err)
				}
				for _, item := range fileList {
					itemPath := path.Join(filePath, item.Name())
					if item.Mode().IsRegular() {
						keyName = item.Name()
						if err = addKeyFromFileToSecret(secret, keyName, itemPath); err != nil {
							return err
						}
					}
				}
			} else {
				if err := addKeyFromFileToSecret(secret, keyName, filePath); err != nil {
					return err
				}
			}
		}

		return nil

# safe - Name only
github.com/eshujiushiwo/mongo-tools@v0.0.0-20150622155605-ac81b06dbe8c/mongodump/mongodump_test.go:147:
	>>	fileInfos, err := ioutil.ReadDir(dir)
		if err != nil {
			return err
		}

		for _, fileInfo := range fileInfos {
			fileName := fileInfo.Name()
			if !strings.HasSuffix(fileName, ".bson") || fileName == "system.indexes.bson" {
				continue
			}

			collectionName := fileName[:strings.LastIndex(fileName, ".bson")]
			collection := session.DB(restoreDBName).C(collectionName)

			file, err := os.Open(fmt.Sprintf("%s/%s", dir, fileName))
			if err != nil {
				return err
			}
			defer file.Close()

			bsonSource := db.NewDecodedBSONSource(db.NewBSONSource(file))

# safe - no methods called
k8s.io/kubernetes@v0.0.0-20191231234339-6b5cf90ecd2f/pkg/kubelet/kubelet_volumes_linux_test.go:43:
	>>		_, err := ioutil.ReadDir(dir)
			if os.IsNotExist(err) {
				return nil
			}
			if err != nil {
				return err
			}
			return fmt.Errorf("dir %q still exists", dir)
		}

		func TestCleanupOrphanedPodDirs(t *testing.T) {
			testCases := map[string]struct {
				pods         []*v1.Pod
				prepareFunc  func(kubelet *Kubelet) error
				validateFunc func(kubelet *Kubelet) error
				expectErr    bool
			}{
				"nothing-to-do": {},
				"pods-dir-not-found": {
					prepareFunc: func(kubelet *Kubelet) error {
						return os.Remove(kubelet.getPodsDir())

# safe - Name and IsDir only
github.com/qingwave/kubernetes@v1.19.0-alpha.0/pkg/volume/util/subpath/subpath_linux.go:215:
	>>	containerDirs, err := ioutil.ReadDir(subPathDir)
		if err != nil {
			if os.IsNotExist(err) {
				return nil
			}
			return fmt.Errorf("error reading %s: %s", subPathDir, err)
		}

		for _, containerDir := range containerDirs {
			if !containerDir.IsDir() {
				klog.V(4).Infof("Container file is not a directory: %s", containerDir.Name())
				continue
			}
			klog.V(4).Infof("Cleaning up subpath mounts for container %s", containerDir.Name())

			// scan /var/lib/kubelet/pods/<uid>/volume-subpaths/<volume>/<container name>/*
			fullContainerDirPath := filepath.Join(subPathDir, containerDir.Name())
			err = filepath.Walk(fullContainerDirPath, func(path string, info os.FileInfo, err error) error {
				if path == fullContainerDirPath {
					// Skip top level directory
					return nil

# safe - Name only
github.com/nathan219/go-pg-migrations/v2@v2.0.1/create_test.go:23:
	>>		files, err := ioutil.ReadDir(tmp)
			assert.Nil(t, err)

			found := false
			for _, f := range files {
				if strings.Contains(f.Name(), name) {
					found = true
				}
			}

			assert.Truef(t, found, "expected to find %q migration in %q", name, tmp)
		}

# safe - Name only
github.com/zignig/astralboot@v0.0.0-20180804040320-cc71025bf944/src/astralboot/fs.go:33:
	>>		fi, err := ioutil.ReadDir(fs.base + sl + name)
			names = make([]string, len(fi))
			for i, f := range fi {
				names[i] = f.Name()
			}
			return names, err
		}

		//Get : gets a file as an io.ReadCloser ( don't forget to close )
		func (fs *Diskfs) Get(name string) (f io.ReadCloser, size int64, err error) {
			logger.Debug("FS Get Path : %s", name)
			f, err = os.Open(fs.base + sl + name)
			fi, err := os.Stat(fs.base + sl + name)
			if fi != nil {
				size = fi.Size()
			}
			return f, size, err
		}

		//Stat : checks to see if file system exists
		func (fs *Diskfs) Stat() (stat bool) {

# safe - Name only
github.com/minishift/minishift@v1.34.2/pkg/minishift/profile/profile.go:45:
	>>		files, err := ioutil.ReadDir(profileBaseDir)
			if err != nil {
				return profileList
			}

			for _, f := range files {
				// Skip non-directory and hidden stuffs
				match, _ := regexp.MatchString("^\\.", f.Name())
				if !filehelper.IsDirectory(filepath.Join(profileBaseDir, f.Name())) || match {
					continue
				}
				profileList = append(profileList, f.Name())
			}
			return profileList
		}

		// Set Active Profile and also it makes sure that we have one
		// active profile at one point of time.
		func SetActiveProfile(name string) error {
			activeProfile := config.AllInstancesConfig.ActiveProfile
			if name != activeProfile {

# safe - Name only
github.com/youtube/vitess@v3.0.0-rc.3.0.20190801000458-61621b7d8502+incompatible/go/vt/mysqlctl/builtinbackupengine.go:219:
	>>		fis, err := ioutil.ReadDir(cnf.DataDir)
			if err != nil {
				return nil, err
			}

			for _, fi := range fis {
				p := path.Join(cnf.DataDir, fi.Name())
				if isDbDir(p) {
					result, err = addDirectory(result, backupData, cnf.DataDir, fi.Name())
					if err != nil {
						return nil, err
					}
				}
			}
			return result, nil
		}

		// ExecuteBackup returns a boolean that indicates if the backup is usable,
		// and an overall error.
		func (be *BuiltinBackupEngine) ExecuteBackup(ctx context.Context, cnf *Mycnf, mysqld MysqlDaemon, logger logutil.Logger, bh backupstorage.BackupHandle, backupConcurrency int, hookExtraEnv map[string]string) (bool, error) {

# safe - Name only
github.com/LibiChai/kratos@v0.0.0-20190918051826-38f6fb93e94c/pkg/log/internal/filewriter/filewriter.go:45:
	>>	fis, err := ioutil.ReadDir(dir)
		if err != nil {
			return nil, err
		}

		// parse exists log file filename
		parse := func(s string) (rt rotateItem, err error) {
			// remove filename and left "." error.log.2018-09-12.001 -> 2018-09-12.001
			rt.fname = s
			s = strings.TrimLeft(s[len(fname):], ".")
			seqs := strings.Split(s, ".")
			var t time.Time
			switch len(seqs) {
			case 2:
				if rt.rotateNum, err = strconv.Atoi(seqs[1]); err != nil {
					return
				}
				fallthrough
			case 1:
				if t, err = time.Parse(rotateFormat, seqs[0]); err != nil {
					return

# safe - Name only
github.com/RyanGordon/protoc-gen-doc@v1.3.0/resources/main.go:30:
	>>		files, err := ioutil.ReadDir(inputDir)
			if err != nil {
				log.Fatal(err)
			}

			fd, err := os.Create(outputFile)
			if err != nil {
				log.Fatal(err)
			}

			defer fd.Close()

			w := bufio.NewWriter(fd)
			defer w.Flush()

			w.WriteString(fmt.Sprintf(`// AUTOGENERATED CODE. DO NOT EDIT.

		package %s

		import (
			"bytes"

# safe - Name only
github.com/uadmin/uadmin@v0.4.0/cmd/uadmin/copy.go:93:
	>>		contents, err := ioutil.ReadDir(srcdir)
			if err != nil {
				return err
			}

			for _, content := range contents {
				cs, cd := filepath.Join(srcdir, content.Name()), filepath.Join(destdir, content.Name())
				if err := copy(cs, cd, content); err != nil {
					// If any error, exit immediately
					return err
				}
			}
			return nil
		}

		// lcopy is for a symlink,
		// with just creating a new symlink by replicating src symlink.
		func lcopy(src, dest string, info os.FileInfo) error {
			src, err := os.Readlink(src)
			if err != nil {
				return err

# safe - Name only
github.com/jolheiser/gitea@v1.999.0/modules/options/static.go:63:
	>>		files, err := d.Readdir(-1)
			if err != nil {
				return nil, err
			}
			var results = make([]string, 0, len(files))
			for _, file := range files {
				results = append(results, file.Name())
			}
			return results, nil
		}

		// Locale reads the content of a specific locale from bindata or custom path.
		func Locale(name string) ([]byte, error) {
			return fileFromDir(path.Join("locale", name))
		}

		// Readme reads the content of a specific readme from bindata or custom path.
		func Readme(name string) ([]byte, error) {
			return fileFromDir(path.Join("readme", name))
		}

# safe - more than Name and IsDir
github.com/sshukun/kubernetes@v1.17.0-alpha.1/pkg/volume/util/volumepathhandler/volume_path_handler.go:169:
	>>		files, err := ioutil.ReadDir(mapPath)
			if err != nil {
				return nil, fmt.Errorf("Directory cannot read %v", err)
			}
			for _, file := range files {
				if file.Mode()&os.ModeSymlink != os.ModeSymlink {
					continue
				}
				filename := file.Name()
				fp, err := os.Readlink(filepath.Join(mapPath, filename))
				if err != nil {
					return nil, fmt.Errorf("Symbolic link cannot be retrieved %v", err)
				}
				klog.V(5).Infof("GetDeviceSymlinkRefs: filepath: %v, devPath: %v", fp, devPath)
				if fp == devPath {
					refs = append(refs, filepath.Join(mapPath, filename))
				}
			}
			klog.V(5).Infof("GetDeviceSymlinkRefs: refs %v", refs)
			return refs, nil
		}

# safe - Name and IsDir only
github.com/PointCoin/seelog@v0.0.0-20150206054153-8b40367d2f93/internals_fsutils.go:69:
	>>		allEntities, err := dd.Readdir(-1)
			if err != nil {
				return nil, err
			}
			subDirs := []string{}
			for _, entity := range allEntities {
				if entity.IsDir() {
					subDirs = append(subDirs, entity.Name())
				}
			}
			return subDirs, nil
		}

		// getSubdirAbsPaths recursively visit all the subdirectories
		// starting from the given directory and returns absolute paths for them.
		func getAllSubdirAbsPaths(dirPath string) (res []string, err error) {
			dps, err := getSubdirAbsPaths(dirPath)
			if err != nil {
				res = []string{}
				return
			}

# safe - no methods called
github.com/GenaroNetwork/GenaroCore@v1.0.3/cmd/go-genaro/accountcmd_test.go:118:
	>>		files, err := ioutil.ReadDir(filepath.Join(geth.Datadir, "keystore"))
			if len(files) != 1 {
				t.Errorf("expected one key file in keystore directory, found %d files (error: %v)", len(files), err)
			}
		}

		func TestWalletImportBadPassword(t *testing.T) {
			geth := runGeth(t, "wallet", "import", "--lightkdf", "testdata/guswallet.json")
			defer geth.ExpectExit()
			geth.Expect(`
		!! Unsupported terminal, password will be echoed.
		Passphrase: {{.InputLine "wrong"}}
		Fatal: could not decrypt key with given passphrase
		`)
		}

		func TestUnlockFlag(t *testing.T) {
			datadir := tmpDatadirWithKeystore(t)
			geth := runGeth(t,
				"--datadir", datadir, "--nat", "none", "--nodiscover", "--maxpeers", "0", "--port", "0",
				"--unlock", "f466859ead1932d743d622cb74fc058882e8648a",

# safe - more than Name and IsDir
github.com/cortexproject/cortex@v0.7.1-0.20200316184320-acc42abdf56c/pkg/chunk/local/fs_object_client.go:96:
	>>		filesInfo, err := ioutil.ReadDir(folderPath)
			if err != nil {
				return nil, err
			}

			for _, fileInfo := range filesInfo {
				if fileInfo.IsDir() {
					continue
				}
				storageObjects = append(storageObjects, chunk.StorageObject{
					Key:        filepath.Join(prefix, fileInfo.Name()),
					ModifiedAt: fileInfo.ModTime(),
				})
			}

			return storageObjects, nil
		}

		func (f *FSObjectClient) DeleteObject(ctx context.Context, objectKey string) error {
			err := os.Remove(path.Join(f.cfg.Directory, objectKey))
			if err != nil && os.IsNotExist(err) {

# safe - Name only
github.com/liquidata-inc/vitess@v3.0.0-rc.3+incompatible/go/vt/mysqlctl/backup.go:168:
	>>	fis, err := ioutil.ReadDir(p)
		if err != nil {
			return false
		}
		for _, fi := range fis {
			if strings.HasSuffix(fi.Name(), ".frm") {
				return true
			}

			// .frm files were removed in MySQL 8, so we need to check for two other file types
			// https://dev.mysql.com/doc/refman/8.0/en/data-dictionary-file-removal.html
			if strings.HasSuffix(fi.Name(), ".ibd") {
				return true
			}
			// https://dev.mysql.com/doc/refman/8.0/en/serialized-dictionary-information.html
			if strings.HasSuffix(fi.Name(), ".sdi") {
				return true
			}
		}

		return false

# safe - Name only
github.com/percona/percona-toolkit@v0.0.0-20190425075030-0cd918a835ca/src/go/mongolib/fingerprinter/fingerprinter_test.go:82:
	>>	files, err := ioutil.ReadDir(dir)
		if err != nil {
			t.Fatalf("cannot list samples: %s", err)
		}

		for _, file := range files {
			t.Run(file.Name(), func(t *testing.T) {
				doc := proto.SystemProfile{}
				err = tutil.LoadBson(dir+file.Name(), &doc)
				if err != nil {
					t.Fatalf("cannot load sample %s: %s", dir+file.Name(), err)
				}
				fp := NewFingerprinter(DEFAULT_KEY_FILTERS)
				got, err := fp.Fingerprint(doc)
				if err != nil {
					t.Errorf("cannot create fingerprint: %s", err)
				}
				fExpect := dirExpect + file.Name()
				if tutil.ShouldUpdateSamples() {
					err := tutil.WriteJson(fExpect, got)
					if err != nil {

# safe - more than Name and IsDir
github.com/agnivade/funnel@v0.0.0-20191013085024-5d79a5b493e2/rollup.go:30:
	>>	files, err := ioutil.ReadDir(cfg.DirName)
		if err != nil {
			return "", err
		}

		// Extracting the file names
		var fileNames []string
		for _, file := range files {
			file.ModTime()
			fileNames = append(fileNames, file.Name())
		}
		// Sorting the files in natural order
		sort.Sort(sortorder.Natural(fileNames))

		// Reverse traversing the slice
		for i := len(fileNames) - 1; i >= 0; i-- {
			fileName := fileNames[i]
			// Continuing if its the current file
			if fileName == cfg.ActiveFileName {
				continue
			}

# safe - Name only
github.com/golang/go/src@v0.0.0-20200329020134-5aef51a729f4/os/dir_plan9.go:67:
	>>		fi, err := file.Readdir(n)
			names = make([]string, len(fi))
			for i := range fi {
				names[i] = fi[i].Name()
			}
			return
		}

# safe - Name only
github.com/mjarkk/filedb@v0.0.0-20191217074748-de3fa5680cf5/fileDB.go:236:
	>>		files, err := ioutil.ReadDir(dir)
			for _, file := range files {
				name := file.Name()
				if strings.HasPrefix(name, ".") {
					// We should not touch hidden files
					continue
				}
				if !keysMatchName(name, kvsToMatch) {
					continue
				}
				err := toExec(name)
				if err != nil {
					return err
				}
			}
			return err
		}

		func keysMatchName(fileName string, keyValues []string) bool {
			for _, check := range keyValues {
				if !strings.Contains(fileName, check) {

# safe - Name only
github.com/aghosn/go@v0.0.0-20200306112138-e6ed0986a1d8/test/run.go:881:
	>>	files, dirErr := ioutil.ReadDir(longdir)
		if dirErr != nil {
			t.err = dirErr
			break
		}
		var gos []string
		var asms []string
		for _, file := range files {
			switch filepath.Ext(file.Name()) {
			case ".go":
				gos = append(gos, filepath.Join(longdir, file.Name()))
			case ".s":
				asms = append(asms, filepath.Join(longdir, file.Name()))
			}

		}
		if len(asms) > 0 {
			emptyHdrFile := filepath.Join(t.tempDir, "go_asm.h")
			if err := ioutil.WriteFile(emptyHdrFile, nil, 0666); err != nil {
				t.err = fmt.Errorf("write empty go_asm.h: %s", err)
				return

# safe - no methods called
github.com/arbelt/afero@v1.0.0/afero_test.go:523:
	>>			subInfo, err := sub.Readdir(5)
				if err != nil {
					t.Log(myFileInfo(subInfo))
					t.Error(err)
				}
			}
		}

		func TestReaddir(t *testing.T) {
			defer removeAllTestFiles(t)
			for num := 0; num < 6; num++ {
				outputs := make([]string, len(Fss))
				infos := make([]string, len(Fss))
				for i, fs := range Fss {
					testSubDir := setupTestDir(t, fs)
					//tDir := filepath.Dir(testSubDir)
					root, err := fs.Open(testSubDir)
					if err != nil {
						t.Fatal(err)
					}
					defer root.Close()

# safe - more than Name and IsDir
github.com/rclone/rclone@v1.51.1-0.20200321181642-e569977c0697/backend/local/local.go:378:
	>>		fis, err = fd.Readdir(1024)
			if err == io.EOF && len(fis) == 0 {
				break
			}
		} else {
			// For other OSes we read the names only (which shouldn't fail) then stat the
			// individual ourselves so we can log errors but not fail the directory read.
			var names []string
			names, err = fd.Readdirnames(1024)
			if err == io.EOF && len(names) == 0 {
				break
			}
			if err == nil {
				for _, name := range names {
					namepath := filepath.Join(fsDirPath, name)
					fi, fierr := os.Lstat(namepath)
					if fierr != nil {
						err = errors.Wrapf(err, "failed to read directory %q", namepath)
						fs.Errorf(dir, "%v", fierr)
						_ = accounting.Stats(ctx).Error(fserrors.NoRetryError(fierr)) // fail the sync
						continue

# safe - Name only
github.com/skyjia/etcd@v0.5.0-alpha.5.0.20200227143406-7e08e5dc2578/wal/wal_test.go:257:
	>>		walFiles, err := ioutil.ReadDir(walDir)
			if err != nil {
				t.Fatal(err)
			}

			// corrupt the WAL by truncating one of the WAL files completely
			err = os.Truncate(path.Join(walDir, walFiles[2].Name()), 0)
			if err != nil {
				t.Fatal(err)
			}

			err = Verify(zap.NewExample(), walDir, walpb.Snapshot{})
			if err == nil {
				t.Error("expected a non-nil error, got nil")
			}
		}

		// TODO: split it into smaller tests for better readability
		func TestCut(t *testing.T) {
			p, err := ioutil.TempDir(os.TempDir(), "waltest")
			if err != nil {

# safe - no methods called
github.com/prysmaticlabs/bazel-go-ethereum@v0.0.0-20190929123618-7022a154f56d/cmd/geth/accountcmd_test.go:128:
	>>		files, err := ioutil.ReadDir(filepath.Join(geth.Datadir, "keystore"))
			if len(files) != 1 {
				t.Errorf("expected one key file in keystore directory, found %d files (error: %v)", len(files), err)
			}
		}

		func TestWalletImportBadPassword(t *testing.T) {
			geth := runGeth(t, "wallet", "import", "--lightkdf", "testdata/guswallet.json")
			defer geth.ExpectExit()
			geth.Expect(`
		!! Unsupported terminal, password will be echoed.
		Password: {{.InputLine "wrong"}}
		Fatal: could not decrypt key with given password
		`)
		}

		func TestUnlockFlag(t *testing.T) {
			datadir := tmpDatadirWithKeystore(t)
			geth := runGeth(t,
				"--datadir", datadir, "--nat", "none", "--nodiscover", "--maxpeers", "0", "--port", "0",
				"--unlock", "f466859ead1932d743d622cb74fc058882e8648a",

# safe - Name and IsDir only
github.com/Languege/confbuild@v1.0.1/tpl.go:60:
	>>	dir, err := ioutil.ReadDir(conf.Path)
		if err != nil {
			panic(err)
		}
		PthSep := string(os.PathSeparator)
		for _, fi := range dir {
			if fi.IsDir() { // 忽略目录
				continue
			}
			if strings.HasSuffix(fi.Name(), "json") { //匹配文件
				content, err := ioutil.ReadFile(conf.Path + PthSep + fi.Name())
				if err != nil {
					panic(content)
				}

				table := strings.Split(fi.Name(), ".")[0]
				if table == "" {
					panic(errors.New(fmt.Sprintf("file name %s get failed", fi.Name())))
				}

				confRedis.HSet(GameConfDataKey, table, content)

# safe - Name only
github.com/journeymidnight/seaweedfs@v0.0.0-20190917023228-1f5aa3745774/weed/server/volume_grpc_erasure_coding.go:162:
	>>		fileInfos, err := ioutil.ReadDir(location.Directory)
			if err != nil {
				continue
			}
			for _, fileInfo := range fileInfos {
				if fileInfo.Name() == baseFilename+".ecx" {
					hasEcxFile = true
					continue
				}
				if strings.HasPrefix(fileInfo.Name(), baseFilename+".ec") {
					existingShardCount++
				}
			}
		}

		if hasEcxFile && existingShardCount == 0 {
			if err := os.Remove(baseFilename + ".ecx"); err != nil {
				return nil, err
			}
			if err := os.Remove(baseFilename + ".ecj"); err != nil {
				return nil, err

# safe - Name and IsDir only
github.com/ralfonso/influxdb@v0.6.3/src/api/http/api.go:874:
	>>			entries, err := ioutil.ReadDir(filepath.Join(self.adminAssetsDir, "interfaces"))

				if err != nil {
					return errorToStatusCode(err), err.Error()
				}

				directories := make([]string, 0, len(entries))
				for _, entry := range entries {
					if entry.IsDir() {
						directories = append(directories, entry.Name())
					}
				}
				return libhttp.StatusOK, directories
			})

			w.Header().Add("content-type", contentType)
			w.WriteHeader(statusCode)
			if len(body) > 0 {
				w.Write(body)
			}
		}

# safe - Name only
github.com/containers/storage@v1.17.0/drivers/devmapper/deviceset.go:1278:
	>>		fileInfos, _ := ioutil.ReadDir("/proc/self/fd")
			for _, i := range fileInfos {
				link, _ := os.Readlink(filepath.Join("/proc/self/fd", i.Name()))
				if link == name {
					fd, err := strconv.Atoi(i.Name())
					if err == nil {
						unix.CloseOnExec(fd)
					}
				}
			}
		}

		func major(device uint64) uint64 {
			return (device >> 8) & 0xfff
		}

		func minor(device uint64) uint64 {
			return (device & 0xff) | ((device >> 12) & 0xfff00)
		}

		// ResizePool increases the size of the pool.

# safe - Name only
github.com/ElrondNetwork/elrond-go@v1.0.98-0.20200326215457-f1da0232024c/storage/factory/common.go:72:
	>>	files, err := f.Readdir(-1)
		_ = f.Close()

		if err != nil {
			return 0, err
		}

		epochDirs := make([]string, 0, len(files))
		for _, file := range files {
			if !file.IsDir() {
				continue
			}

			isEpochDir := strings.HasPrefix(file.Name(), defaultEpochString)
			if !isEpochDir {
				continue
			}

			epochDirs = append(epochDirs, file.Name())
		}

# safe - Name only
github.com/scottwinkler/terraform@v0.10.8/command/init_test.go:749:
	>>	files, err := ioutil.ReadDir(m.pluginDir())
		if err != nil {
			t.Fatal(err)
		}

		if !installer.PurgeUnusedCalled {
			t.Errorf("init -upgrade didn't purge providers, but should have")
		}

		gotFilenames := make([]string, len(files))
		for i, info := range files {
			gotFilenames[i] = info.Name()
		}
		sort.Strings(gotFilenames)

		wantFilenames := []string{
			"lock.json",

			// no "between" because the file in cwd overrides it

			// The mock PurgeUnused doesn't actually purge anything, so the dir

# safe - Name and IsDir only
github.com/rmasci/viper@v1.3.0/viper_test.go:861:
	>>		entries, err := ioutil.ReadDir(root)
			for _, e := range entries {
				if e.IsDir() {
					v.AddConfigPath(e.Name())
				}
			}

			err = v.ReadInConfig()
			assert.Nil(t, err)

			assert.Equal(t, `value is `+path.Base(v.configPaths[0]), v.GetString(`key`))
		}

		func TestWrongDirsSearchNotFound(t *testing.T) {

			_, config, cleanup := initDirs(t)
			defer cleanup()

			v := New()
			v.SetConfigName(config)
			v.SetDefault(`key`, `default`)

# safe - Name and IsDir only
github.com/flant/helm@v0.0.0-20200302114220-d40ba0adc0f1/internal/third_party/dep/fs/fs.go:122:
	>>	entries, err := ioutil.ReadDir(src)
		if err != nil {
			return errors.Wrapf(err, "cannot read directory %s", dst)
		}

		for _, entry := range entries {
			srcPath := filepath.Join(src, entry.Name())
			dstPath := filepath.Join(dst, entry.Name())

			if entry.IsDir() {
				if err = CopyDir(srcPath, dstPath); err != nil {
					return errors.Wrap(err, "copying directory failed")
				}
			} else {
				// This will include symlinks, which is what we want when
				// copying things.
				if err = copyFile(srcPath, dstPath); err != nil {
					return errors.Wrap(err, "copying file failed")
				}
			}
		}

# safe - Name only
github.com/moby/moby@v1.13.2-0.20170712005057-ceb9e244d934/registry/registry.go:58:
	>>	fs, err := ioutil.ReadDir(directory)
		if err != nil && !os.IsNotExist(err) {
			return err
		}

		for _, f := range fs {
			if strings.HasSuffix(f.Name(), ".crt") {
				if tlsConfig.RootCAs == nil {
					systemPool, err := tlsconfig.SystemCertPool()
					if err != nil {
						return fmt.Errorf("unable to get system cert pool: %v", err)
					}
					tlsConfig.RootCAs = systemPool
				}
				logrus.Debugf("crt: %s", filepath.Join(directory, f.Name()))
				data, err := ioutil.ReadFile(filepath.Join(directory, f.Name()))
				if err != nil {
					return err
				}
				tlsConfig.RootCAs.AppendCertsFromPEM(data)
			}

# safe - no methods called
github.com/huizluo/kratos@v0.3.2/pkg/log/internal/filewriter/filewriter_test.go:117:
	>>		fis, err := ioutil.ReadDir(logdir + "/test-rotate")
			if err != nil {
				t.Fatal(err)
			}
			assert.True(t, len(fis) > 5, "expect more than 5 file get %d", len(fis))
		}

		func TestMaxFile(t *testing.T) {
			fw, err := New(logdir+"/test-maxfile/info.log",
				MaxSize(1024*1024),
				MaxFile(1),
				func(opt *option) { opt.RotateInterval = 1 * time.Millisecond },
			)
			if err != nil {
				t.Fatal(err)
			}
			data := make([]byte, 1024)
			for i := range data {
				data[i] = byte(i)
			}
			for i := 0; i < 10; i++ {

# safe - Name only
github.com/ytjjyy/gmsm@v1.2.0/sm2/cert_pool.go:92:
	>>			fis, err := ioutil.ReadDir(directory)
				if err != nil {
					if firstErr == nil && !os.IsNotExist(err) {
						firstErr = err
					}
					continue
				}
				rootsAdded := false
				for _, fi := range fis {
					data, err := ioutil.ReadFile(directory + "/" + fi.Name())
					if err == nil && roots.AppendCertsFromPEM(data) {
						rootsAdded = true
					}
				}
				if rootsAdded {
					return roots, nil
				}
			}

			return nil, firstErr
		}

# safe - no methods called
github.com/sbourlon/go-git@v4.7.0+incompatible/storage/filesystem/storage_test.go:54:
	>>		fis, err := ioutil.ReadDir(s.dir)
			c.Assert(err, IsNil)
			c.Assert(fis, HasLen, 0)
		}

		type StorageExclusiveSuite struct {
			StorageSuite
		}

		var _ = Suite(&StorageExclusiveSuite{})

		func (s *StorageExclusiveSuite) SetUpTest(c *C) {
			s.dir = c.MkDir()
			storage, err := NewStorageWithOptions(
				osfs.New(s.dir),
				Options{ExclusiveAccess: true})
			c.Assert(err, IsNil)

			setUpTest(&s.StorageSuite, c, storage)
		}

# safe - Name only
github.com/scakemyer/pulsar@v0.9.77/bittorrent/service.go:895:
	>>	files, err := ioutil.ReadDir(extractedPath)
		if err != nil {
			return err
		}
		if len(files) == 1 {
			extracted = files[0].Name()
		} else {
			for _, file := range files {
				fileName := file.Name()
				re := regexp.MustCompile("(?i).*\\.(mkv|mp4|mov|avi)")
				if re.MatchString(fileName) {
					extracted = fileName
					break
				}
			}
		}
		if extracted != "" {
			filePath = filepath.Join(filepath.Dir(filePath), "extracted", extracted)
		} else {
			return errors.New("No extracted file to move")
		}

# safe - Name only
github.com/qorpress/i18n@v0.0.0-20200228133635-af116c699cac/exchange_actions/exchange_actions_test.go:126:
	>>		files, _ := ioutil.ReadDir("./public/downloads")
			for _, f := range files {
				os.Remove("./public/downloads/" + f.Name())
			}
		}

		func downloadedFileContent() string {
			files, _ := ioutil.ReadDir("./public/downloads")
			for _, f := range files {
				if content, err := ioutil.ReadFile("./public/downloads/" + f.Name()); err == nil {
					return string(content)
				}
			}
			return ""
		}

		func loadFixture(fileName string) string {
			if content, err := ioutil.ReadFile("./fixtures/" + fileName); err == nil {
				return string(content)
			}
			return ""

# safe - Name only
github.com/prometheus/procfs@v0.0.11/sysfs/class_power_supply.go:111:
	>>		dirs, err := ioutil.ReadDir(path)
			if err != nil {
				return nil, fmt.Errorf("failed to list power supplies at %q: %v", path, err)
			}

			psc := make(PowerSupplyClass, len(dirs))
			for _, d := range dirs {
				ps, err := parsePowerSupply(filepath.Join(path, d.Name()))
				if err != nil {
					return nil, err
				}

				ps.Name = d.Name()
				psc[d.Name()] = *ps
			}

			return psc, nil
		}

		func parsePowerSupply(path string) (*PowerSupply, error) {
			files, err := ioutil.ReadDir(path)

# safe - Name and IsDir only
github.com/threefoldtech/zosv2/modules@v0.0.0-20191001184911-b6d8bc81a7f0/network/portm/backend/fs.go:90:
	>>		infos, err := ioutil.ReadDir(dir)
			if err != nil {
				return nil, err
			}
			// walk through all ips in this network to get the ones which belong to a specific ID
			for _, info := range infos {
				if info.IsDir() {
					continue
				}

				p, err := strconv.Atoi(info.Name())
				if err != nil {
					return nil, err
				}
				ports = append(ports, p)
			}

			return ports, nil
		}

# safe - Name and IsDir only
github.com/PhillP/goa@v0.0.0-20160615074141-d26491060c03/service.go:365:
	>>	dirs, err := f.Readdir(-1)
		if err != nil {
			return err
		}
		sort.Sort(byName(dirs))

		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		fmt.Fprintf(w, "<pre>\n")
		for _, d := range dirs {
			name := d.Name()
			if d.IsDir() {
				name += "/"
			}

# safe - Name only
github.com/zchee/nvim-go@v0.0.0-20181208073724-1fbb3699e9d6/pkg/nvimutil/complete.go:34:
	>>				files, err := ioutil.ReadDir(dir)
					if err != nil {
						return nil, err
					}
					return matchFile(files, a.ArgLead), nil
				}

			default:
				files, err := ioutil.ReadDir(dir)
				if err != nil {
					return nil, err
				}
				for _, f := range files {
					if filepath.Ext(f.Name()) == ".go" || f.IsDir() {
						filelist = append(filelist, f.Name())
					}
				}
			}

			return filelist, nil
		}

# safe - more than Name and IsDir
github.com/ViBiOh/fibr@v0.0.0-20191125073312-d7688c6efdd1/pkg/filesystem/fs.go:143:
	>>		files, err := ioutil.ReadDir(a.getFullPath(pathname))
			if err != nil {
				return nil, convertError(err)
			}

			items := make([]*provider.StorageItem, len(files))
			for index, item := range files {
				items[index] = convertToItem(pathname, item)
			}

			sort.Sort(ByHybridSort(items))

			return items, nil
		}

		// Walk browses item recursively
		func (a app) Walk(walkFn func(*provider.StorageItem, error) error) error {
			return convertError(filepath.Walk(a.rootDirectory, func(pathname string, info os.FileInfo, err error) error {
				return walkFn(convertToItem(path.Dir(strings.TrimPrefix(pathname, a.rootDirectory)), info), err)
			}))
		}

# safe - Name and IsDir only
github.com/superp00t/gophercraft@v0.0.0-20200214203822-43dfe618f20a/packet/update/deserialize_test.go:46:
	>>	list, err := ioutil.ReadDir(captureDir.Render())
		if err != nil {
			t.Fatal(err)
		}

		for _, v := range list {
			if !v.IsDir() {
				if strings.HasSuffix(v.Name(), ".bin") {
					elements := strings.Split(v.Name(), ".")
					vsn, err := strconv.ParseInt(elements[0], 0, 64)
					if err != nil {
						t.Fatal(err)
					}

					data, err := captureDir.Concat(v.Name()).ReadAll()
					if err != nil {
						t.Fatal(err)
					}

					cap := capture{
						Version:     uint32(vsn),

# safe - more than Name and IsDir
github.com/Donders-Institute/tg-toolset-golang@v0.0.0-20191016091355-ad6decbb97ed/project/pkg/pdb/runner.go:74:
	>>		projects, err := ioutil.ReadDir(projectRootPath)
			if err != nil {
				log.Fatal(err)
			}
			for _, info := range projects {
				chanPrj <- info
			}
			return
		}()

		// initialize the database connection.
		db, err := sql.Open("mysql", dbConfig.FormatDSN())
		if err != nil {
			return fmt.Errorf("Fail connecting SQL database: %+v", err)
		}
		defer db.Close()

		// start parallel workers within a wait group.
		var wg sync.WaitGroup
		wg.Add(r.Nthreads)
		for i := 0; i < r.Nthreads; i++ {

# safe - Name only
github.com/lambda-zhang/systemmonitor@v0.0.0-20190330174335-7afebaf3a171/thermalzone.go:23:
	>>	dir, err := ioutil.ReadDir("/sys/class/thermal")
		if err != nil {
			return err
		}

		for _, fi := range dir {
			idx := strings.Index(fi.Name(), "thermal_zone")
			dirname := fi.Name()
			dirname_len := strings.Count(dirname, "") - 1
			if idx < 0 || dirname_len < (strings.Count("thermal_zonex", "")-1) {
				continue
			}
			ttype, err2 := readFile2String("/sys/class/thermal/" + fi.Name() + "/type")
			if err2 != nil || strings.Count(ttype, "") < 1 {
				continue
			}

			name := ttype + dirname[dirname_len-1:]
			temp_val, err3 := readFile2String("/sys/class/thermal/" + fi.Name() + "/temp")
			if err3 != nil || strings.Count(temp_val, "") < 1 {
				continue

# safe - Name only
code.cloudfoundry.org/cacheddownloader@v0.0.0-20200131002357-1a5ba4181601/cached_downloader_test.go:1432:
	>>		fis, err := ioutil.ReadDir(cachePath)
			ExpectWithOffset(1, err).ToNot(HaveOccurred())
			foundTmp := false
			for _, fi := range fis {
				foundTmp = foundTmp || fi.Name() == "temp"
			}
			ExpectWithOffset(1, len(fis)).To(Equal(n+1), "unexpected number of files in cache")
			ExpectWithOffset(1, foundTmp).To(BeTrue(), "did not find temp directory in cache")
		}

# safe - Name only
github.com/zJean001/Bilibili-Go-Backup@v0.0.0-20190616135638-050ab66d51ec/app/tool/liverpc/liverpcgen/main.go:129:
	>>	files, err = ioutil.ReadDir(rpcPath)
		if err != nil {
			return cli.NewExitError("Cannot read dir : "+rpcPath+" error: "+err.Error(), 1)
		}
		for _, file := range files {
			if strings.HasPrefix(file.Name(), "client.v") {
				pkg := strings.Split(file.Name(), ".")[1]
				pkgUpper := strings.ToUpper(pkg)
				var b []byte
				b, err = ioutil.ReadFile(rpcPath + "/" + file.Name())
				fileContent := string(b)
				if err != nil {
					return cli.NewExitError("fail to read file: "+rpcPath+"/"+file.Name(), 1)
				}
				fileContent = strings.TrimSuffix(fileContent, "\n")
				if fileContent != "" {
					names := strings.Split(fileContent, "\n")
					for _, name := range names {
						apVar(&outputCliDeclares, fmt.Sprintf("	// %s%s presents the controller in liverpc",
							pkgUpper, name))
						apVar(&outputCliDeclares, fmt.Sprintf("	%s%s %s.%sRPCClient", pkgUpper, name, pkg, name))

# safe - Name and IsDir only
github.com/pmuir/jx@v1.2.64/pkg/jx/cmd/import_test.go:28:
	>>		files, err := ioutil.ReadDir(testData)
			assert.NoError(t, err)

			for _, f := range files {
				if f.IsDir() {
					name := f.Name()
					srcDir := filepath.Join(testData, name)
					testDir := filepath.Join(tempDir, name)
					util.CopyDir(srcDir, testDir, true)

					err = assertImport(t, testDir)
					assert.NoError(t, err, "Importing dir %s from source %s", testDir, srcDir)
				}
			}
		}

		func assertImport(t *testing.T, testDir string) error {
			_, dirName := filepath.Split(testDir)
			o := &ImportOptions{}
			configureOptions(&o.CommonOptions)
			o.Dir = testDir

# safe - Name only
github.com/SamWhited/moby@v1.13.1/plugin/blobstore.go:60:
	>>			items, err := ioutil.ReadDir(filepath.Join(b.path, alg))
				if err != nil {
					continue
				}
				for _, fi := range items {
					if _, exists := whitelist[digest.Digest(alg+":"+fi.Name())]; !exists {
						p := filepath.Join(b.path, alg, fi.Name())
						err := os.RemoveAll(p)
						logrus.Debugf("cleaned up blob %v: %v", p, err)
					}
				}
			}

		}

		// WriteCommitCloser defines object that can be committed to blobstore.
		type WriteCommitCloser interface {
			io.WriteCloser
			Commit() (digest.Digest, error)
		}

# safe - Name only
github.com/camlistore/camlistore@v0.0.0-20200311132925-c2e31370ddef/cmd/pk-put/files.go:966:
	>>		fis, err := f.Readdir(-1)
			f.Close()
			if err != nil {
				return nil, err
			}
			sort.Sort(byTypeAndName(fis))
			for _, fi := range fis {
				depn, err := t.statPath(filepath.Join(fullPath, filepath.Base(fi.Name())), fi)
				if err != nil {
					return nil, err
				}
				if depn != nil {
					n.children = append(n.children, depn)
				}
			}
			return n, nil
		}

		// testHookStatCache, if non-nil, runs first in the checkStatCache worker.
		var testHookStatCache func(el interface{}, ok bool)

# safe - Name only
github.com/schollz/gojot@v4.0.0+incompatible/src/prompt.go:26:
	>>			files, _ := ioutil.ReadDir(path)
				for _, f := range files {
					names = append(names, f.Name())
				}
				return names
			}
		}

		var completer = readline.NewPrefixCompleter()

		func filterInput(r rune) (rune, bool) {
			switch r {
			// block CtrlZ feature
			case readline.CharCtrlZ:
				return r, false
			}
			return r, true
		}

# safe - Name only
github.com/attack/influxdb@v1.7.9-0.20191029173138-5bd71457cbd5/cmd/influx_inspect/buildtsi/buildtsi.go:93:
	>>		fis, err := ioutil.ReadDir(dataDir)
			if err != nil {
				return err
			}

			for _, fi := range fis {
				name := fi.Name()
				if !fi.IsDir() {
					continue
				} else if cmd.databaseFilter != "" && name != cmd.databaseFilter {
					continue
				}

				if err := cmd.processDatabase(name, filepath.Join(dataDir, name), filepath.Join(walDir, name)); err != nil {
					return err
				}
			}

			return nil
		}

# safe - Name and IsDir only
github.com/golang/text@v0.3.3-0.20200306154105-06d492aade88/message/pipeline/pipeline.go:200:
	>>	files, err := ioutil.ReadDir(path)
		if err != nil {
			return nil
		}
		for _, f := range files {
			name := f.Name()
			tag := tag
			if f.IsDir() {
				if t, err := language.Parse(name); err == nil {
					tag = t
				}
				// We ignore errors
				if err := i.walkImport(filepath.Join(path, name), tag); err != nil {
					return err
				}
				continue
			}
			for _, l := range strings.Split(name, ".") {
				if t, err := language.Parse(l); err == nil {
					tag = t
				}

# safe - Name and IsDir only
github.com/xyproto/u-root@v6.0.0+incompatible/tools/build_perf/build_perf.go:76:
	>>		files, err := ioutil.ReadDir(os.ExpandEnv(cmdsPath))
			if err != nil {
				return nil, err
			}
			cmds := []string{}
			for _, file := range files {
				if file.IsDir() {
					cmds = append(cmds, file.Name())
				}
			}
			return cmds, nil
		}

		func buildCmd(cmd string, gogc int) (*measurement, error) {
			start := time.Now()
			c := exec.Command("go", "build")
			c.Dir = filepath.Join(os.ExpandEnv(cmdsPath), cmd)
			c.Env = append(os.Environ(), fmt.Sprintf("GOGC=%d", gogc))
			if err := c.Run(); err != nil {
				return nil, err
			}

# safe - Name only
github.com/lazada/goprof@v0.0.0-20170418074850-71c946b457c7/web.go:253:
	>>	children, err := ioutil.ReadDir(profilesDir)
		if err != nil {
			return nil, fmt.Errorf("failed to ls '%v': %v", profilesDir, err)
		}
		for _, child := range children {
			childName := filepath.Join(profilesDir, child.Name())
			if err := writeFile(archive, childName); err != nil {
				return nil, fmt.Errorf("failed to write %v: %v", childName, err)
			}
		}
		dirname := filepath.Base(profilesDir)
		if !strings.HasPrefix("prof-all", dirname) && !strings.HasPrefix("prof-trace", dirname) && len(children) == 1 {
			binName := filepath.Base(binary)
			profileName := children[0].Name()
			withBinary := strings.Replace(showWebScriptTpl, "{{bin}}", binName, -1)
			scriptSrc := strings.Replace(withBinary, "{{profile}}", profileName, -1)
			tmpDir, err := ioutil.TempDir("", "")
			if err != nil {
				return nil, fmt.Errorf("failed to create temp dir: %v", err)
			}
			tmpFile, err := os.Create(filepath.Join(tmpDir, "show-web"))

# safe - Name and IsDir only
github.com/itchyny/bed@v0.1.1-0.20200201024941-78fd8cf0595d/cmdline/completor.go:146:
	>>	fileInfos, err := f.Readdir(500)
		if err != nil {
			return arg, nil
		}
		lowerBase := strings.ToLower(base)
		for _, fileInfo := range fileInfos {
			name := fileInfo.Name()
			if base != separator && !strings.HasPrefix(strings.ToLower(name), lowerBase) {
				continue
			}
			isDir := fileInfo.IsDir()
			if !isDir && fileInfo.Mode()&os.ModeSymlink != 0 {
				fileInfo, err = c.fs.Stat(filepath.Join(dir, name))
				if err != nil {
					return arg, nil
				}
				isDir = fileInfo.IsDir()
			}
			if isDir {
				name += separator
			}

# safe - Name only
k8s.io/cloud-provider-openstack@v1.17.1-0.20200203100121-931b4247deae/pkg/cloudprovider/providers/openstack/openstack_volumes.go:448:
	>>		files, _ := ioutil.ReadDir("/dev/disk/by-id/")

			for _, f := range files {
				for _, c := range candidateDeviceNodes {
					if c == f.Name() {
						klog.V(4).Infof("Found disk attached as %q; full devicepath: %s\n", f.Name(), path.Join("/dev/disk/by-id/", f.Name()))
						return path.Join("/dev/disk/by-id/", f.Name())
					}
				}
			}

			klog.V(4).Infof("Failed to find device for the volumeID: %q by serial ID", volumeID)
			return ""
		}

		func (os *OpenStack) getDevicePathFromInstanceMetadata(volumeID string) string {
			// Nova Hyper-V hosts cannot override disk SCSI IDs. In order to locate
			// volumes, we're querying the metadata service. Note that the Hyper-V
			// driver will include device metadata for untagged volumes as well.
			//
			// We're avoiding using cached metadata (or the configdrive),

# safe - Name only
github.com/kubernetes-sigs/controller-runtime@v0.5.2/pkg/envtest/webhook.go:351:
	>>	if files, err = ioutil.ReadDir(path); err != nil {
			return nil, nil, err
		}

		// file extensions that may contain Webhooks
		resourceExtensions := sets.NewString(".json", ".yaml", ".yml")

		var mutHooks []runtime.Object
		var valHooks []runtime.Object
		for _, file := range files {
			// Only parse whitelisted file types
			if !resourceExtensions.Has(filepath.Ext(file.Name())) {
				continue
			}

			// Unmarshal Webhooks from file into structs
			docs, err := readDocuments(filepath.Join(path, file.Name()))
			if err != nil {
				return nil, nil, err
			}


# safe - no methods called
github.com/yuyangjack/fabric@v1.4.2/integration/e2e/e2e_test.go:220:
	>>			files, err = ioutil.ReadDir(snapDir)
				Expect(err).NotTo(HaveOccurred())
				Expect(len(files)).To(Equal(numOfSnaps))

			})
		})

		Describe("three node etcdraft network with 2 orgs", func() {
			BeforeEach(func() {
				network = nwo.New(nwo.MultiNodeEtcdRaft(), testDir, client, BasePort(), components)
				network.GenerateConfigTree()
				network.Bootstrap()

				networkRunner := network.NetworkGroupRunner()
				process = ifrit.Invoke(networkRunner)
				Eventually(process.Ready(), network.EventuallyTimeout).Should(BeClosed())
			})

			// This tests:
			//
			// 1. channel creation with raft orderer,

# safe - no methods called
github.com/chhsia0/kubernetes@v0.0.0-20200103235644-a620a30d1cb8/pkg/kubelet/kubelet_volumes_linux_test.go:43:
	>>		_, err := ioutil.ReadDir(dir)
			if os.IsNotExist(err) {
				return nil
			}
			if err != nil {
				return err
			}
			return fmt.Errorf("dir %q still exists", dir)
		}

		func TestCleanupOrphanedPodDirs(t *testing.T) {
			testCases := map[string]struct {
				pods         []*v1.Pod
				prepareFunc  func(kubelet *Kubelet) error
				validateFunc func(kubelet *Kubelet) error
				expectErr    bool
			}{
				"nothing-to-do": {},
				"pods-dir-not-found": {
					prepareFunc: func(kubelet *Kubelet) error {
						return os.Remove(kubelet.getPodsDir())

# safe - Name only
github.com/jenkins-x/jx@v0.0.0-20191223101842-9dece1bb4fc9/pkg/util/unzip_test.go:26:
	>>		files, err := ioutil.ReadDir(dest)
			require.NoError(t, err, "failed to list files")

			assert.Len(t, files, 2)
			// files are sorted by ReadDir
			assert.Equal(t, "file1.txt", files[0].Name())
			assert.Equal(t, "file2.txt", files[1].Name())
			for _, f := range files {
				assertFileContents(t, filepath.Join(dest, f.Name()), strings.TrimSuffix(f.Name(), filepath.Ext(f.Name())))
			}
		}

		func TestUnzipSpecificFilesHappyPath(t *testing.T) {
			t.Parallel()
			dest, err := ioutil.TempDir("", "testUnzip")
			require.NoError(t, err, "[TEST SETUP] failed to create temporary directory for tests")
			defer os.RemoveAll(dest)

			zipFile, err := filepath.Abs("")
			require.NoError(t, err, "[TEST SETUP] could not obtain CWD")
			zipFile = filepath.Join(zipFile, "test_data", "2_files.zip")

# safe - no methods called
github.com/gemnasium/migrate@v1.4.2-0.20171027203356-30abc3eda21e/migrate/migrate_test.go:46:
	>>	files, err := ioutil.ReadDir(tmpdir)
		if err != nil {
			t.Fatal(err)
		}
		if len(files) != 4 {
			t.Fatal("Expected 2 new files, got", len(files))
		}
		expectFiles := []string{
			file1.UpFile.FileName, file1.DownFile.FileName,
			file2.UpFile.FileName, file2.DownFile.FileName,
		}
		for _, expectFile := range expectFiles {
			filepath := path.Join(tmpdir, expectFile)
			if _, err := os.Stat(filepath); os.IsNotExist(err) {
				t.Errorf("Can't find migration file: %s", filepath)
			}
		}

		if file1.Version == file2.Version {
			t.Errorf("files can't same version: %d", file1.Version)
		}

# safe - Name and IsDir only
github.com/jbw976/go-ps@v0.0.0-20170713234100-82859aed1b5d/process_unix.go:89:
	>>	fis, err := d.Readdir(10)
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}

		for _, fi := range fis {
			// We only care about directories, since all pids are dirs
			if !fi.IsDir() {
				continue
			}

			// We only care if the name starts with a numeric
			name := fi.Name()
			if name[0] < '0' || name[0] > '9' {
				continue
			}

			// From this point forward, any errors we just ignore, because

# safe - Name only
github.com/baiihcy/nutsdb@v0.4.2/db_test.go:138:
	>>	files, _ := ioutil.ReadDir(fileDir)
		for _, f := range files {
			name := f.Name()
			if name != "" {
				err := os.Remove(fileDir + "/" + name)
				if err != nil {
					panic(err)
				}
			}
		}

		opt := DefaultOptions
		opt.Dir = fileDir
		opt.SegmentSize = 1 * 100

		db2, err := Open(opt)
		//defer db2.Close()

		if err != nil {
			t.Fatal(err)
		}

# safe - Name and IsDir only
github.com/hwdef/kubernetes@v1.18.0-alpha.2/pkg/kubelet/cm/pod_container_manager_linux.go:250:
	>>	dirInfo, err := ioutil.ReadDir(qc)
		if err != nil {
			if os.IsNotExist(err) {
				continue
			}
			return nil, fmt.Errorf("failed to read the cgroup directory %v : %v", qc, err)
		}
		for i := range dirInfo {
			// its not a directory, so continue on...
			if !dirInfo[i].IsDir() {
				continue
			}
			// convert the concrete cgroupfs name back to an internal identifier
			// this is needed to handle path conversion for systemd environments.
			// we pass the fully qualified path so decoding can work as expected
			// since systemd encodes the path in each segment.
			cgroupfsPath := path.Join(qcConversion, dirInfo[i].Name())
			internalPath := m.cgroupManager.CgroupName(cgroupfsPath)
			// we only care about base segment of the converted path since that
			// is what we are reading currently to know if it is a pod or not.
			basePath := internalPath[len(internalPath)-1]

# safe - Name and IsDir only
github.com/sql2/vault@v1.3.0/command/auth_enable_test.go:154:
	>>	files, err := ioutil.ReadDir("../builtin/credential")
		if err != nil {
			t.Fatal(err)
		}

		var backends []string
		for _, f := range files {
			if f.IsDir() {
				backends = append(backends, f.Name())
			}
		}

		modFile, err := ioutil.ReadFile("../go.mod")
		if err != nil {
			t.Fatal(err)
		}
		modLines := strings.Split(string(modFile), "\n")
		for _, p := range modLines {
			splitLine := strings.Split(strings.TrimSpace(p), " ")
			if len(splitLine) == 0 {
				continue

# safe - more than Name and IsDir
github.com/jrote1/cockroach@v19.2.0-alpha.20190805+incompatible/pkg/util/log/file.go:286:
	>>		infos, err := ioutil.ReadDir(dir)
			if err != nil {
				return results, err
			}
			// The file names have a fixed structure with fields delimited by
			// periods. create() for new files removes the periods from the
			// provided prefix; do the same here to filter out selected names
			// below.
			programPrefix := removePeriods(l.prefix)
			for _, info := range infos {
				if info.Mode().IsRegular() {
					details, err := ParseLogFilename(info.Name())
					if err == nil && details.Program == programPrefix {
						results = append(results, MakeFileInfo(details, info))
					}
				}
			}
			return results, nil
		}

		// GetLogReader returns a reader for the specified filename. In

# safe - no methods called
github.com/ncw/rclone@v1.51.1-0.20200302181246-4d8d1e287ba3/backend/cache/cache_internal_test.go:1316:
	>>			list, err = ioutil.ReadDir(path.Join(r.mntDir, remote))
				for _, ll := range list {
					l = append(l, ll)
				}
			} else {
				var list fs.DirEntries
				list, err = f.List(context.Background(), remote)
				for _, ll := range list {
					l = append(l, ll)
				}
			}
			return l, err
		}

		func (r *run) copyFile(t *testing.T, f fs.Fs, src, dst string) error {
			in, err := os.Open(src)
			if err != nil {
				return err
			}
			defer func() {
				_ = in.Close()

# safe - more than Name and IsDir
github.com/rancher/k3s@v0.0.0-20190819162204-750881c0ab62/pkg/volume/util/volumepathhandler/volume_path_handler.go:170:
	>>		files, err := ioutil.ReadDir(mapPath)
			if err != nil {
				return nil, fmt.Errorf("Directory cannot read %v", err)
			}
			for _, file := range files {
				if file.Mode()&os.ModeSymlink != os.ModeSymlink {
					continue
				}
				filename := file.Name()
				filepath, err := os.Readlink(path.Join(mapPath, filename))
				if err != nil {
					return nil, fmt.Errorf("Symbolic link cannot be retrieved %v", err)
				}
				klog.V(5).Infof("GetDeviceSymlinkRefs: filepath: %v, devPath: %v", filepath, devPath)
				if filepath == devPath {
					refs = append(refs, path.Join(mapPath, filename))
				}
			}
			klog.V(5).Infof("GetDeviceSymlinkRefs: refs %v", refs)
			return refs, nil
		}

# safe - Name only
github.com/redhat-developer/helm@v3.0.0-alpha.2+incompatible/pkg/downloader/manager.go:629:
	>>		files, _ := ioutil.ReadDir(tmpPath)
			for _, file := range files {
				filename := file.Name()
				tmpfile := filepath.Join(tmpPath, filename)
				destfile := filepath.Join(destPath, filename)
				if err := os.Rename(tmpfile, destfile); err != nil {
					return errors.Wrap(err, "unable to move local charts to charts dir")
				}
			}
			return nil
		}

# safe - Name only
go.googlesource.com/go.git/src@v0.0.0-20190903170517-cc8838d645b2/os/dir_plan9.go:67:
	>>		fi, err := file.Readdir(n)
			names = make([]string, len(fi))
			for i := range fi {
				names[i] = fi[i].Name()
			}
			return
		}

# safe - no methods called
github.com/muryoutaisuu/go-fuse@v0.0.0-20181211172615-a2f69da40e3a/unionfs/unionfs_test.go:1209:
	>>		_, err = ioutil.ReadDir(wd + "/mnt")
			if err != nil {
				t.Fatal("Readdir should succeed", err)
			}
			err = ioutil.WriteFile(wd+"/mnt/file2", []byte("blabla"), 0644)
			if err != nil {
				t.Fatal("write should succeed", err)
			}
		}

		func TestUnionFsDeletedGetAttr(t *testing.T) {
			wd, clean := setupUfs(t)
			defer clean()

			err := ioutil.WriteFile(wd+"/ro/file", []byte("blabla"), 0644)
			if err != nil {
				t.Fatalf("WriteFile: %v", err)
			}
			setRecursiveWritable(t, wd+"/ro", false)

			f, err := os.Open(wd + "/mnt/file")

# safe - Name and IsDir only
github.com/rif/lov3lyme@v0.0.0-20140120095510-5c9dba763dac/src/app/models/context.go:122:
	>>	files, err := ioutil.ReadDir(langPath)
		if err != nil {
			Log("error reading langs dir: ", err.Error())
			return
		}
		Translations = make(map[string]Trans)
		for _, f := range files {
			if f.IsDir() {
				continue
			}
			file, err := os.Open(path.Join(langPath, f.Name()))
			if err != nil {
				Log("error opening lang file: ", err.Error())
				break
			}
			data, err := ioutil.ReadAll(file)
			if err != nil {
				Log("error reading lang file: ", err.Error())
				break
			}
			trans := Trans{}

# safe - Name and IsDir only
github.com/pterodactyl/wings@v1.0.0-alpha.2/config/config.go:307:
	>>	files, err := ioutil.ReadDir(c.System.Data)
		if err != nil {
			return err
		}

		su, err := user.Lookup(c.System.Username)
		if err != nil {
			return err
		}

		wg := new(sync.WaitGroup)

		for _, file := range files {
			wg.Add(1)

			// Asynchronously run through the list of files and folders in the data directory. If
			// the item is not a folder, or is not a folder that matches the expected UUIDv4 format
			// skip over it.
			//
			// If we do have a positive match, run a chown aganist the directory.
			go func(f os.FileInfo) {

# safe - Name only
github.com/hukaixuan/elfinder@v0.0.11/volume.go:84:
	>>		files, err := ioutil.ReadDir(path)
			if err != nil {
				return []FileDir{}
			}
			fileDir := make([]FileDir, 0, len(files))

			for _, item := range files {
				fileD, err := f.Info(filepath.Join(path, item.Name()))
				if err != nil {
					continue
				}
				fileDir = append(fileDir, fileD)
			}

			return fileDir
		}

		func (f *LocalFileVolume) Parents(path string, dep int) []FileDir {
			relativepath := strings.TrimPrefix(strings.TrimPrefix(path, f.basePath), "/")
			relativePaths := strings.Split(relativepath, "/")
			dirs := make([]FileDir, 0, len(relativePaths))

# safe - Name and IsDir only
github.com/tmathews/ebook@v0.0.0-20180804193045-76115822098f/lib.go:37:
	>>		files, err := ioutil.ReadDir(dir)
			if err != nil {
				return nil, err
			}
			xs := []os.FileInfo{}
			for _, x := range files {
				if x.IsDir() {
					continue
				}
				name := x.Name()
				ext := filepath.Ext(name)
				if !IsValidExt(ext) {
					continue
				}
				xs = append(xs, x)
			}
			return xs, nil
		}

		func ZipTemplate(a *zip.Writer, t *template.Template, s interface{}, f string) error {
			header := zip.FileHeader{

# safe - more than Name and IsDir
github.com/ystia/yorc@v1.0.0/helper/ziputil/zip_path.go:78:
	>>	fileInfos, err := ioutil.ReadDir(dirPath)
		if err != nil {
			return err
		}
		for _, fileInfo := range fileInfos {
			absPath, err := filepath.Abs(filepath.Join(dirPath, fileInfo.Name()))
			if err != nil {
				return err
			}
			absPath, err = filepath.EvalSymlinks(absPath)
			if err != nil {
				return err
			}
			fileName := rootEntry + fileInfo.Name()

			fileInfo, err = os.Stat(absPath)
			if err != nil {
				return err
			}

			// Create a header based off of the fileinfo

# safe - no methods called
code.cloudfoundry.org/cacheddownloader@v0.0.0-20191025171633-45dd66a014fe/cached_downloader_test.go:230:
	>>				Expect(ioutil.ReadDir(uncachedPath)).To(HaveLen(0))
				})
			})
		})

		Context("when the download succeeds but does not have an ETag", func() {
			BeforeEach(func() {
				downloadContent = []byte(strings.Repeat("7", int(maxSizeInBytes/2)))
				server.AppendHandlers(ghttp.CombineHandlers(
					ghttp.VerifyRequest("GET", "/my_file"),
					http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
						Expect(req.Header.Get("If-None-Match")).To(BeEmpty())
					}),
					ghttp.RespondWith(http.StatusOK, string(downloadContent)),
				))
			})

			It("should not error", func() {
				Expect(fetchErr).NotTo(HaveOccurred())
			})

# safe - Name only
github.com/hyperledger/fabric-ca@v2.0.0-alpha.0.20200302160032-47dd0ca45b9f+incompatible/cmd/fabric-ca-client/command/main_test.go:1074:
	>>	files, err := ioutil.ReadDir(signcerts)
		if err != nil {
			t.Fatalf("Failed to get number of files in directory '%s': %s", signcerts, err)
		}

		if files[0].Name() != "identity.csr" {
			t.Fatalf("Failed to find identity.csr in '%s': %s", signcerts, err)
		}

		err = RunMain([]string{cmdName, "gencsr", "--csr.cn", "identity", "--csr.names", "C=CA,O=Org1,FOO=BAR", "-M", mspDir})
		if err == nil {
			t.Error("Should have failed: Invalid CSR name")
		}

		err = RunMain([]string{cmdName, "gencsr", "--csr.cn", "identity", "--csr.names", "C:CA,O=Org1,OU=OU2", "-M", mspDir})
		if err == nil {
			t.Error("Should have failed: No '=' for name/value pair")
		}

		err = RunMain([]string{cmdName, "gencsr", "-c", defYaml, "--csr.names", "C=CA,O=Org1,OU=OU1", "-M", mspDir})
		if err == nil {

# safe - Name only
github.com/lxc/lxd@v0.0.0-20191225221339-dfbb18acc0d8/lxd/instance/qemu/vm_qemu.go:2030:
	>>	dents, err := ioutil.ReadDir(vm.DevicesPath())
		if err != nil {
			return err
		}

		// Go through all the unix devices
		for _, f := range dents {
			// Skip non-disk devices
			if !strings.HasPrefix(f.Name(), "disk.") {
				continue
			}

			// Always try to unmount the host side
			_ = unix.Unmount(filepath.Join(vm.DevicesPath(), f.Name()), unix.MNT_DETACH)

			// Remove the entry
			diskPath := filepath.Join(vm.DevicesPath(), f.Name())
			err := os.Remove(diskPath)
			if err != nil {
				logger.Error("Failed to remove disk device path", log.Ctx{"err": err, "path": diskPath})
			}

# safe - Name only
github.com/flynn-archive/docker@v1.13.1/plugin/blobstore.go:60:
	>>			items, err := ioutil.ReadDir(filepath.Join(b.path, alg))
				if err != nil {
					continue
				}
				for _, fi := range items {
					if _, exists := whitelist[digest.Digest(alg+":"+fi.Name())]; !exists {
						p := filepath.Join(b.path, alg, fi.Name())
						err := os.RemoveAll(p)
						logrus.Debugf("cleaned up blob %v: %v", p, err)
					}
				}
			}

		}

		// WriteCommitCloser defines object that can be committed to blobstore.
		type WriteCommitCloser interface {
			io.WriteCloser
			Commit() (digest.Digest, error)
		}


# safe - Name only
github.com/bstasyszyn/fabric-mod@v0.0.0-20191223174145-610832ee681f/bccsp/sw/fileks.go:226:
	>>		files, _ := ioutil.ReadDir(ks.path)
			for _, f := range files {
				if strings.HasPrefix(f.Name(), alias) {
					if strings.HasSuffix(f.Name(), "sk") {
						return "sk"
					}
					if strings.HasSuffix(f.Name(), "pk") {
						return "pk"
					}
					if strings.HasSuffix(f.Name(), "key") {
						return "key"
					}
					break
				}
			}
			return ""
		}

		func (ks *fileBasedKeyStore) storePrivateKey(alias string, privateKey interface{}) error {
			rawKey, err := utils.PrivateKeyToPEM(privateKey, ks.pwd)
			if err != nil {

# safe - Name and IsDir only
github.com/SierraSoftworks/git-tool@v1.5.5/internal/pkg/repo/mapper.go:101:
	>>		files, err := ioutil.ReadDir(di.GetConfig().ScratchDirectory())
			if err != nil {
				return nil, errors.Wrapf(err, "repo: unable to list directory contents in scratchpad direction '%s'", di.GetConfig().ScratchDirectory())
			}

			scratchpads := []models.Scratchpad{}

			for _, file := range files {
				if !file.IsDir() {
					continue
				}

				scratchpad, err := d.GetScratchpad(file.Name())
				if err != nil {
					return nil, errors.Wrapf(err, "repo: failed to list directory contents in the scratchpad directory '%s'", di.GetConfig().ScratchDirectory())
				}
				scratchpads = append(scratchpads, scratchpad)
			}

			return scratchpads, nil
		}

# safe - Name and IsDir only
github.com/timotheenicolas/vault@v1.4.0-beta1/command/server/config.go:675:
	>>	fis, err = f.Readdir(128)
		if err != nil && err != io.EOF {
			return nil, err
		}

		for _, fi := range fis {
			// Ignore directories
			if fi.IsDir() {
				continue
			}

			// Only care about files that are valid to load.
			name := fi.Name()
			skip := true
			if strings.HasSuffix(name, ".hcl") {
				skip = false
			} else if strings.HasSuffix(name, ".json") {
				skip = false
			}
			if skip || isTemporaryFile(name) {
				continue

# safe - no methods called
github.com/vrothberg/storage@v0.0.0-20191127123152-fae1939e8330/pkg/fileutils/fileutils_unix.go:16:
	>>		if fds, err := ioutil.ReadDir(fmt.Sprintf("/proc/%d/fd", os.Getpid())); err != nil {
				logrus.Errorf("Error opening /proc/%d/fd: %s", os.Getpid(), err)
			} else {
				return len(fds)
			}
			return -1
		}

# safe - Name only
github.com/micnncim/kubernetes@v0.0.0-20190829012645-ca5babc1da4f/pkg/volume/configmap/configmap_test.go:528:
	>>		infos, err = ioutil.ReadDir(datadirPath)
			if err != nil {
				t.Fatalf("couldn't find volume data path, %s", datadirPath)
			}
			if len(infos) != 0 {
				t.Errorf("empty data directory, %s, is not empty. Contains: %s", datadirSymlink, infos[0].Name())
			}

			doTestCleanAndTeardown(plugin, testPodUID, testVolumeName, volumePath, t)
		}

		func TestPluginKeysOptional(t *testing.T) {
			var (
				testPodUID     = types.UID("test_pod_uid")
				testVolumeName = "test_volume_name"
				testNamespace  = "test_configmap_namespace"
				testName       = "test_configmap_name"
				trueVal        = true

				volumeSpec    = volumeSpec(testVolumeName, testName, 0644)
				configMap     = configMap(testNamespace, testName)

# safe - Name only
github.com/ethersphere/swarm@v0.5.8-0.20200224093313-23ddb8204fc5/storage/localstore/migration_test.go:326:
	>>	files, err := ioutil.ReadDir(dir)
		if err != nil {
			log.Fatal(err)
		}

		for _, f := range files {
			err = copyFileContents(path.Join(dir, f.Name()), path.Join(tmpdir, f.Name()))
			if err != nil {
				t.Fatal(err)
			}
		}

		baseKey := make([]byte, 32)
		if _, err := rand.Read(baseKey); err != nil {
			t.Fatal(err)
		}

		// start localstore with the copied fixture
		db, err := New(tmpdir, baseKey, &Options{Tags: chunk.NewTags()})
		if err != nil {
			t.Fatal(err)

# safe - Name only
github.com/qorpress/i18n@v0.0.0-20200228133635-af116c699cac/exchange_actions/exchange_actions_test.go:133:
	>>		files, _ := ioutil.ReadDir("./public/downloads")
			for _, f := range files {
				if content, err := ioutil.ReadFile("./public/downloads/" + f.Name()); err == nil {
					return string(content)
				}
			}
			return ""
		}

		func loadFixture(fileName string) string {
			if content, err := ioutil.ReadFile("./fixtures/" + fileName); err == nil {
				return string(content)
			}
			return ""
		}

# safe - Name only
github.com/cocoonlife/influxdb@v0.0.0-20160929164952-f77ce3998835/cmd/influx_tsm/main.go:154:
	>>	dbs, err := ioutil.ReadDir(opts.DataPath)
		if err != nil {
			log.Fatalf("failed to access data directory at %v: %v\n", opts.DataPath, err)
		}
		fmt.Println() // Cleanly separate output from start of program.

		if opts.Parallel {
			if !isEnvSet("GOMAXPROCS") {
				// Only modify GOMAXPROCS if it wasn't set in the environment
				// This means 'GOMAXPROCS=1 influx_tsm -parallel' will not actually
				// run in parallel
				runtime.GOMAXPROCS(runtime.NumCPU())
			}
		}

		var badUser string
		if opts.SkipBackup {
			badUser = "(NOT RECOMMENDED)"
		}

		// Dump summary of what is about to happen.

# safe - no methods called
github.com/gruntwork-io/terratest@v0.26.1/test/terraform_scp_example_test.go:162:
	>>				fileInfos, err := ioutil.ReadDir(testCase.options.LocalDir)

					if err != nil {
						t.Fatalf("Error reading from local dir: %s, due to: %s", testCase.options.LocalDir, err.Error())
					}

					actualNumFilesCopied := len(fileInfos)

					if len(fileInfos) != expectedNumFiles {
						t.Fatalf("Error: expected %d files to be copied. Only found %d", expectedNumFiles, actualNumFilesCopied)
					}

					// Clean up the temp file we created
					os.RemoveAll(testCase.options.LocalDir)
				})
			}
		}

		func testScpFromHost(t *testing.T, terraformOptions *terraform.Options, keyPair *aws.Ec2Keypair) {
			// Run `terraform output` to get the value of an output variable
			awsRegion := terraformOptions.Vars["aws_region"].(string)

# safe - Name and IsDir only
github.com/adamlenda/engine@v0.1.2/tools/g3nshaders/main.go:161:
	>>		finfos, err := f.Readdir(0)
			if err != nil {
				panic(err)
			}

			// Process all directory entries.
			for _, fi := range finfos {
				if fi.IsDir() {
					dirInclude := include
					if fi.Name() == DIR_INCLUDE {
						dirInclude = true
					}
					processDir(filepath.Join(dir, fi.Name()), dirInclude)
				} else {
					processFile(filepath.Join(dir, fi.Name()), include)
				}
			}
		}

		// processFile process one file checking if it has the shaders extension,
		// otherwise it is ignored.

# safe - no methods called
github.com/iainsproat/lifecycle@v0.4.0/analyzer_test.go:596:
	>>					if _, err := ioutil.ReadDir(filepath.Join(layerDir, "metdata.buildpack", "stale-launch-build")); !os.IsNotExist(err) {
							t.Fatalf("Found stale stale-launch-build cache, it should not exist")
						}
						if _, err := ioutil.ReadDir(filepath.Join(layerDir, "some-app-dir")); err != nil {
							t.Fatalf("Missing some-app-dir")
						}
					})
				})
			})
		}

		func assertNil(t *testing.T, actual interface{}) {
			t.Helper()
			if actual != nil {
				t.Fatalf("Expected nil: %s", actual)
			}
		}

# safe - Name only
github.com/stripe/sequins@v0.0.0-20190702164353-ade6f04c0d85/backend/backend.go:85:
	>>		infos, err := ioutil.ReadDir(filepath.Join(lb.path, db, version))
			if err != nil {
				return nil, err
			}

			datasetSize := int64(0)
			numFiles := int64(len(infos))

			var res []string
			for _, info := range infos {
				name := info.Name()
				if !info.IsDir() && !strings.HasPrefix(name, "_") && !strings.HasPrefix(name, ".") {
					res = append(res, filepath.Base(info.Name()))
				}
			}

			log.Printf("call_site=files.ListFiles sequins_db=%q sequins_db_version=%q dataset_size=%d file_count=%d", db, version, datasetSize, numFiles)

			return res, nil
		}


# safe - Name only
github.com/wuka1/swarmkit@v0.0.0-20200319154513-603c702a46a9/manager/state/raft/storage_test.go:116:
	>>				dirents, err := ioutil.ReadDir(filepath.Join(node.StateDir, "snap-v3-encrypted"))
					if err != nil {
						return err
					}
					if len(dirents) != 1 {
						return fmt.Errorf("expected 1 snapshot, found %d on node %d", len(dirents), nodeID)
					}
					if dirents[0].Name() == snapshotFilenames[nodeID] {
						return fmt.Errorf("snapshot %s did not get replaced on node %d", snapshotFilenames[nodeID], nodeID)
					}
					return nil
				}))
			}

			// All nodes should have all the data
			raftutils.CheckValuesOnNodes(t, clockSource, nodes, nodeIDs, values)
		}

		func TestRaftSnapshotRestart(t *testing.T) {
			t.Parallel()

# safe - more than Name and IsDir
github.com/duanqy/community@v2.4.0+incompatible/domain/conversion/store/local.go:72:
	>>	list, err := ioutil.ReadDir(inputFolder)

		if err != nil {
			return filename, fileResult, err
		}

		if len(list) == 0 {
			return filename, fileResult, errors.New("no file to convert")
		}

		// remove temporary directory on exit
		defer func() { os.RemoveAll(inputFolder) }()

		for _, v := range list {
			if v.Size() > 0 && !strings.HasPrefix(v.Name(), ".") && v.Mode().IsRegular() {
				filename = inputFolder + v.Name()
				fileData, err := ioutil.ReadFile(filename)

				if err != nil {
					return filename, fileResult, err
				}

# safe - no methods called
github.com/mayusy/kubernetes@v1.18.0-alpha.0/pkg/util/mount/mount_helper_test.go:131:
	>>		_, err := ioutil.ReadDir(dir)
			if os.IsNotExist(err) {
				return nil
			}
			if err != nil {
				return err
			}
			return fmt.Errorf("dir %q still exists", dir)
		}

# safe - Name and IsDir only
github.com/couchbase/query@v0.0.0-20191217170643-c6916e179e4c/datastore/file/file.go:802:
	>>		dirEntries, er := ioutil.ReadDir(pi.keyspace.path())
			if er != nil {
				conn.Error(errors.NewFileDatastoreError(er, ""))
				return
			}

			for i, dirEntry := range dirEntries {
				if limit > 0 && int64(i) > limit {
					break
				}
				if !dirEntry.IsDir() {
					entry := datastore.IndexEntry{PrimaryKey: documentPathToId(dirEntry.Name())}
					conn.Sender().SendEntry(&entry)
				}
			}
		}

		func fetch(path string) (item value.AnnotatedValue, e errors.Error) {
			bytes, er := ioutil.ReadFile(path)
			if er != nil {
				return nil, errors.NewFileDatastoreError(er, "")

# safe - Name only
github.com/lysu/cockroach@v0.0.0-20200225094030-2c36a747283e/pkg/cmd/roachprod/tests.go:112:
	>>		ents, err := ioutil.ReadDir(dir)
			if err != nil {
				return nil, err
			}

			for _, e := range ents {
				r, err := loadTestRun(dir, e.Name())
				if err != nil {
					return nil, err
				}
				if r != nil {
					d.Runs = append(d.Runs, r)
				}
			}

			sort.Slice(d.Runs, func(i, j int) bool {
				return d.Runs[i].Concurrency < d.Runs[j].Concurrency
			})
			return d, nil
		}

# safe - Name and IsDir only
github.com/UlricQin/goutils@v0.0.0-20141016093831-470e8f553458/filetool/filetool.go:115:
	>>	fs, err := ioutil.ReadDir(dirPath)
		if err != nil {
			return []string{}, err
		}

		sz := len(fs)
		if sz == 0 {
			return []string{}, nil
		}

		ret := []string{}
		for i := 0; i < sz; i++ {
			if fs[i].IsDir() {
				name := fs[i].Name()
				if name != "." && name != ".." {
					ret = append(ret, name)
				}
			}
		}

		return ret, nil

# safe - Name and IsDir only
github.com/rancher/containerd@v0.2.1-0.20200224170405-c134a9befa59/oci/spec_opts_linux.go:45:
	>>	files, err := ioutil.ReadDir(path)
		if err != nil {
			return nil, err
		}
		var out []specs.LinuxDevice
		for _, f := range files {
			switch {
			case f.IsDir():
				switch f.Name() {
				// ".lxc" & ".lxd-mounts" added to address https://github.com/lxc/lxd/issues/2825
				// ".udev" added to address https://github.com/opencontainers/runc/issues/2093
				case "pts", "shm", "fd", "mqueue", ".lxc", ".lxd-mounts", ".udev":
					continue
				default:
					sub, err := getDevices(filepath.Join(path, f.Name()))
					if err != nil {
						return nil, err
					}

					out = append(out, sub...)
					continue

# safe - no methods called
github.com/snapcore/snapd@v0.0.0-20200327115532-350144226b80/interfaces/apparmor/backend_test.go:1396:
	>>		files, err := ioutil.ReadDir(dirs.SnapConfineAppArmorDir)
			c.Assert(err, IsNil)
			c.Assert(files, HasLen, 0)

			// We didn't reload the policy.
			c.Assert(cmd.Calls(), HasLen, 0)
		}

		// Test behavior when os.Readlink "/proc/self/exe" fails.
		func (s *backendSuite) TestSetupSnapConfineGeneratedPolicyError2(c *C) {
			// Make it appear as if NFS workaround was needed.
			restore := apparmor.MockIsHomeUsingNFS(func() (bool, error) { return true, nil })
			defer restore()

			// Make it appear as if overlay was not used.
			restore = apparmor.MockIsRootWritableOverlay(func() (string, error) { return "", nil })
			defer restore()

			// Intercept interaction with apparmor_parser
			cmd := testutil.MockCommand(c, "apparmor_parser", "")
			defer cmd.Restore()

# safe - Name only
github.com/juju/juju@v0.0.0-20191220234645-b4eda940b4b2/caas/kubernetes/provider/exec/copy.go:162:
	>>		files, err := ioutil.ReadDir(fpath)
			if err != nil {
				return err
			}
			if len(files) == 0 {
				//case empty directory
				hdr, _ := tar.FileInfoHeader(stat, fpath)
				hdr.Name = destFile
				if err := tw.WriteHeader(hdr); err != nil {
					return err
				}
			}
			for _, f := range files {
				if err := recursiveTar(srcBase, path.Join(srcFile, f.Name()), destBase, path.Join(destFile, f.Name()), tw); err != nil {
					return err
				}
			}
			return nil
		} else if stat.Mode()&os.ModeSymlink != 0 {
			//case soft link
			hdr, _ := tar.FileInfoHeader(stat, fpath)

# safe - Name only
github.com/Andyfoo/golang/x/tools@v0.0.0-20190901054642-57c1bf301704/internal/imports/mod.go:130:
	>>			pkgFiles, err := ioutil.ReadDir(pkgDir)
				if err != nil {
					continue
				}

				// A module only contains a package if it has buildable go
				// files in that directory. If not, it could be provided by an

# safe - Name only
github.com/omakoto/compromise@v0.0.0-20190321045054-79b424850d70/src/compromise/comptest/fileuitl.go:22:
	>>		files, err := ioutil.ReadDir(path)
			if err != nil {
				return nil, err
			}

			ret := make([]FileEntry, 0, len(files))
			for _, file := range files {
				baseName := file.Name()
				relPath := filepath.Join(path, baseName)
				isDir := dry.FileIsDir(relPath)

				ret = append(ret, FileEntry{baseName, isDir})
			}
			return ret, nil
		}

# safe - Name and IsDir only
github.com/rkt/rkt@v1.29.1-0.20171101133520-a1a97d417ef8/tests/rkt_image_gc_test.go:85:
	>>		ls, err := ioutil.ReadDir(filepath.Join(ctx.DataDir(), "cas", "tree"))
			if err != nil {
				if os.IsNotExist(err) {
					return treeStoreIDs, nil
				}
				return nil, fmt.Errorf("cannot read treestore directory: %v", err)
			}

			for _, p := range ls {
				if p.IsDir() {
					id := filepath.Base(p.Name())
					treeStoreIDs[id] = struct{}{}
				}
			}
			return treeStoreIDs, nil
		}

# safe - Name and IsDir only
github.com/worldiety/tools@v0.0.0-20200212095042-da9114d80da1/golist.go:21:
	>>	files, err := ioutil.ReadDir(parent.Dir)
		if err != nil {
			return fmt.Errorf("failed to read dir %s: %w", parent.Dir, err)
		}

		for _, file := range files {
			// ignore hidden
			if strings.HasPrefix(file.Name(), ".") {
				continue
			}

			if file.IsDir() {
				childPath := filepath.Join(parent.Dir, file.Name())
				childPkg, err := GoList(childPath, false)

				if err != nil {
					pseudoOrphaned, err := findHiddenPackageCandidatesDirectories(childPath)
					if err != nil {
						return fmt.Errorf("failed to find hidden packages: %w", err)
					}
					// the relationship is not correct, but at least we won't miss them and they are children

# safe - Name and IsDir only
github.com/EarthWind/CoolFS@v0.0.0-20200109153756-c946465ae823/internal/metanode/manager.go:130:
	>>	fileInfoList, err := ioutil.ReadDir(m.rootDir)
		if err != nil {
			return
		}
		var wg sync.WaitGroup
		for _, fileInfo := range fileInfoList {
			if fileInfo.IsDir() && strings.HasPrefix(fileInfo.Name(), partitionPrefix) {
				wg.Add(1)
				go func(fileName string) {
					var errload error
					defer func() {
						if r := recover(); r != nil {
							log.Errorf("loadPartitions partition: %s, "+
								"error: %s, failed: %v", fileName, errload, r)
							log.LogFlush()
							panic(r)
						}
						if errload != nil {
							log.Errorf("loadPartitions partition: %s, "+
								"error: %s", fileName, errload)
							log.LogFlush()

# safe - more than Name and IsDir
github.com/karrick/go@v0.0.0-20170817181416-d5b0ec858b37/src/cmd/compile/internal/syntax/parser_test.go:85:
	>>	fis, err := ioutil.ReadDir(dir)
		if err != nil {
			t.Error(err)
			return
		}

		var files, dirs []string
		for _, fi := range fis {
			if fi.Mode().IsRegular() {
				if strings.HasSuffix(fi.Name(), ".go") {
					path := filepath.Join(dir, fi.Name())
					files = append(files, path)
				}
			} else if fi.IsDir() && fi.Name() != "testdata" {
				path := filepath.Join(dir, fi.Name())
				if !strings.HasSuffix(path, "/test") {
					dirs = append(dirs, path)
				}
			}
		}


# safe - Name only
github.com/takjn/tinygo@v0.9.0/target.go:396:
	>>				dirnames, err := ioutil.ReadDir(clangVersionRoot)
					if err != nil || len(dirnames) != 1 {
						// Unexpected.
						return ""
					}
					return filepath.Join(clangVersionRoot, dirnames[0].Name(), "include")
				}
			}

			// Could not find it.
			return ""
		}

# safe - Name only
github.com/loov/ci@v0.0.0-20190410201617-eeaec549e0bd/files.go:109:
	>>		paths, err := ioutil.ReadDir(sourcePath)
			if err != nil {
				return err
			}

			for _, path := range paths {
				name := path.Name()
				err := copyAny(sourcePath, name, destinationPath)
				if err != nil {
					return err
				}
			}
			return nil
		}

		source, err := os.Open(sourcePath)
		if err != nil {
			return err
		}

		defer source.Close()

# safe - more than Name and IsDir
github.com/gusgins/skeema@v1.4.2/fs/dir.go:705:
	>>	fileInfos, err := ioutil.ReadDir(dirPath)
		if err != nil {
			return nil, err
		}
		result := make([]SQLFile, 0, len(fileInfos))
		for _, fi := range fileInfos {
			name := fi.Name()
			// symlinks: verify it points to an existing file within repoBase. If it
			// does not, or if any error occurs in any step in checking, skip it.
			if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
				dest, err := os.Readlink(path.Join(dirPath, name))
				if err != nil {
					continue
				}
				dest = filepath.Clean(dest)
				if !filepath.IsAbs(dest) {
					if dest, err = filepath.Abs(path.Join(dirPath, dest)); err != nil {
						continue
					}
				}
				if !strings.HasPrefix(dest, repoBase) {

# safe - Name only
github.com/mongodb/mongo-tools@v0.0.0-20191122191534-cea087360e0e/mongodump/mongodump_test.go:190:
	>>	fileInfos, err := ioutil.ReadDir(dir)
		if err != nil {
			return err
		}

		for _, fileInfo := range fileInfos {
			fileName := fileInfo.Name()
			if !strings.HasSuffix(fileName, ".bson") || fileName == "system.indexes.bson" {
				continue
			}

			collectionName, err := util.UnescapeCollectionName(fileName[:strings.LastIndex(fileName, ".bson")])
			if err != nil {
				return err
			}

			collection := session.Database(restoreDBName).Collection(collectionName)

			file, err := os.Open(fmt.Sprintf("%s/%s", dir, fileName))
			if err != nil {
				return err

# safe - no methods called
github.com/pulumi/pulumi-kubernetes@v1.6.0/tests/integration/render-yaml/render_yaml_test.go:63:
	>>						files, err = ioutil.ReadDir(filepath.Join(dir, "0-crd"))
							assert.NoError(t, err)
							assert.Equal(t, len(files), 0)

							// Verify that manifest directory was created.
							files, err = ioutil.ReadDir(filepath.Join(dir, "1-manifest"))
							assert.NoError(t, err)
							assert.Equal(t, len(files), 2)
						},
					},
				},
			})
		}

# safe - no methods called
github.com/moby/buildkit@v0.0.0-20191218033227-f7cf4823f71b/cache/manager_test.go:708:
	>>	dirs, err := ioutil.ReadDir(filepath.Join(tmpdir, "snapshots/snapshots"))
		require.NoError(t, err)
		require.Equal(t, 2, len(dirs))

		// prune with keeping refs does nothing
		buf := pruneResultBuffer()
		err = cm.Prune(ctx, buf.C, client.PruneInfo{})
		buf.close()
		require.NoError(t, err)

		checkDiskUsage(ctx, t, cm, 2, 0)
		require.Equal(t, len(buf.all), 0)

		dirs, err = ioutil.ReadDir(filepath.Join(tmpdir, "snapshots/snapshots"))
		require.NoError(t, err)
		require.Equal(t, 2, len(dirs))

		err = snap2.Release(ctx)
		require.NoError(t, err)

		checkDiskUsage(ctx, t, cm, 1, 1)

# safe - no methods called
gopkg.in/mqtt.v0@v0.0.0-20150615092906-7c18684bbe7d/unit_store_test.go:48:
	>>		files, err := ioutil.ReadDir(dir)
			chkerr(err)
			return len(files) == 0
		}

		func Test_key2mid(t *testing.T) {
			key := "i.123"
			exp := MId(123)
			res := key2mid(key)
			if exp != res {
				t.Fatalf("key2mid failed")
			}
		}

		func Test_ibound_mid2key(t *testing.T) {
			id := MId(9876)
			exp := "i.9876"
			res := ibound_mid2key(id)
			if exp != res {
				t.Fatalf("ibound_mid2key failed")
			}

# safe - Name and IsDir only
github.com/qiniu/logkit@v1.5.5-0.20200212151253-822434c0fa55/mgr/mgr.go:622:
	>>		files, err := ioutil.ReadDir(m.RestDir)
			if err != nil {
				log.Errorf("ioutil.ReadDir(%s): %v, err:%v", m.RestDir, files, err)
				return
			}
			nums := 0
			for _, f := range files {
				if f.IsDir() {
					log.Warn("skipped dir", f.Name())
					continue
				}
				m.Add(filepath.Join(m.RestDir, f.Name()))
				nums++
			}
			log.Infof("successfully restored %v runners in %v web rest dir", nums, m.RestDir)
		}

		func (m *Manager) Status() (rss map[string]RunnerStatus) {
			m.runnerLock.RLock()
			defer m.runnerLock.RUnlock()
			rss = make(map[string]RunnerStatus)

# safe - Name only
github.com/idestis/gort@v1.2.1-0.20191115153020-ec3542d9df2b/utils/utils.go:21:
	>>		scriptsList, _ := ioutil.ReadDir(dir)
			for _, s := range scriptsList {
				data = append(data, s.Name())
			}
			return data
		}

# safe - Name only
github.com/yyewolf/dca-disgord@v0.0.0-20190410103004-b16040de55c3/example/main.go:78:
	>>		files, _ := ioutil.ReadDir(*Folder)
			for _, f := range files {
				fmt.Println("PlayAudioFile:", f.Name())
				discord.UpdateStatus(0, f.Name())
				PlayAudioFile(voice, fmt.Sprintf("%s/%s", *Folder, f.Name()))
			}

			// Close connections
			voice.Close()
			discord.Close()

			return
		}

		// PlayAudioFile will play the given filename to the already connected
		// Discord voice server/channel.  voice websocket and udp socket
		// must already be setup before this will work.
		func PlayAudioFile(v *discordgo.VoiceConnection, filename string) {
			// Send "speaking" packet over the voice websocket
			err := v.Speaking(true)
			if err != nil {

# safe - Name only
github.com/360EntSecGroup-Skylar/goreporter@v0.0.0-20170817030823-f8e87b7d8677/linters/staticscan/lint/testutil/util.go:32:
	>>	fis, err := ioutil.ReadDir(baseDir)
		if err != nil {
			t.Fatalf("ioutil.ReadDir: %v", err)
		}
		if len(fis) == 0 {
			t.Fatalf("no files in %v", baseDir)
		}
		rx, err := regexp.Compile(*lintMatch)
		if err != nil {
			t.Fatalf("Bad -lint.match value %q: %v", *lintMatch, err)
		}

		files := map[int][]os.FileInfo{}
		for _, fi := range fis {
			if !rx.MatchString(fi.Name()) {
				continue
			}
			if !strings.HasSuffix(fi.Name(), ".go") {
				continue
			}
			parts := strings.Split(fi.Name(), "_")

# safe - no methods called
github.com/getantibody/antibody@v1.0.1-0.20200303021432-2aba8bd92294/antibodylib/antibody_test.go:32:
	>>		files, err := ioutil.ReadDir(home)
			require.NoError(t, err)
			require.Len(t, files, 3)
			require.Contains(t, sh, `export PATH="/tmp:$PATH"`)
			require.Contains(t, sh, `export PATH="`+home+`/https-COLON--SLASH--SLASH-github.com-SLASH-caarlos0-SLASH-ports:$PATH"`)
			require.Contains(t, sh, `export PATH="`+home+`/https-COLON--SLASH--SLASH-github.com-SLASH-caarlos0-SLASH-jvm:$PATH"`)
			// nolint: lll
			require.Contains(t, sh, `source `+home+`/https-COLON--SLASH--SLASH-github.com-SLASH-caarlos0-SLASH-zsh-open-pr/git-open-pr.plugin.zsh`)
		}

		func TestAntibodyError(t *testing.T) {
			home := home()
			bundles := bytes.NewBufferString("invalid-repo")
			sh, err := New(home, bundles, runtime.NumCPU()).Bundle()
			require.Error(t, err)
			require.Empty(t, sh)
		}

		func TestMultipleRepositories(t *testing.T) {
			home := home()
			bundles := []string{

# safe - Name only
github.com/C-FO/migrate@v1.3.2/migrate/migrate_test.go:46:
	>>	files, err := ioutil.ReadDir(tmpdir)
		if err != nil {
			t.Fatal(err)
		}
		if len(files) != 4 {
			t.Fatal("Expected 4 new files, got", len(files))
		}
		fileNameRegexp := regexp.MustCompile(`^\d{10}_(.*.[up|down].sql)`)

		expectFiles := []string{
			"test_migration.up.sql", "test_migration.down.sql",
			"another_migration.up.sql", "another_migration.down.sql",
		}

		var foundCounter int

		for _, file := range files {
			if x := fileNameRegexp.FindStringSubmatch(file.Name()); len(x) != 2 {
				t.Errorf("expected %v to match %v", file.Name(), fileNameRegexp)
			} else {
				for _, expect := range expectFiles {

# safe - Name and IsDir only
gopkg.in/labstack/echo.v1@v1.4.4/echo.go:468:
	>>		dirs, err := d.Readdir(-1)
			if err != nil {
				return err
			}

			// Create directory index
			w := c.Response()
			w.Header().Set(ContentType, TextHTMLCharsetUTF8)
			fmt.Fprintf(w, "<pre>\n")
			for _, d := range dirs {
				name := d.Name()

# safe - Name only
github.com/sencvkk/go-ipfs@v0.0.0-20200311154710-ba48cf8a2eaa/pkg/mod/golang.org/x/net@v0.0.0-20190227160552-c95aed5357e7/webdav/file_test.go:249:
	>>			children, err := f.Readdir(-1)
				if err != nil {
					return nil, err
				}
				for _, c := range children {
					ss, err = find(ctx, ss, fs, path.Join(name, c.Name()))
					if err != nil {
						return nil, err
					}
				}
			}
			return ss, nil
		}

		func testFS(t *testing.T, fs FileSystem) {
			errStr := func(err error) string {
				switch {
				case os.IsExist(err):
					return "errExist"
				case os.IsNotExist(err):
					return "errNotExist"

# safe - Name and IsDir only
github.com/guitcastro/jx@v1.3.1109/pkg/draft/draft.go:37:
	>>				packs, err := ioutil.ReadDir(packDir)
					if err != nil {
						return "", fmt.Errorf("there was an error reading %s: %v", packDir, err)
					}
					for _, file := range packs {
						if file.IsDir() {
							if strings.Compare(strings.ToLower(detectedLang.Language), strings.ToLower(file.Name())) == 0 {
								packPath := filepath.Join(packDir, file.Name())
								return packPath, nil
							}
						}
					}
				}
				fmt.Fprintf(out, "--> Could not find a pack for %s. Trying to find the next likely language match...\n", detectedLang.Language)
			}
			return "", fmt.Errorf("there was an error detecting the language using packs from %s", home.Packs())
		}

		// DoPackDetectionForBuildPack performs detection of the language based on a sepcific build pack
		func DoPackDetectionForBuildPack(out io.Writer, dir string, packDir string) (string, error) {
			log.Infof("performing pack detection in folder %s\n", dir)

# safe - Name only
github.com/yaozhang0105/go/src@v0.0.0-20190715165305-b9edee32e15e/os/dir_plan9.go:67:
	>>		fi, err := file.Readdir(n)
			names = make([]string, len(fi))
			for i := range fi {
				names[i] = fi[i].Name()
			}
			return
		}

# safe - Name only
github.com/maoyuhong82/grafana@v6.1.6+incompatible/pkg/cmd/grafana-cli/services/io_util.go:20:
	>>		return ioutil.ReadDir(path)
		}

		func (i IoUtilImp) ReadFile(filename string) ([]byte, error) {
			return ioutil.ReadFile(filename)
		}

# safe - Name and IsDir only
github.com/donovansolms/stellite-gui-miner@v1.3.1/src/gui/miner/helper.go:69:
	>>	files, err := ioutil.ReadDir(dir)
		if err != nil {
			return "", "", err
		}

		for _, file := range files {
			if file.IsDir() {
				continue
			}
			if runtime.GOOS == "windows" {
				if strings.Contains(strings.ToLower(file.Name()), "exe") == false {
					continue
				}
			} else {
				if strings.Contains(file.Mode().Perm().String(), "x") == false {
					continue
				}
			}

			fileName := strings.ToLower(file.Name())
			for _, supportedMiner := range SupportedMiners {

# safe - more than Name and IsDir
github.com/keybase/client@v5.3.1+incompatible/go/kbfs/libpages/stats.go:222:
	>>		hostStamps, err := ioutil.ReadDir(filepath.Join(s.root, dirnameHostStamps))
			if err != nil {
				return nil, err
			}
			return &fileinfoActivesGetter{
				tlfs:  tlfStamps,
				hosts: hostStamps,
			}, nil
		}

# safe - no methods called
github.com/liorokman/kubernetes@v1.16.0-alpha.0/pkg/kubelet/checkpoint/checkpoint_test.go:117:
	>>		files, err := ioutil.ReadDir(dir)
			if err != nil {
				t.Errorf("Failed to read directory %v", dir)
			}
			if len(files) > 0 {

# safe - Name only
github.com/hpe-storage/common-host-libs@v0.0.0-20191220161401-792671e1be62/linux/iscsi.go:442:
	>>	files, err := ioutil.ReadDir(ifacesPath)
		if err != nil && !os.IsNotExist(err) {
			return nil, err
		}
		if len(files) == 0 {
			log.Trace("no iscsi ifaces found")
			return nil, nil
		}

		// get network interfaces
		networks, err := GetNetworkInterfaces()
		if err != nil {
			return nil, fmt.Errorf("Unable to get the network interfaces on host: Error: %s", err.Error())
		}
		// create ifaces with bound network info
		for _, file := range files {
			lines, _ := util.FileGetStringsWithPattern(fmt.Sprintf("%s/%s", ifacesPath, file.Name()), ifaceNetNamePattern)
			if len(lines) > 0 {
				iface := &model.Iface{Name: file.Name()}
				for _, network := range networks {
					if network.Name == strings.TrimSpace(lines[0]) {

# safe - no methods called
github.com/danmarg/outtake@v0.0.0-20170521165132-1fdbcb6f94dc/lib/gmail/gmail_test.go:203:
	>>	fs, err = ioutil.ReadDir(dir + "/new")
		if err != nil {
			panic(err)
		}
		if len(fs) != 3 {
			t.Errorf(`Sync(true, nil) wrote %v messages to "new", expected 3`, len(fs))
		}
		// And zero in "cur".
		fs, err = ioutil.ReadDir(dir + "/cur")
		if err != nil {
			panic(err)
		}
		if len(fs) != 0 {
			t.Errorf(`Sync(true, nil) wrote %v messages to "cur", expected 0`, len(fs))
		}
		// And 0x3 should no longer have LABEL_3 set.
		k, ok = c.cache.GetMsgKey("0x3")
		if !ok {
			t.Errorf(`GetMsgKey("0x3") == false, expected true`)
		}
		f, err = c.dir.GetFile(k)

# safe - Name only
github.com/ilkeraksu/statik@v0.1.7/fs/fs_test.go:300:
	>>	fis, err := dir.Readdir(1)
		if err != nil {
			t.Errorf("dir.Readdir(1) = %v", err)
			return
		}
		if len(fis) != 1 {
			t.Errorf("got: %d, expect: 1", len(fis))
		}
		if fis[0].Name() != "aa" {
			t.Errorf("got: %s, expect: aa", fis[0].Name())
		}
		fis, err = dir.Readdir(1)
		if err != nil {
			t.Errorf("dir.Readdir(1) = %v", err)
			return
		}
		if len(fis) != 1 {
			t.Errorf("got: %d, expect: 1", len(fis))
		}
		if fis[0].Name() != "bb" {
			t.Errorf("got: %s, expect: bb", fis[0].Name())

# safe - Name and IsDir only
github.com/theishshah/operator-sdk@v0.6.1-0.20191010210909-81f36a5a7ee7/cmd/operator-sdk/internal/genutil/genutil.go:41:
	>>	versions, err := ioutil.ReadDir(groupDir)
		if err != nil {
			return nil, fmt.Errorf("could not read %s directory to find api Versions: %v", groupDir, err)
		}

		gvs[g.Name()] = make([]string, 0)
		for _, v := range versions {
			if v.IsDir() {
				// Ignore directories that do not contain any files, so generators
				// do not get empty directories as arguments.
				verDir := filepath.Join(groupDir, v.Name())
				files, err := ioutil.ReadDir(verDir)
				if err != nil {
					return nil, fmt.Errorf("could not read %s directory to find api Versions: %v", verDir, err)
				}
				for _, f := range files {
					if !f.IsDir() && filepath.Ext(f.Name()) == ".go" {
						gvs[g.Name()] = append(gvs[g.Name()], filepath.ToSlash(v.Name()))
						break
					}
				}

# safe - more than Name and IsDir
gitee.com/uhila/gf@v1.8.4/os/gfile/gfile.go:221:
	>>	entries, err := ioutil.ReadDir(src)
		if err != nil {
			return
		}
		for _, entry := range entries {
			srcPath := filepath.Join(src, entry.Name())
			dstPath := filepath.Join(dst, entry.Name())
			if entry.IsDir() {
				err = CopyDir(srcPath, dstPath)
				if err != nil {
					return
				}
			} else {
				// Skip symlinks.
				if entry.Mode()&os.ModeSymlink != 0 {
					continue
				}
				err = CopyFile(srcPath, dstPath)
				if err != nil {
					return
				}

# safe - more than Name and IsDir
github.com/qingwave/kubernetes@v1.19.0-alpha.0/pkg/volume/util/fs/fs_windows.go:104:
	>>		files, err := dir.Readdir(-1)
			if err != nil {
				return size, err
			}

			for _, file := range files {
				if file.IsDir() {
					s, err := diskUsage(fmt.Sprintf("%s/%s", currPath, file.Name()), file)
					if err != nil {
						return size, err
					}
					size += s
				} else {
					size += file.Size()
				}
			}
			return size, nil
		}

# safe - Name only
github.com/minio/hdfs@v1.1.3/file_reader.go:296:
	>>		fis, err := f.Readdir(n)
			if err != nil {
				return nil, err
			}

			names := make([]string, 0, len(fis))
			for _, fi := range fis {
				names = append(names, fi.Name())
			}

			return names, nil
		}

		// Close implements io.Closer.
		func (f *FileReader) Close() error {
			f.closed = true

			if f.blockReader != nil {
				f.blockReader.Close()
			}

# safe - no methods called
github.com/nats-io/nsc@v0.0.0-20200311215038-410c29a91237/cmd/store/store.go:143:
	>>	files, err := ioutil.ReadDir(root)
		if err != nil {
			return nil, err
		}

		if len(files) != 0 {

# safe - Name only
github.com/maddevsio/go-idmatch@v0.0.0-20181119071732-e54286919884/templates/templates.go:73:
	>>	dir, err := ioutil.ReadDir(config.Template.Path)
		if err != nil {
			return list, err
		}

		for _, file := range dir {
			var f TemplateFile
			jsonFile, err := ioutil.ReadFile(config.Template.Path + file.Name())
			if err != nil {
				return list, err
			}
			err = json.Unmarshal(jsonFile, &f)
			if err != nil {
				return list, err
			}

			for _, template := range f.Template {
				if template.Type == name || len(name) == 0 {
					list = append(list, template)
				}
			}

# safe - Name and IsDir only
github.com/IBM-Cloud/bluemix-go@v0.0.0-20191219070205-adffc398d07d/api/container/containerv1/clusters.go:339:
	>>	files, _ := ioutil.ReadDir(resultDir)
		for _, f := range files {
			if f.IsDir() && strings.HasPrefix(f.Name(), "kube") {
				kubedir = filepath.Join(resultDir, f.Name())
				files, _ := ioutil.ReadDir(kubedir)
				for _, f := range files {
					old := filepath.Join(kubedir, f.Name())
					new := filepath.Join(kubedir, "../", f.Name())
					if strings.HasSuffix(f.Name(), ".yml") {
						new = filepath.Join(kubedir, "../", kubeConfigName)
						kubeyml = new
					}
					err := os.Rename(old, new)
					if err != nil {
						return "", fmt.Errorf("Couldn't rename: %q", err)
					}
				}
				break
			}
		}
		if kubedir == "" {

# safe - Name only
github.com/innogames/grafsy@v2.0.2+incompatible/server.go:168:
	>>			files, err := ioutil.ReadDir(s.Conf.MetricDir)
				if err != nil {
					panic(err.Error())
				}
				for _, f := range files {
					resultsList, _ := readMetricsFromFile(s.Conf.MetricDir + "/" + f.Name())
					s.Mon.Increase(&s.Mon.serverStat.dir, len(resultsList))
					s.cleanAndUseIncomingData(resultsList)
				}

			}
		}

		// Run server.
		// Should be run in separate goroutine.
		func (s *Server) Run() {
			// Listen for incoming connections.
			l, err := net.Listen("tcp", s.Conf.LocalBind)
			if err != nil {
				s.Lc.lg.Println("Failed to run server:", err.Error())
				os.Exit(1)

# safe - Name and IsDir only
github.com/wimspaargaren/mongo-go-driver@v1.2.1/mongo/integration/json_helpers_test.go:42:
	>>		entries, err := ioutil.ReadDir(dir)
			assert.Nil(t, err, "unable to read json file: %v", err)

			for _, entry := range entries {
				if entry.IsDir() || path.Ext(entry.Name()) != ".json" {
					continue
				}

				files = append(files, entry.Name())
			}

			return files
		}

		// create client options from a map
		func createClientOptions(t testing.TB, opts bson.Raw) *options.ClientOptions {
			t.Helper()

			clientOpts := options.Client()
			elems, _ := opts.Elements()
			for _, elem := range elems {

# safe - Name only
github.com/hanwen/go-fuse/v2@v2.0.3-0.20200120094957-fe141f38f2b7/zipfs/multizip_test.go:126:
	>>			entries, err = ioutil.ReadDir(mountPoint)
				if err != nil {
					t.Fatalf("ReadDir failed: %v", err)
				}
				for _, e := range entries {
					if e.Name() == "zipmount" {
						t.Error("Should not have entry: ", e)
					}
				}
			}

		}

# safe - Name only
github.com/wuxingzhong/kratos@v0.1.0/pkg/log/internal/filewriter/filewriter_test.go:84:
	>>		fis, err := ioutil.ReadDir(logdir + "/test-rotate-exists")
			if err != nil {
				t.Fatal(err)
			}
			var fnams []string
			for _, fi := range fis {
				fnams = append(fnams, fi.Name())
			}
			assert.Contains(t, fnams, "info.log."+time.Now().Format("2006-01-02")+".006")
		}

		func TestSizeRotate(t *testing.T) {
			fw, err := New(logdir+"/test-rotate/info.log",
				MaxSize(1024*1024),
				func(opt *option) { opt.RotateInterval = 1 * time.Millisecond },
			)
			if err != nil {
				t.Fatal(err)
			}
			data := make([]byte, 1024)
			for i := range data {