diff --git a/afero_test.go b/afero_test.go
index 6c9c64b..26e23cd 100644
--- a/afero_test.go
+++ b/afero_test.go
@@ -194,20 +194,39 @@
 		tDir := testDir(fs)
 		from := filepath.Join(tDir, "/renamefrom")
 		to := filepath.Join(tDir, "/renameto")
+		exists := filepath.Join(tDir, "/renameexists")
 		file, err := fs.Create(from)
 		if err != nil {
-			t.Fatalf("open %q failed: %v", to, err)
+			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
 		}
 		if err = file.Close(); err != nil {
-			t.Errorf("close %q failed: %v", to, err)
+			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
+		}
+		file, err = fs.Create(exists)
+		if err != nil {
+			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
+		}
+		if err = file.Close(); err != nil {
+			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
 		}
 		err = fs.Rename(from, to)
 		if err != nil {
-			t.Fatalf("rename %q, %q failed: %v", to, from, err)
+			t.Fatalf("%s: rename %q, %q failed: %v", fs.Name(), to, from, err)
+		}
+		file, err = fs.Create(from)
+		if err != nil {
+			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
+		}
+		if err = file.Close(); err != nil {
+			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
+		}
+		err = fs.Rename(from, exists)
+		if err != nil {
+			t.Errorf("%s: rename %q, %q failed: %v", fs.Name(), exists, from, err)
 		}
 		names, err := readDirNames(fs, tDir)
 		if err != nil {
-			t.Fatalf("readDirNames error: %v", err)
+			t.Errorf("%s: readDirNames error: %v", fs.Name(), err)
 		}
 		found := false
 		for _, e := range names {
@@ -224,7 +243,7 @@
 
 		_, err = fs.Stat(to)
 		if err != nil {
-			t.Errorf("stat %q failed: %v", to, err)
+			t.Errorf("%s: stat %q failed: %v", fs.Name(), to, err)
 		}
 	}
 }
diff --git a/filter_test.go b/filter_test.go
index dcbc6f4..679cf92 100644
--- a/filter_test.go
+++ b/filter_test.go
@@ -13,7 +13,7 @@
 	if err == nil {
 		t.Errorf("Did not fail to create file")
 	}
