func (t *ForeignModsTest) ReadDir_ContentsInRoot() {
// Set up contents.
createTime := t.mtimeClock.Now()
AssertEq(
nil,
t.createObjects(
map[string]string{
// File
"foo": "taco",
// Directory
"bar/": "",
// File
"baz": "burrito",
}))
/////////////////////////
// ReadDir
/////////////////////////
entries, err := fusetesting.ReadDirPicky(t.mfs.Dir())
AssertEq(nil, err)
AssertEq(3, len(entries), "Names: %v", getFileNames(entries))
var e os.FileInfo
// bar
e = entries[0]
ExpectEq("bar", e.Name())
ExpectEq(0, e.Size())
ExpectEq(dirPerms|os.ModeDir, e.Mode())
ExpectTrue(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
// baz
e = entries[1]
ExpectEq("baz", e.Name())
ExpectEq(len("burrito"), e.Size())
ExpectEq(filePerms, e.Mode())
ExpectThat(e, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectFalse(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
// foo
e = entries[2]
ExpectEq("foo", e.Name())
ExpectEq(len("taco"), e.Size())
ExpectEq(filePerms, e.Mode())
ExpectThat(e, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectFalse(e.IsDir())
ExpectEq(1, e.Sys().(*syscall.Stat_t).Nlink)
ExpectEq(currentUid(), e.Sys().(*syscall.Stat_t).Uid)
ExpectEq(currentGid(), e.Sys().(*syscall.Stat_t).Gid)
}
func (t *MemFSTest) Mkdir_TwoLevels() {
var err error
var fi os.FileInfo
var stat *syscall.Stat_t
var entries []os.FileInfo
// Create a directory within the root.
err = os.Mkdir(path.Join(t.Dir, "parent"), 0700)
AssertEq(nil, err)
// Create a child of that directory.
createTime := time.Now()
err = os.Mkdir(path.Join(t.Dir, "parent/dir"), 0754)
AssertEq(nil, err)
// Stat the directory.
fi, err = os.Stat(path.Join(t.Dir, "parent/dir"))
stat = fi.Sys().(*syscall.Stat_t)
AssertEq(nil, err)
ExpectEq("dir", fi.Name())
ExpectEq(0, fi.Size())
ExpectEq(os.ModeDir|applyUmask(0754), fi.Mode())
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectThat(fi, fusetesting.BirthtimeIsWithin(createTime, timeSlop))
ExpectTrue(fi.IsDir())
ExpectNe(0, stat.Ino)
ExpectEq(1, stat.Nlink)
ExpectEq(currentUid(), stat.Uid)
ExpectEq(currentGid(), stat.Gid)
ExpectEq(0, stat.Size)
// Check the parent's mtime.
fi, err = os.Stat(path.Join(t.Dir, "parent"))
AssertEq(nil, err)
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
// Read the directory.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "parent/dir"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// Read the parent.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "parent"))
AssertEq(nil, err)
AssertEq(1, len(entries))
fi = entries[0]
ExpectEq("dir", fi.Name())
ExpectEq(os.ModeDir|applyUmask(0754), fi.Mode())
}
func (t *MemFSTest) Rmdir_Empty() {
var err error
var entries []os.FileInfo
// Create two levels of directories.
err = os.MkdirAll(path.Join(t.Dir, "foo/bar"), 0754)
AssertEq(nil, err)
// Remove the leaf.
rmTime := time.Now()
err = os.Remove(path.Join(t.Dir, "foo/bar"))
AssertEq(nil, err)
// There should be nothing left in the parent.
entries, err = fusetesting.ReadDirPicky(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
// Check the parent's mtime.
fi, err := os.Stat(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
ExpectThat(fi, fusetesting.MtimeIsWithin(rmTime, timeSlop))
// Remove the parent.
err = os.Remove(path.Join(t.Dir, "foo"))
AssertEq(nil, err)
// Now the root directory should be empty, too.
entries, err = fusetesting.ReadDirPicky(t.Dir)
AssertEq(nil, err)
ExpectThat(entries, ElementsAre())
}
func (t *MemFSTest) Rmdir_OpenedForReading() {
var err error
// Create a directory.
createTime := time.Now()
err = os.Mkdir(path.Join(t.Dir, "dir"), 0700)
AssertEq(nil, err)
// Open the directory for reading.
f, err := os.Open(path.Join(t.Dir, "dir"))
defer func() {
if f != nil {
ExpectEq(nil, f.Close())
}
}()
AssertEq(nil, err)
// Remove the directory.
err = os.Remove(path.Join(t.Dir, "dir"))
AssertEq(nil, err)
// Create a new directory, with the same name even, and add some contents
// within it.
err = os.MkdirAll(path.Join(t.Dir, "dir/foo"), 0700)
AssertEq(nil, err)
err = os.MkdirAll(path.Join(t.Dir, "dir/bar"), 0700)
AssertEq(nil, err)
err = os.MkdirAll(path.Join(t.Dir, "dir/baz"), 0700)
AssertEq(nil, err)
// We should still be able to stat the open file handle. It should show up as
// unlinked.
fi, err := f.Stat()
ExpectEq("dir", fi.Name())
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectEq(0, fi.Sys().(*syscall.Stat_t).Nlink)
// Attempt to read from the directory. This shouldn't see any junk from the
// new directory. It should either succeed with an empty result or should
// return ENOENT.
names, err := f.Readdirnames(0)
if err != nil {
ExpectThat(err, Error(HasSubstr("no such file")))
} else {
ExpectThat(names, ElementsAre())
}
}
func (t *MemFSTest) ModifyExistingFile_InSubDir() {
var err error
var n int
var fi os.FileInfo
var stat *syscall.Stat_t
// Create a sub-directory.
dirName := path.Join(t.Dir, "dir")
err = os.Mkdir(dirName, 0700)
AssertEq(nil, err)
// Write a file.
fileName := path.Join(dirName, "foo")
createTime := time.Now()
err = ioutil.WriteFile(fileName, []byte("Hello, world!"), 0600)
AssertEq(nil, err)
// Open the file and modify it.
f, err := os.OpenFile(fileName, os.O_WRONLY, 0400)
t.ToClose = append(t.ToClose, f)
AssertEq(nil, err)
modifyTime := time.Now()
n, err = f.WriteAt([]byte("H"), 0)
AssertEq(nil, err)
AssertEq(1, n)
// Stat the file.
fi, err = os.Stat(fileName)
stat = fi.Sys().(*syscall.Stat_t)
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectEq(len("Hello, world!"), fi.Size())
ExpectEq(applyUmask(0600), fi.Mode())
ExpectThat(fi, fusetesting.MtimeIsWithin(modifyTime, timeSlop))
ExpectThat(fi, fusetesting.BirthtimeIsWithin(createTime, timeSlop))
ExpectFalse(fi.IsDir())
ExpectNe(0, stat.Ino)
ExpectEq(1, stat.Nlink)
ExpectEq(currentUid(), stat.Uid)
ExpectEq(currentGid(), stat.Gid)
ExpectEq(len("Hello, world!"), stat.Size)
// Read the file back.
slice, err := ioutil.ReadFile(fileName)
AssertEq(nil, err)
ExpectEq("Hello, world!", string(slice))
}
func (t *MemFSTest) Chtimes() {
var err error
fileName := path.Join(t.Dir, "foo")
// Create a file.
err = ioutil.WriteFile(fileName, []byte(""), 0600)
AssertEq(nil, err)
// Chtimes it.
expectedMtime := time.Now().Add(123 * time.Second).Round(time.Second)
err = os.Chtimes(fileName, time.Now(), expectedMtime)
AssertEq(nil, err)
// Stat it.
fi, err := os.Stat(fileName)
AssertEq(nil, err)
ExpectThat(fi, fusetesting.MtimeIsWithin(expectedMtime, timeSlop))
}
func (t *MemFSTest) CreateNewFile_InSubDir() {
var err error
var fi os.FileInfo
var stat *syscall.Stat_t
// Create a sub-dir.
dirName := path.Join(t.Dir, "dir")
err = os.Mkdir(dirName, 0700)
AssertEq(nil, err)
// Write a file.
fileName := path.Join(dirName, "foo")
const contents = "Hello\x00world"
createTime := time.Now()
err = ioutil.WriteFile(fileName, []byte(contents), 0400)
AssertEq(nil, err)
// Stat it.
fi, err = os.Stat(fileName)
stat = fi.Sys().(*syscall.Stat_t)
AssertEq(nil, err)
ExpectEq("foo", fi.Name())
ExpectEq(len(contents), fi.Size())
ExpectEq(applyUmask(0400), fi.Mode())
ExpectThat(fi, fusetesting.MtimeIsWithin(createTime, timeSlop))
ExpectThat(fi, fusetesting.BirthtimeIsWithin(createTime, timeSlop))
ExpectFalse(fi.IsDir())
ExpectNe(0, stat.Ino)
ExpectEq(1, stat.Nlink)
ExpectEq(currentUid(), stat.Uid)
ExpectEq(currentGid(), stat.Gid)
ExpectEq(len(contents), stat.Size)
// Read it back.
slice, err := ioutil.ReadFile(fileName)
AssertEq(nil, err)
ExpectEq(contents, string(slice))
}