From 52f2e5fec517fffe1b8fb5666afa7e885dbe842a Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 22:18:05 -0600 Subject: [PATCH 1/6] MemFSTest.ModifyExistingFile_InSubDir --- samples/memfs/memfs_test.go | 57 ++++++++++++++++++++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index 204f096..9c10b93 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -481,7 +481,62 @@ func (t *MemFSTest) ModifyExistingFile_InRoot() { } func (t *MemFSTest) ModifyExistingFile_InSubDir() { - AssertTrue(false, "TODO") + var err error + var n int + var fi os.FileInfo + var stat *syscall.Stat_t + + // Create a sub-directory. + dirName := path.Join(t.mfs.Dir(), "dir") + err = os.Mkdir(dirName, 0700) + AssertEq(nil, err) + + // Write a file. + fileName := path.Join(dirName, "foo") + + createTime := t.clock.Now() + err = ioutil.WriteFile(fileName, []byte("Jello, world!"), 0600) + AssertEq(nil, err) + + // Simulate time advancing. + t.clock.AdvanceTime(time.Second) + + // 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 := t.clock.Now() + n, err = f.WriteAt([]byte("H"), 0) + AssertEq(nil, err) + AssertEq(1, n) + + // Simulate time advancing. + t.clock.AdvanceTime(time.Second) + + // 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(0600, fi.Mode()) + ExpectEq(0, fi.ModTime().Sub(modifyTime)) + 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) + ExpectEq(0, timespecToTime(stat.Mtimespec).Sub(modifyTime)) + ExpectEq(0, timespecToTime(stat.Birthtimespec).Sub(createTime)) + + // Read the file back. + slice, err := ioutil.ReadFile(fileName) + AssertEq(nil, err) + ExpectEq("Hello, world!", string(slice)) } func (t *MemFSTest) UnlinkFile_Exists() { From 005e43cd240c5f0cafcdf2b5d819d3e62d08c7ab Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 22:19:52 -0600 Subject: [PATCH 2/6] MemFSTest.UnlinkFile_Exists --- samples/memfs/memfs_test.go | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index 9c10b93..d9e821e 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -540,7 +540,27 @@ func (t *MemFSTest) ModifyExistingFile_InSubDir() { } func (t *MemFSTest) UnlinkFile_Exists() { - AssertTrue(false, "TODO") + var err error + + // Write a file. + fileName := path.Join(t.mfs.Dir(), "foo") + err = ioutil.WriteFile(fileName, []byte("Jello, world!"), 0600) + AssertEq(nil, err) + + // Unlink it. + err = os.Remove(fileName) + AssertEq(nil, err) + + // Statting it should fail. + _, err = os.Stat(fileName) + + AssertNe(nil, err) + ExpectThat(err, Error(HasSubstr("no such file"))) + + // Nothing should be in the directory. + entries, err := ioutil.ReadDir(t.mfs.Dir()) + AssertEq(nil, err) + ExpectThat(entries, ElementsAre()) } func (t *MemFSTest) UnlinkFile_NotAFile() { From e8c884f82baa15762c1ce714151842570e8a7ae0 Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 22:22:46 -0600 Subject: [PATCH 3/6] MemFSTest.UnlinkFile_NonExistent --- samples/memfs/memfs_test.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index d9e821e..35ab5b1 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -563,12 +563,11 @@ func (t *MemFSTest) UnlinkFile_Exists() { ExpectThat(entries, ElementsAre()) } -func (t *MemFSTest) UnlinkFile_NotAFile() { - AssertTrue(false, "TODO") -} - func (t *MemFSTest) UnlinkFile_NonExistent() { - AssertTrue(false, "TODO") + err := os.Remove(path.Join(t.mfs.Dir(), "foo")) + + AssertNe(nil, err) + ExpectThat(err, Error(HasSubstr("no such file"))) } func (t *MemFSTest) UnlinkFile_StillOpen() { From c9cd78eef20fa17f831e126a7bd4ce91aeba706e Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 22:31:44 -0600 Subject: [PATCH 4/6] MemFSTest.UnlinkFile_StillOpen --- samples/memfs/memfs_test.go | 42 ++++++++++++++++++++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index 35ab5b1..6ada4e9 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -571,7 +571,47 @@ func (t *MemFSTest) UnlinkFile_NonExistent() { } func (t *MemFSTest) UnlinkFile_StillOpen() { - AssertTrue(false, "TODO") + fileName := path.Join(t.mfs.Dir(), "foo") + + // Create and open a file. + f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0600) + t.toClose = append(t.toClose, f) + AssertEq(nil, err) + + // Write some data into it. + n, err := f.Write([]byte("taco")) + AssertEq(nil, err) + AssertEq(4, n) + + // Unlink it. + err = os.Remove(fileName) + AssertEq(nil, err) + + // The directory should no longer contain it. + entries, err := ioutil.ReadDir(t.mfs.Dir()) + AssertEq(nil, err) + ExpectThat(entries, ElementsAre()) + + // We should be able to stat the file. It should still show as having + // contents, but with no links. + fi, err := f.Stat() + + AssertEq(nil, err) + ExpectEq(4, fi.Size()) + ExpectEq(0, fi.Sys().(*syscall.Stat_t).Nlink) + + // The contents should still be available. + buf := make([]byte, 1024) + n, err = f.ReadAt(buf, 0) + + AssertEq(nil, err) + AssertEq(4, n) + ExpectEq("taco", buf[:4]) + + // Writing should still work, too. + n, err = f.Write([]byte("burrito")) + AssertEq(nil, err) + AssertEq(4, n) } func (t *MemFSTest) Rmdir_NonEmpty() { From b53eac308c63401ca82a9954b70a06dbd99f1a51 Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 22:35:57 -0600 Subject: [PATCH 5/6] Deleted a redundant test. --- samples/memfs/memfs_test.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index 6ada4e9..f0f9803 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -759,10 +759,6 @@ func (t *MemFSTest) CaseSensitive() { } } -func (t *MemFSTest) FileReadsAndWrites() { - AssertTrue(false, "TODO") -} - func (t *MemFSTest) WriteOverlapsEndOfFile() { var err error var n int From df6feb98c50d0c5d576e6cb49223353a1406b8e7 Mon Sep 17 00:00:00 2001 From: Aaron Jacobs Date: Fri, 6 Mar 2015 23:18:30 -0600 Subject: [PATCH 6/6] MemFSTest.ReadDirWhileModifying --- samples/memfs/memfs_test.go | 56 ++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/samples/memfs/memfs_test.go b/samples/memfs/memfs_test.go index f0f9803..b082415 100644 --- a/samples/memfs/memfs_test.go +++ b/samples/memfs/memfs_test.go @@ -1089,5 +1089,59 @@ func (t *MemFSTest) Chtimes() { } func (t *MemFSTest) ReadDirWhileModifying() { - AssertTrue(false, "TODO") + dirName := path.Join(t.mfs.Dir(), "dir") + createFile := func(name string) { + AssertEq(nil, ioutil.WriteFile(path.Join(dirName, name), []byte{}, 0400)) + } + + // Create a directory. + err := os.Mkdir(dirName, 0700) + AssertEq(nil, err) + + // Open the directory. + d, err := os.Open(dirName) + t.toClose = append(t.toClose, d) + AssertEq(nil, err) + + // Add four files. + createFile("foo") + createFile("bar") + createFile("baz") + createFile("qux") + + // Read one entry from the directory. + names, err := d.Readdirnames(1) + AssertEq(nil, err) + AssertThat(names, ElementsAre("foo")) + + // Make two holes in the directory. + AssertEq(nil, os.Remove(path.Join(dirName, "foo"))) + AssertEq(nil, os.Remove(path.Join(dirName, "baz"))) + + // Add a bunch of files to the directory. + createFile("blah_0") + createFile("blah_1") + createFile("blah_2") + createFile("blah_3") + createFile("blah_4") + + // Continue reading from the directory, noting the names we see. + namesSeen := make(map[string]bool) + for { + names, err = d.Readdirnames(1) + for _, n := range names { + namesSeen[n] = true + } + + if err == io.EOF { + break + } + + AssertEq(nil, err) + } + + // Posix requires that we should have seen bar and qux, which we didn't + // delete. + ExpectTrue(namesSeen["bar"]) + ExpectTrue(namesSeen["qux"]) }