-	t.Logf("ERR=%s", err)
+	// t.Logf("ERR=%s", err)
 }
 
 func TestFilterReadonlyRemoveAndRead(t *testing.T) {
@@ -59,9 +59,10 @@
 	fs.AddFilter(NewRegexpFilter(regexp.MustCompile(`\.txt$`)))
 	_, err := fs.Create("/file.html")
 	if err == nil {
+
 		t.Errorf("Did not fail to create file")
 	}
-	t.Logf("ERR=%s", err)
+	// t.Logf("ERR=%s", err)
 }
 
 func TestFilterRORegexpChain(t *testing.T) {
@@ -73,7 +74,7 @@
 	if err == nil {
 		t.Errorf("Did not fail to create file")
 	}
-	t.Logf("ERR=%s", err)
+	// t.Logf("ERR=%s", err)
 }
 
 func TestFilterRegexReadDir(t *testing.T) {
diff --git a/mem/dir.go b/mem/dir.go
index 79cba7a..e104013 100644
--- a/mem/dir.go
+++ b/mem/dir.go
@@ -16,20 +16,20 @@
 type Dir interface {
 	Len() int
 	Names() []string
-	Files() []File
-	Add(File)
-	Remove(File)
+	Files() []*FileData
+	Add(*FileData)
+	Remove(*FileData)
 }
 
-func RemoveFromMemDir(dir *File, f *File) {
-	dir.memDir.Remove(*f)
+func RemoveFromMemDir(dir *FileData, f *FileData) {
+	dir.memDir.Remove(f)
 }
 
-func AddToMemDir(dir *File, f *File) {
-	dir.memDir.Add(*f)
+func AddToMemDir(dir *FileData, f *FileData) {
+	dir.memDir.Add(f)
 }
 
-func InitializeDir(d *File) {
+func InitializeDir(d *FileData) {
 	if d.memDir == nil {
 		d.dir = true
 		d.memDir = &DirMap{}
diff --git a/mem/dirmap.go b/mem/dirmap.go
index 59c5d8d..03a57ee 100644
--- a/mem/dirmap.go
+++ b/mem/dirmap.go
@@ -15,12 +15,12 @@
 
 import "sort"
 
-type DirMap map[string]File
+type DirMap map[string]*FileData
 
-func (m DirMap) Len() int      { return len(m) }
-func (m DirMap) Add(f File)    { m[f.Name()] = f }
-func (m DirMap) Remove(f File) { delete(m, f.Name()) }
-func (m DirMap) Files() (files []File) {
+func (m DirMap) Len() int           { return len(m) }
+func (m DirMap) Add(f *FileData)    { m[f.name] = f }
+func (m DirMap) Remove(f *FileData) { delete(m, f.name) }
+func (m DirMap) Files() (files []*FileData) {
 	for _, f := range m {
 		files = append(files, f)
 	}
@@ -28,12 +28,12 @@
 	return files
 }
 
-type filesSorter []File
+// implement sort.Interface for []*FileData
+type filesSorter []*FileData
 
-// implement sort.Interface for []File
 func (s filesSorter) Len() int           { return len(s) }
 func (s filesSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s filesSorter) Less(i, j int) bool { return s[i].Name() < s[j].Name() }
+func (s filesSorter) Less(i, j int) bool { return s[i].name < s[j].name }
 
 func (m DirMap) Names() (names []string) {
 	for x := range m {
diff --git a/mem/file.go b/mem/file.go
index 33093f5..be3673e 100644
--- a/mem/file.go
+++ b/mem/file.go
@@ -32,63 +32,86 @@
 	// atomic requires 64-bit alignment for struct field access
 	at           int64
 	readDirCount int64
+	closed       bool
+	readOnly     bool
+	fileData     *FileData
+}
 
+func NewFileHandle(data *FileData) *File {
+	return &File{fileData: data}
+}
+
+func NewReadOnlyFileHandle(data *FileData) *File {
+	return &File{fileData: data, readOnly: true}
+}
+
+func (f File) Data() *FileData {
+	return f.fileData
+}
+
+type FileData struct {
 	sync.Mutex
 	name    string
 	data    []byte
 	memDir  Dir
 	dir     bool
-	closed  bool
 	mode    os.FileMode
 	modtime time.Time
 }
 
-func CreateFile(name string) *File {
-	return &File{name: name, mode: os.ModeTemporary, modtime: time.Now()}
+func (d FileData) Name() string {
+	return d.name
 }
 
-func CreateDir(name string) *File {
-	return &File{name: name, memDir: &DirMap{}, dir: true}
+func CreateFile(name string) *FileData {
+	return &FileData{name: name, mode: os.ModeTemporary, modtime: time.Now()}
 }
 
-func ChangeFileName(f *File, newname string) {
+func CreateDir(name string) *FileData {
+	return &FileData{name: name, memDir: &DirMap{}, dir: true}
+}
+
+func ChangeFileName(f *FileData, newname string) {
 	f.name = newname
 }
 
-func SetMode(f *File, mode os.FileMode) {
+func SetMode(f *FileData, mode os.FileMode) {
 	f.mode = mode
 }
 
-func SetModTime(f *File, mtime time.Time) {
+func SetModTime(f *FileData, mtime time.Time) {
 	f.modtime = mtime
 }
 
-func GetFileInfo(f *File) *FileInfo {
-	return &FileInfo{file: f}
+func GetFileInfo(f *FileData) *FileInfo {
+	return &FileInfo{f}
 }
 
 func (f *File) Open() error {
 	atomic.StoreInt64(&f.at, 0)
 	atomic.StoreInt64(&f.readDirCount, 0)
-	f.Lock()
+	f.fileData.Lock()
 	f.closed = false
-	f.Unlock()
+	f.fileData.Unlock()
 	return nil
 }
 
 func (f *File) Close() error {
-	f.Lock()
+	f.fileData.Lock()
 	f.closed = true
-	f.Unlock()
+	if !f.readOnly {
+		SetModTime(f.fileData, time.Now())
+	}
+	f.fileData.Unlock()
 	return nil
 }
 
 func (f *File) Name() string {
-	return f.name
+	return f.fileData.name
 }
 
 func (f *File) Stat() (os.FileInfo, error) {
-	return &FileInfo{f}, nil
+	return &FileInfo{f.fileData}, nil
 }
 
 func (f *File) Sync() error {
@@ -98,8 +121,8 @@
 func (f *File) Readdir(count int) (res []os.FileInfo, err error) {
 	var outLength int64
 
-	f.Lock()
-	files := f.memDir.Files()[f.readDirCount:]
+	f.fileData.Lock()
+	files := f.fileData.memDir.Files()[f.readDirCount:]
 	if count > 0 {
 		if len(files) < count {
 			outLength = int64(len(files))
@@ -113,11 +136,11 @@
 		outLength = int64(len(files))
 	}
 	f.readDirCount += outLength
-	f.Unlock()
+	f.fileData.Unlock()
 
 	res = make([]os.FileInfo, outLength)
 	for i := range res {
-		res[i], _ = files[i].Stat()
+		res[i] = &FileInfo{files[i]}
 	}
 
 	return res, err
@@ -133,20 +156,20 @@
 }
 
 func (f *File) Read(b []byte) (n int, err error) {
-	f.Lock()
-	defer f.Unlock()
+	f.fileData.Lock()
+	defer f.fileData.Unlock()
 	if f.closed == true {
 		return 0, ErrFileClosed
 	}
-	if len(b) > 0 && int(f.at) == len(f.data) {
+	if len(b) > 0 && int(f.at) == len(f.fileData.data) {
 		return 0, io.EOF
 	}
-	if len(f.data)-int(f.at) >= len(b) {
+	if len(f.fileData.data)-int(f.at) >= len(b) {
 		n = len(b)
 	} else {
-		n = len(f.data) - int(f.at)
+		n = len(f.fileData.data) - int(f.at)
 	}
-	copy(b, f.data[f.at:f.at+int64(n)])
+	copy(b, f.fileData.data[f.at:f.at+int64(n)])
 	atomic.AddInt64(&f.at, int64(n))
 	return
 }
@@ -160,15 +183,19 @@
 	if f.closed == true {
 		return ErrFileClosed
 	}
+	if f.readOnly {
+		return &os.PathError{"truncate", f.fileData.name, errors.New("file handle is read only")}
+	}
 	if size < 0 {
 		return ErrOutOfRange
 	}
-	if size > int64(len(f.data)) {
-		diff := size - int64(len(f.data))
-		f.data = append(f.data, bytes.Repeat([]byte{00}, int(diff))...)
+	if size > int64(len(f.fileData.data)) {
+		diff := size - int64(len(f.fileData.data))
+		f.fileData.data = append(f.fileData.data, bytes.Repeat([]byte{00}, int(diff))...)
 	} else {
-		f.data = f.data[0:size]
+		f.fileData.data = f.fileData.data[0:size]
 	}
+	SetModTime(f.fileData, time.Now())
 	return nil
 }
 
@@ -182,30 +209,34 @@
 	case 1:
 		atomic.AddInt64(&f.at, int64(offset))
 	case 2:
-		atomic.StoreInt64(&f.at, int64(len(f.data))+offset)
+		atomic.StoreInt64(&f.at, int64(len(f.fileData.data))+offset)
 	}
 	return f.at, nil
 }
 
 func (f *File) Write(b []byte) (n int, err error) {
+	if f.readOnly {
+		return 0, &os.PathError{"write", f.fileData.name, errors.New("file handle is read only")}
+	}
 	n = len(b)
 	cur := atomic.LoadInt64(&f.at)
-	f.Lock()
-	defer f.Unlock()
-	diff := cur - int64(len(f.data))
+	f.fileData.Lock()
+	defer f.fileData.Unlock()
+	diff := cur - int64(len(f.fileData.data))
 	var tail []byte
-	if n+int(cur) < len(f.data) {
-		tail = f.data[n+int(cur):]
+	if n+int(cur) < len(f.fileData.data) {
+		tail = f.fileData.data[n+int(cur):]
 	}
 	if diff > 0 {
-		f.data = append(bytes.Repeat([]byte{00}, int(diff)), b...)
-		f.data = append(f.data, tail...)
+		f.fileData.data = append(bytes.Repeat([]byte{00}, int(diff)), b...)
+		f.fileData.data = append(f.fileData.data, tail...)
 	} else {
-		f.data = append(f.data[:cur], b...)
-		f.data = append(f.data, tail...)
+		f.fileData.data = append(f.fileData.data[:cur], b...)
+		f.fileData.data = append(f.fileData.data, tail...)
 	}
+	SetModTime(f.fileData, time.Now())
 
-	atomic.StoreInt64(&f.at, int64(len(f.data)))
+	atomic.StoreInt64(&f.at, int64(len(f.fileData.data)))
 	return
 }
 
@@ -219,27 +250,27 @@
 }
 
 func (f *File) Info() *FileInfo {
-	return &FileInfo{file: f}
+	return &FileInfo{f.fileData}
 }
 
 type FileInfo struct {
-	file *File
+	*FileData
 }
 
 // Implements os.FileInfo
 func (s *FileInfo) Name() string {
-	_, name := filepath.Split(s.file.Name())
+	_, name := filepath.Split(s.name)
 	return name
 }
-func (s *FileInfo) Mode() os.FileMode  { return s.file.mode }
-func (s *FileInfo) ModTime() time.Time { return s.file.modtime }
-func (s *FileInfo) IsDir() bool        { return s.file.dir }
+func (s *FileInfo) Mode() os.FileMode  { return s.mode }
+func (s *FileInfo) ModTime() time.Time { return s.modtime }
+func (s *FileInfo) IsDir() bool        { return s.dir }
 func (s *FileInfo) Sys() interface{}   { return nil }
 func (s *FileInfo) Size() int64 {
 	if s.IsDir() {
 		return int64(42)
 	}
-	return int64(len(s.file.data))
+	return int64(len(s.data))
 }
 
 var (
diff --git a/memmap.go b/memmap.go
index ff9da99..21fbe67 100644
--- a/memmap.go
+++ b/memmap.go
@@ -14,7 +14,6 @@
 package afero
 
 import (
-	"errors"
 	"fmt"
 	"log"
 	"os"
@@ -28,15 +27,15 @@
 
 type MemMapFs struct {
 	mu   sync.RWMutex
-	data map[string]File
+	data map[string]*mem.FileData
 	init sync.Once
 }
 
 var memfsInit sync.Once
 
-func (m *MemMapFs) getData() map[string]File {
+func (m *MemMapFs) getData() map[string]*mem.FileData {
 	m.init.Do(func() {
-		m.data = make(map[string]File)
+		m.data = make(map[string]*mem.FileData)
 		// Root should always exist, right?
 		// TODO: what about windows?
 		m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator)
@@ -53,7 +52,7 @@
 	m.getData()[name] = file
 	m.registerWithParent(file)
 	m.mu.Unlock()
-	return file, nil
+	return mem.NewFileHandle(file), nil
 }
 
 func (m *MemMapFs) unRegisterWithParent(fileName string) error {
@@ -65,13 +64,11 @@
 	if parent == nil {
 		log.Fatal("parent of ", f.Name(), " is nil")
 	}
-	pmem := parent.(*mem.File)
-	fmem := f.(*mem.File)
-	mem.RemoveFromMemDir(pmem, fmem)
+	mem.RemoveFromMemDir(parent, f)
 	return nil
 }
 
-func (m *MemMapFs) findParent(f File) File {
+func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData {
 	pdir, _ := filepath.Split(f.Name())
 	pdir = filepath.Clean(pdir)
 	pfile, err := m.lockfreeOpen(pdir)
@@ -81,7 +78,7 @@
 	return pfile
 }
 
-func (m *MemMapFs) registerWithParent(f File) {
+func (m *MemMapFs) registerWithParent(f *mem.FileData) {
 	if f == nil {
 		return
 	}
@@ -99,15 +96,9 @@
 			return
 		}
 	}
-	pmem := parent.(*mem.File)
-	fmem := f.(*mem.File)
 
-	// TODO(mbertschler): memDir is only nil when it was not made with Mkdir
-	// or lockfreeMkdir. In this case the parent is also not a real directory.
-	// This currently only happens for the file ".".
-	// This is a quick hack to make the library usable with relative paths.
-	mem.InitializeDir(pmem)
-	mem.AddToMemDir(pmem, fmem)
+	mem.InitializeDir(parent)
+	mem.AddToMemDir(parent, f)
 }
 
 func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error {
@@ -115,13 +106,10 @@
 	x, ok := m.getData()[name]
 	if ok {
 		// Only return ErrFileExists if it's a file, not a directory.
-		i, err := x.Stat()
+		i := mem.FileInfo{x}
 		if !i.IsDir() {
 			return ErrFileExists
 		}
-		if err != nil {
-			return err
-		}
 	} else {
 		item := mem.CreateDir(name)
 		m.getData()[name] = item
@@ -175,30 +163,37 @@
 }
 
 func (m *MemMapFs) Open(name string) (File, error) {
+	f, err := m.open(name)
+	if f != nil {
+		return mem.NewReadOnlyFileHandle(f), err
+	}
+	return nil, err
+}
+
+func (m *MemMapFs) openWrite(name string) (File, error) {
+	f, err := m.open(name)
+	if f != nil {
+		return mem.NewFileHandle(f), err
+	}
+	return nil, err
+}
+
+func (m *MemMapFs) open(name string) (*mem.FileData, error) {
 	name = normalizePath(name)
 
 	m.mu.RLock()
 	f, ok := m.getData()[name]
-	ff, ok := f.(*mem.File)
-
-	if ok {
-		ff.Open()
-	}
 	m.mu.RUnlock()
-
-	if ok {
-		return f, nil
-	} else {
+	if !ok {
 		return nil, &os.PathError{"open", name, ErrFileNotFound}
 	}
+	return f, nil
 }
 
-func (m *MemMapFs) lockfreeOpen(name string) (File, error) {
+func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) {
 	name = normalizePath(name)
 	f, ok := m.getData()[name]
-	ff, ok := f.(*mem.File)
 	if ok {
-		ff.Open()
 		return f, nil
 	} else {
 		return nil, ErrFileNotFound
@@ -206,13 +201,16 @@
 }
 
 func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	file, err := m.Open(name)
+	file, err := m.openWrite(name)
 	if os.IsNotExist(err) && (flag&os.O_CREATE > 0) {
 		file, err = m.Create(name)
 	}
 	if err != nil {
 		return nil, err
 	}
+	if flag == os.O_RDONLY {
+		file = mem.NewReadOnlyFileHandle(file.(*mem.File).Data())
+	}
 	if flag&os.O_APPEND > 0 {
 		_, err = file.Seek(0, os.SEEK_END)
 		if err != nil {
@@ -280,20 +278,16 @@
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	if _, ok := m.getData()[oldname]; ok {
-		if _, ok := m.getData()[newname]; !ok {
-			m.mu.RUnlock()
-			m.mu.Lock()
-			m.unRegisterWithParent(oldname)
-			file := m.getData()[oldname].(*mem.File)
-			delete(m.getData(), oldname)
-			mem.ChangeFileName(file, newname)
-			m.getData()[newname] = file
-			m.registerWithParent(file)
-			m.mu.Unlock()
-			m.mu.RLock()
-		} else {
-			return &os.PathError{"rename", newname, ErrDestinationExists}
-		}
+		m.mu.RUnlock()
+		m.mu.Lock()
+		m.unRegisterWithParent(oldname)
+		fileData := m.getData()[oldname]
+		delete(m.getData(), oldname)
+		mem.ChangeFileName(fileData, newname)
+		m.getData()[newname] = fileData
+		m.registerWithParent(fileData)
+		m.mu.Unlock()
+		m.mu.RLock()
 	} else {
 		return &os.PathError{"rename", oldname, ErrFileNotFound}
 	}
@@ -305,7 +299,7 @@
 	if err != nil {
 		return nil, err
 	}
-	fi := mem.GetFileInfo(f.(*mem.File))
+	fi := mem.GetFileInfo(f.(*mem.File).Data())
 	return fi, nil
 }
 
@@ -316,14 +310,10 @@
 		return &os.PathError{"chmod", name, ErrFileNotFound}
 	}
 
-	ff, ok := f.(*mem.File)
-	if ok {
-		m.mu.Lock()
-		mem.SetMode(ff, mode)
-		m.mu.Unlock()
-	} else {
-		return errors.New("Unable to Chmod Memory File")
-	}
+	m.mu.Lock()
+	mem.SetMode(f, mode)
+	m.mu.Unlock()
+
 	return nil
 }
 
@@ -334,20 +324,16 @@
 		return &os.PathError{"chtimes", name, ErrFileNotFound}
 	}
 
-	ff, ok := f.(*mem.File)
-	if ok {
-		m.mu.Lock()
-		mem.SetModTime(ff, mtime)
-		m.mu.Unlock()
-	} else {
-		return errors.New("Unable to Chtime Memory File")
-	}
+	m.mu.Lock()
+	mem.SetModTime(f, mtime)
+	m.mu.Unlock()
+
 	return nil
 }
 
 func (m *MemMapFs) List() {
 	for _, x := range m.data {
-		y, _ := x.Stat()
+		y := mem.FileInfo{x}
 		fmt.Println(x.Name(), y.Size())
 	}
 }
diff --git a/memmap_test.go b/memmap_test.go
index ce9a4e5..f090df7 100644
--- a/memmap_test.go
+++ b/memmap_test.go
@@ -100,3 +100,153 @@
 		t.Error(op+":", err, "contains another os.PathError")
 	}
 }
+
+// Fails if multiple file objects use the same file.at counter in MemMapFs
+func TestMultipleOpenFiles(t *testing.T) {
+	defer removeAllTestFiles(t)
+	const fileName = "afero-demo2.txt"
+
+	var data = make([][]byte, len(Fss))
+
+	for i, fs := range Fss {
+		dir := testDir(fs)
+		path := filepath.Join(dir, fileName)
+		fh1, err := fs.Create(path)
+		if err != nil {
+			t.Error("fs.Create failed: " + err.Error())
+		}
+		_, err = fh1.Write([]byte("test"))
+		if err != nil {
+			t.Error("fh.Write failed: " + err.Error())
+		}
+		_, err = fh1.Seek(0, os.SEEK_SET)
+		if err != nil {
+			t.Error(err)
+		}
+
+		fh2, err := fs.OpenFile(path, os.O_RDWR, 0777)
+		if err != nil {
+			t.Error("fs.OpenFile failed: " + err.Error())
+		}
+		_, err = fh2.Seek(0, os.SEEK_END)
+		if err != nil {
+			t.Error(err)
+		}
+		_, err = fh2.Write([]byte("data"))
+		if err != nil {
+			t.Error(err)
+		}
+		err = fh2.Close()
+		if err != nil {
+			t.Error(err)
+		}
+
+		_, err = fh1.Write([]byte("data"))
+		if err != nil {
+			t.Error(err)
+		}
+		err = fh1.Close()
+		if err != nil {
+			t.Error(err)
+		}
+		// the file now should contain "datadata"
+		data[i], err = ReadFile(fs, path)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	for i, fs := range Fss {
+		if i == 0 {
+			continue
+		}
+		if string(data[0]) != string(data[i]) {
+			t.Errorf("%s and %s don't behave the same\n"+
+				"%s: \"%s\"\n%s: \"%s\"\n",
+				Fss[0].Name(), fs.Name(), Fss[0].Name(), data[0], fs.Name(), data[i])
+		}
+	}
+}
+
+// Test if file.Write() fails when opened as read only
+func TestReadOnly(t *testing.T) {
+	defer removeAllTestFiles(t)
+	const fileName = "afero-demo.txt"
+
+	for _, fs := range Fss {
+		dir := testDir(fs)
+		path := filepath.Join(dir, fileName)
+
+		f, err := fs.Create(path)
+		if err != nil {
+			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
+		}
+		_, err = f.Write([]byte("test"))
+		if err != nil {
+			t.Error(fs.Name()+":", "Write failed: "+err.Error())
+		}
+		f.Close()
+
+		f, err = fs.Open(path)
+		if err != nil {
+			t.Error("fs.Open failed: " + err.Error())
+		}
+		_, err = f.Write([]byte("data"))
+		if err == nil {
+			t.Error(fs.Name()+":", "No write error")
+		}
+		f.Close()
+
+		f, err = fs.OpenFile(path, os.O_RDONLY, 0644)
+		if err != nil {
+			t.Error("fs.Open failed: " + err.Error())
+		}
+		_, err = f.Write([]byte("data"))
+		if err == nil {
+			t.Error(fs.Name()+":", "No write error")
+		}
+		f.Close()
+	}
+}
+
+func TestWriteCloseTime(t *testing.T) {
+	defer removeAllTestFiles(t)
+	const fileName = "afero-demo.txt"
+
+	for _, fs := range Fss {
+		dir := testDir(fs)
+		path := filepath.Join(dir, fileName)
+
+		f, err := fs.Create(path)
+		if err != nil {
+			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
+		}
+		f.Close()
+
+		f, err = fs.Create(path)
+		if err != nil {
+			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
+		}
+		fi, err := f.Stat()
+		if err != nil {
+			t.Error(fs.Name()+":", "Stat failed: "+err.Error())
+		}
+		timeBefore := fi.ModTime()
+		// sorry for the delay, but we have to make sure time advances, also
+		// on non Un*x systems...
+		time.Sleep(2 * time.Second)
+
+		_, err = f.Write([]byte("test"))
+		if err != nil {
+			t.Error(fs.Name()+":", "Write failed: "+err.Error())
+		}
+		f.Close()
+		fi, err = fs.Stat(path)
+		if err != nil {
+			t.Error(fs.Name()+":", "fs.Stat failed: "+err.Error())
+		}
+		if fi.ModTime().Equal(timeBefore) {
+			t.Error(fs.Name()+":", "ModTime was not set on Close()")
+		}
+	}
+}