for _, sz := range []int64{1 << 20, 2 << 20, 3 << 20} {
		err = out.Mmap(uint64(sz))
		if err != nil {
			t.Fatalf("Mmap failed: %v", err)
		}
		stat, err := os.Stat(filename)
		if err != nil {
			t.Fatalf("Stat failed: %v", err)
		}
		if got := stat.Size(); got != sz {
			t.Errorf("unexpected file size: got %d, want %d", got, sz)
		}
		// The number of blocks must be enough for the requested size.

)

func loadProcStatMetrics(ctx context.Context, stat procfs.ProcStat, m MetricValues) {
	if stat.CPUTime() > 0 {
		m.Set(processCPUTotalSeconds, float64(stat.CPUTime()))
	}

	if stat.ResidentMemory() > 0 {
		m.Set(processResidentMemoryBytes, float64(stat.ResidentMemory()))
	}

	if stat.VirtualMemory() > 0 {
		m.Set(processVirtualMemoryBytes, float64(stat.VirtualMemory()))
	}

	startTime, err := stat.StartTime()

}

type stats map[Cookie]*Stat

func (st stats) getLocked(c Cookie) *Stat {
	s, ok := st[c]
	if !ok {
		s = &Stat{Family: c.Family(), Type: c.Type(), Protocol: c.Protocol()}
		st[c] = s
	}
	return s
}

// A FilterType represents a filter type.
type FilterType int

        if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {
            def stat = NativeServicesTestFixture.instance.get(Stat)
            assert stat.getUnixMode(registryFile) == 0600 // user read-write
            assert stat.getUnixMode(registryFile.parentFile) == 0700 // user read-write-execute
        }
    }

    @Override
    State getCurrentState() {

    public AttributeBasedFileVisitDetails(File file, RelativePath relativePath, AtomicBoolean stop, Chmod chmod, Stat stat, BasicFileAttributes attributes) {
        super(file, relativePath, stop, chmod, stat);
        this.attributes = attributes;
    }

    @Override
    public long getSize() {
        return attributes.size();
    }

    @Override
    public long getLastModified() {

	eps := hcsshim.HNSEndpointStats{}
	for _, c := range s.containers {
		for _, stat := range c.hcsStats {
			if endpointName == stat.InstanceId {
				eps = hcsshim.HNSEndpointStats{
					EndpointID:      stat.EndpointId,
					BytesSent:       stat.BytesSent,
					BytesReceived:   stat.BytesReceived,
					PacketsReceived: stat.PacketsReceived,
					PacketsSent:     stat.PacketsSent,
				}
			}
		}
	}

	return &eps, nil
}

}

// Open calls Logger().Open, if a logger has been set.
func Open(name string) {
	if log := Logger(); log != nil {
		log.Open(name)
	}
}

// Stat calls Logger().Stat, if a logger has been set.
func Stat(name string) {
	if log := Logger(); log != nil {
		log.Stat(name)
	}

func Stat(path string, stat *Stat_t) (err error) {
	return fstatat(_AT_FDCWD, path, stat, 0)
}

func Lchown(path string, uid int, gid int) (err error) {
	return Fchownat(_AT_FDCWD, path, uid, gid, _AT_SYMLINK_NOFOLLOW)
}

func Lstat(path string, stat *Stat_t) (err error) {
	return fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW)
}

//sys	Shutdown(fd int, how int) (err error)
//sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)

func Stat(path string, stat *Stat_t) (err error) {
	// Use fstatat, because Android's seccomp policy blocks stat.
	return Fstatat(AT_FDCWD, path, stat, 0)
}

//sys	Statfs(path string, buf *Statfs_t) (err error)
//sys	SyncFileRange(fd int, off int64, n int64, flags int) (err error)

		entries, err := readDirN(dirname, 1)
		if err != nil {
			return false
		}
		return len(entries) == 0
	}
	var stat syscall.Stat_t
	if err := syscall.Stat(dirname, &stat); err != nil {
		return false
	}
	return stat.Mode&syscall.S_IFMT == syscall.S_IFDIR && stat.Nlink == 2