swarm: network rewrite merge

6 files changed, 1422 insertions, 509 deletions

diff --git a/swarm/fuse/fuse_dir.go b/swarm/fuse/fuse_dir.go
index a7701985e..7f66451f1 100644
--- a/swarm/fuse/fuse_dir.go
+++ b/swarm/fuse/fuse_dir.go
@@ -25,6 +25,7 @@ import (
 
 	"bazil.org/fuse"
 	"bazil.org/fuse/fs"
+	"github.com/ethereum/go-ethereum/swarm/log"
 	"golang.org/x/net/context"
 )
 
@@ -49,6 +50,7 @@ type SwarmDir struct {
 }
 
 func NewSwarmDir(fullpath string, minfo *MountInfo) *SwarmDir {
+	log.Debug("swarmfs", "NewSwarmDir", fullpath)
 	newdir := &SwarmDir{
 		inode:       NewInode(),
 		name:        filepath.Base(fullpath),
@@ -62,6 +64,8 @@ func NewSwarmDir(fullpath string, minfo *MountInfo) *SwarmDir {
 }
 
 func (sd *SwarmDir) Attr(ctx context.Context, a *fuse.Attr) error {
+	sd.lock.RLock()
+	defer sd.lock.RUnlock()
 	a.Inode = sd.inode
 	a.Mode = os.ModeDir | 0700
 	a.Uid = uint32(os.Getuid())
@@ -70,7 +74,7 @@ func (sd *SwarmDir) Attr(ctx context.Context, a *fuse.Attr) error {
 }
 
 func (sd *SwarmDir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (fs.Node, error) {
-
+	log.Debug("swarmfs", "Lookup", req.Name)
 	for _, n := range sd.files {
 		if n.name == req.Name {
 			return n, nil
@@ -85,6 +89,7 @@ func (sd *SwarmDir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *f
 }
 
 func (sd *SwarmDir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
+	log.Debug("swarmfs ReadDirAll")
 	var children []fuse.Dirent
 	for _, file := range sd.files {
 		children = append(children, fuse.Dirent{Inode: file.inode, Type: fuse.DT_File, Name: file.name})
@@ -96,6 +101,7 @@ func (sd *SwarmDir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
 }
 
 func (sd *SwarmDir) Create(ctx context.Context, req *fuse.CreateRequest, resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) {
+	log.Debug("swarmfs Create", "path", sd.path, "req.Name", req.Name)
 
 	newFile := NewSwarmFile(sd.path, req.Name, sd.mountInfo)
 	newFile.fileSize = 0 // 0 means, file is not in swarm yet and it is just created
@@ -108,6 +114,7 @@ func (sd *SwarmDir) Create(ctx context.Context, req *fuse.CreateRequest, resp *f
 }
 
 func (sd *SwarmDir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
+	log.Debug("swarmfs Remove", "path", sd.path, "req.Name", req.Name)
 
 	if req.Dir && sd.directories != nil {
 		newDirs := []*SwarmDir{}
@@ -144,13 +151,11 @@ func (sd *SwarmDir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
 }
 
 func (sd *SwarmDir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
-
-	newDir := NewSwarmDir(req.Name, sd.mountInfo)
-
+	log.Debug("swarmfs Mkdir", "path", sd.path, "req.Name", req.Name)
+	newDir := NewSwarmDir(filepath.Join(sd.path, req.Name), sd.mountInfo)
 	sd.lock.Lock()
 	defer sd.lock.Unlock()
 	sd.directories = append(sd.directories, newDir)
 
 	return newDir, nil
-
 }
diff --git a/swarm/fuse/fuse_file.go b/swarm/fuse/fuse_file.go
index c94a0773f..80c26fe05 100644
--- a/swarm/fuse/fuse_file.go
+++ b/swarm/fuse/fuse_file.go
@@ -26,7 +26,7 @@ import (
 
 	"bazil.org/fuse"
 	"bazil.org/fuse/fs"
-	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/swarm/log"
 	"github.com/ethereum/go-ethereum/swarm/storage"
 	"golang.org/x/net/context"
 )
@@ -50,7 +50,7 @@ type SwarmFile struct {
 	inode    uint64
 	name     string
 	path     string
-	key      storage.Key
+	addr     storage.Address
 	fileSize int64
 	reader   storage.LazySectionReader
 
@@ -63,7 +63,7 @@ func NewSwarmFile(path, fname string, minfo *MountInfo) *SwarmFile {
 		inode:    NewInode(),
 		name:     fname,
 		path:     path,
-		key:      nil,
+		addr:     nil,
 		fileSize: -1, // -1 means , file already exists in swarm and you need to just get the size from swarm
 		reader:   nil,
 
@@ -73,33 +73,38 @@ func NewSwarmFile(path, fname string, minfo *MountInfo) *SwarmFile {
 	return newFile
 }
 
-func (file *SwarmFile) Attr(ctx context.Context, a *fuse.Attr) error {
-
-	a.Inode = file.inode
+func (sf *SwarmFile) Attr(ctx context.Context, a *fuse.Attr) error {
+	log.Debug("swarmfs Attr", "path", sf.path)
+	sf.lock.Lock()
+	defer sf.lock.Unlock()
+	a.Inode = sf.inode
 	//TODO: need to get permission as argument
 	a.Mode = 0700
 	a.Uid = uint32(os.Getuid())
 	a.Gid = uint32(os.Getegid())
 
-	if file.fileSize == -1 {
-		reader := file.mountInfo.swarmApi.Retrieve(file.key)
+	if sf.fileSize == -1 {
+		reader, _ := sf.mountInfo.swarmApi.Retrieve(sf.addr)
 		quitC := make(chan bool)
 		size, err := reader.Size(quitC)
 		if err != nil {
-			log.Warn("Couldnt get size of file %s : %v", file.path, err)
+			log.Error("Couldnt get size of file %s : %v", sf.path, err)
+			return err
 		}
-		file.fileSize = size
+		sf.fileSize = size
+		log.Trace("swarmfs Attr", "size", size)
+		close(quitC)
 	}
-	a.Size = uint64(file.fileSize)
+	a.Size = uint64(sf.fileSize)
 	return nil
 }
 
 func (sf *SwarmFile) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
-
+	log.Debug("swarmfs Read", "path", sf.path, "req.String", req.String())
 	sf.lock.RLock()
 	defer sf.lock.RUnlock()
 	if sf.reader == nil {
-		sf.reader = sf.mountInfo.swarmApi.Retrieve(sf.key)
+		sf.reader, _ = sf.mountInfo.swarmApi.Retrieve(sf.addr)
 	}
 	buf := make([]byte, req.Size)
 	n, err := sf.reader.ReadAt(buf, req.Offset)
@@ -108,26 +113,23 @@ func (sf *SwarmFile) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse
 	}
 	resp.Data = buf[:n]
 	sf.reader = nil
-	return err
 
+	return err
 }
 
 func (sf *SwarmFile) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {
-
+	log.Debug("swarmfs Write", "path", sf.path, "req.String", req.String())
 	if sf.fileSize == 0 && req.Offset == 0 {
-
 		// A new file is created
 		err := addFileToSwarm(sf, req.Data, len(req.Data))
 		if err != nil {
 			return err
 		}
 		resp.Size = len(req.Data)
-
 	} else if req.Offset <= sf.fileSize {
-
 		totalSize := sf.fileSize + int64(len(req.Data))
 		if totalSize > MaxAppendFileSize {
-			log.Warn("Append file size reached (%v) : (%v)", sf.fileSize, len(req.Data))
+			log.Warn("swarmfs Append file size reached (%v) : (%v)", sf.fileSize, len(req.Data))
 			return errFileSizeMaxLimixReached
 		}
 
@@ -137,9 +139,8 @@ func (sf *SwarmFile) Write(ctx context.Context, req *fuse.WriteRequest, resp *fu
 		}
 		resp.Size = len(req.Data)
 	} else {
-		log.Warn("Invalid write request size(%v) : off(%v)", sf.fileSize, req.Offset)
+		log.Warn("swarmfs Invalid write request size(%v) : off(%v)", sf.fileSize, req.Offset)
 		return errInvalidOffset
 	}
-
 	return nil
 }
diff --git a/swarm/fuse/swarmfs.go b/swarm/fuse/swarmfs.go
index e56d0ad4e..c7aa983b7 100644
--- a/swarm/fuse/swarmfs.go
+++ b/swarm/fuse/swarmfs.go
@@ -39,12 +39,12 @@ var (
 )
 
 type SwarmFS struct {
-	swarmApi     *api.Api
+	swarmApi     *api.API
 	activeMounts map[string]*MountInfo
 	swarmFsLock  *sync.RWMutex
 }
 
-func NewSwarmFS(api *api.Api) *SwarmFS {
+func NewSwarmFS(api *api.API) *SwarmFS {
 	swarmfsLock.Do(func() {
 		swarmfs = &SwarmFS{
 			swarmApi:     api,
diff --git a/swarm/fuse/swarmfs_test.go b/swarm/fuse/swarmfs_test.go
index 42af36345..accf9b02b 100644
--- a/swarm/fuse/swarmfs_test.go
+++ b/swarm/fuse/swarmfs_test.go
@@ -1,4 +1,4 @@
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -21,6 +21,8 @@ package fuse
 import (
 	"bytes"
 	"crypto/rand"
+	"flag"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -29,8 +31,24 @@ import (
 
 	"github.com/ethereum/go-ethereum/swarm/api"
 	"github.com/ethereum/go-ethereum/swarm/storage"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	colorable "github.com/mattn/go-colorable"
+)
+
+var (
+	loglevel    = flag.Int("loglevel", 4, "verbosity of logs")
+	rawlog      = flag.Bool("rawlog", false, "turn off terminal formatting in logs")
+	longrunning = flag.Bool("longrunning", false, "do run long-running tests")
 )
 
+func init() {
+	flag.Parse()
+	log.PrintOrigins(true)
+	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(!*rawlog))))
+}
+
 type fileInfo struct {
 	perm     uint64
 	uid      int
@@ -38,41 +56,70 @@ type fileInfo struct {
 	contents []byte
 }
 
-func createTestFilesAndUploadToSwarm(t *testing.T, api *api.Api, files map[string]fileInfo, uploadDir string) string {
-	os.RemoveAll(uploadDir)
+//create files from the map of name and content provided and upload them to swarm via api
+func createTestFilesAndUploadToSwarm(t *testing.T, api *api.API, files map[string]fileInfo, uploadDir string, toEncrypt bool) string {
 
+	//iterate the map
 	for fname, finfo := range files {
 		actualPath := filepath.Join(uploadDir, fname)
 		filePath := filepath.Dir(actualPath)
 
+		//create directory
 		err := os.MkdirAll(filePath, 0777)
 		if err != nil {
 			t.Fatalf("Error creating directory '%v' : %v", filePath, err)
 		}
 
+		//create file
 		fd, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(finfo.perm))
 		if err1 != nil {
 			t.Fatalf("Error creating file %v: %v", actualPath, err1)
 		}
 
-		fd.Write(finfo.contents)
-		fd.Chown(finfo.uid, finfo.gid)
-		fd.Chmod(os.FileMode(finfo.perm))
-		fd.Sync()
-		fd.Close()
+		//write content to file
+		_, err = fd.Write(finfo.contents)
+		if err != nil {
+			t.Fatalf("Error writing to file '%v' : %v", filePath, err)
+		}
+		/*
+				Note @holisticode: It's not clear why the Chown command was added to the test suite.
+				Some files are initialized with different permissions in the individual test,
+				resulting in errors on Chown which were not checked.
+			  After adding the checks tests would fail.
+
+				What's then the reason to have this check in the first place?
+				Disabling for now
+
+			  err = fd.Chown(finfo.uid, finfo.gid)
+			  if err != nil {
+			    t.Fatalf("Error chown file '%v' : %v", filePath, err)
+				}
+		*/
+		err = fd.Chmod(os.FileMode(finfo.perm))
+		if err != nil {
+			t.Fatalf("Error chmod file '%v' : %v", filePath, err)
+		}
+		err = fd.Sync()
+		if err != nil {
+			t.Fatalf("Error sync file '%v' : %v", filePath, err)
+		}
+		err = fd.Close()
+		if err != nil {
+			t.Fatalf("Error closing file '%v' : %v", filePath, err)
+		}
 	}
 
-	bzzhash, err := api.Upload(uploadDir, "")
+	//upload directory to swarm and return hash
+	bzzhash, err := api.Upload(uploadDir, "", toEncrypt)
 	if err != nil {
-		t.Fatalf("Error uploading directory %v: %v", uploadDir, err)
+		t.Fatalf("Error uploading directory %v: %vm encryption: %v", uploadDir, err, toEncrypt)
 	}
 
 	return bzzhash
 }
 
-func mountDir(t *testing.T, api *api.Api, files map[string]fileInfo, bzzHash string, mountDir string) *SwarmFS {
-	os.RemoveAll(mountDir)
-	os.MkdirAll(mountDir, 0777)
+//mount a swarm hash as a directory on files system via FUSE
+func mountDir(t *testing.T, api *api.API, files map[string]fileInfo, bzzHash string, mountDir string) *SwarmFS {
 	swarmfs := NewSwarmFS(api)
 	_, err := swarmfs.Mount(bzzHash, mountDir)
 	if isFUSEUnsupportedError(err) {
@@ -81,17 +128,21 @@ func mountDir(t *testing.T, api *api.Api, files map[string]fileInfo, bzzHash str
 		t.Fatalf("Error mounting hash %v: %v", bzzHash, err)
 	}
 
+	//check directory is mounted
 	found := false
 	mi := swarmfs.Listmounts()
 	for _, minfo := range mi {
+		minfo.lock.RLock()
 		if minfo.MountPoint == mountDir {
 			if minfo.StartManifest != bzzHash ||
 				minfo.LatestManifest != bzzHash ||
 				minfo.fuseConnection == nil {
+				minfo.lock.RUnlock()
 				t.Fatalf("Error mounting: exp(%s): act(%s)", bzzHash, minfo.StartManifest)
 			}
 			found = true
 		}
+		minfo.lock.RUnlock()
 	}
 
 	// Test listMounts
@@ -105,6 +156,7 @@ func mountDir(t *testing.T, api *api.Api, files map[string]fileInfo, bzzHash str
 	return swarmfs
 }
 
+// Check if file and their attributes are as expected
 func compareGeneratedFileWithFileInMount(t *testing.T, files map[string]fileInfo, mountDir string) {
 	err := filepath.Walk(mountDir, func(path string, f os.FileInfo, err error) error {
 		if f.IsDir() {
@@ -142,12 +194,12 @@ func compareGeneratedFileWithFileInMount(t *testing.T, files map[string]fileInfo
 		}
 		if !bytes.Equal(fileContents, finfo.contents) {
 			t.Fatalf("File %v contents mismatch: %v , %v", fname, fileContents, finfo.contents)
-
 		}
 		// TODO: check uid and gid
 	}
 }
 
+//check mounted file with provided content
 func checkFile(t *testing.T, testMountDir, fname string, contents []byte) {
 	destinationFile := filepath.Join(testMountDir, fname)
 	dfinfo, err1 := os.Stat(destinationFile)
@@ -163,15 +215,21 @@ func checkFile(t *testing.T, testMountDir, fname string, contents []byte) {
 		t.Fatalf("Could not open file %v", destinationFile)
 	}
 	newcontent := make([]byte, len(contents))
-	fd.Read(newcontent)
-	fd.Close()
+	_, err := fd.Read(newcontent)
+	if err != nil {
+		t.Fatalf("Could not read from file %v", err)
+	}
+	err = fd.Close()
+	if err != nil {
+		t.Fatalf("Could not close file %v", err)
+	}
 
 	if !bytes.Equal(contents, newcontent) {
 		t.Fatalf("File content mismatch expected (%v): received (%v) ", contents, newcontent)
 	}
 }
 
-func getRandomBtes(size int) []byte {
+func getRandomBytes(size int) []byte {
 	contents := make([]byte, size)
 	rand.Read(contents)
 	return contents
@@ -190,647 +248,1448 @@ func isDirEmpty(name string) bool {
 }
 
 type testAPI struct {
-	api *api.Api
-}
-
-func (ta *testAPI) mountListAndUnmount(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "fuse-source")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "fuse-dest")
-
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["2.txt"] = fileInfo{0711, 333, 444, getRandomBtes(10)}
-	files["3.txt"] = fileInfo{0622, 333, 444, getRandomBtes(100)}
-	files["4.txt"] = fileInfo{0533, 333, 444, getRandomBtes(1024)}
-	files["5.txt"] = fileInfo{0544, 333, 444, getRandomBtes(10)}
-	files["6.txt"] = fileInfo{0555, 333, 444, getRandomBtes(10)}
-	files["7.txt"] = fileInfo{0666, 333, 444, getRandomBtes(10)}
-	files["8.txt"] = fileInfo{0777, 333, 333, getRandomBtes(10)}
-	files["11.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
-	files["111.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
-	files["two/2.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
-	files["two/2/2.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
-	files["two/2./2.txt"] = fileInfo{0777, 444, 444, getRandomBtes(10)}
-	files["twice/2.txt"] = fileInfo{0777, 444, 333, getRandomBtes(200)}
-	files["one/two/three/four/five/six/seven/eight/nine/10.txt"] = fileInfo{0777, 333, 444, getRandomBtes(10240)}
-	files["one/two/three/four/five/six/six"] = fileInfo{0777, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
-
-	swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs.Stop()
+	api *api.API
+}
+
+type testData struct {
+	testDir       string
+	testUploadDir string
+	testMountDir  string
+	bzzHash       string
+	files         map[string]fileInfo
+	toEncrypt     bool
+	swarmfs       *SwarmFS
+}
+
+//create the root dir of a test
+func (ta *testAPI) initSubtest(name string) (*testData, error) {
+	var err error
+	d := &testData{}
+	d.testDir, err = ioutil.TempDir(os.TempDir(), name)
+	if err != nil {
+		return nil, fmt.Errorf("Couldn't create test dir: %v", err)
+	}
+	return d, nil
+}
+
+//upload data and mount directory
+func (ta *testAPI) uploadAndMount(dat *testData, t *testing.T) (*testData, error) {
+	//create upload dir
+	err := os.MkdirAll(dat.testUploadDir, 0777)
+	if err != nil {
+		return nil, fmt.Errorf("Couldn't create upload dir: %v", err)
+	}
+	//create mount dir
+	err = os.MkdirAll(dat.testMountDir, 0777)
+	if err != nil {
+		return nil, fmt.Errorf("Couldn't create mount dir: %v", err)
+	}
+	//upload the file
+	dat.bzzHash = createTestFilesAndUploadToSwarm(t, ta.api, dat.files, dat.testUploadDir, dat.toEncrypt)
+	log.Debug("Created test files and uploaded to Swarm")
+	//mount the directory
+	dat.swarmfs = mountDir(t, ta.api, dat.files, dat.bzzHash, dat.testMountDir)
+	log.Debug("Mounted swarm fs")
+	return dat, nil
+}
+
+//add a directory to the test directory tree
+func addDir(root string, name string) (string, error) {
+	d := filepath.Join(root, name)
+	err := os.MkdirAll(d, 0777)
+	if err != nil {
+		return "", fmt.Errorf("Couldn't create dir inside test dir: %v", err)
+	}
+	return d, nil
+}
 
+func (ta *testAPI) mountListAndUnmountEncrypted(t *testing.T) {
+	log.Debug("Starting mountListAndUnmountEncrypted test")
+	ta.mountListAndUnmount(t, true)
+	log.Debug("Test mountListAndUnmountEncrypted terminated")
+}
+
+func (ta *testAPI) mountListAndUnmountNonEncrypted(t *testing.T) {
+	log.Debug("Starting mountListAndUnmountNonEncrypted test")
+	ta.mountListAndUnmount(t, false)
+	log.Debug("Test mountListAndUnmountNonEncrypted terminated")
+}
+
+//mount a directory unmount and check the directory is empty afterwards
+func (ta *testAPI) mountListAndUnmount(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("mountListAndUnmount")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
+
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "testUploadDir")
+	dat.testMountDir = filepath.Join(dat.testDir, "testMountDir")
+	dat.files = make(map[string]fileInfo)
+
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["2.txt"] = fileInfo{0711, 333, 444, getRandomBytes(10)}
+	dat.files["3.txt"] = fileInfo{0622, 333, 444, getRandomBytes(100)}
+	dat.files["4.txt"] = fileInfo{0533, 333, 444, getRandomBytes(1024)}
+	dat.files["5.txt"] = fileInfo{0544, 333, 444, getRandomBytes(10)}
+	dat.files["6.txt"] = fileInfo{0555, 333, 444, getRandomBytes(10)}
+	dat.files["7.txt"] = fileInfo{0666, 333, 444, getRandomBytes(10)}
+	dat.files["8.txt"] = fileInfo{0777, 333, 333, getRandomBytes(10)}
+	dat.files["11.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
+	dat.files["111.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
+	dat.files["two/2.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
+	dat.files["two/2/2.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
+	dat.files["two/2./2.txt"] = fileInfo{0777, 444, 444, getRandomBytes(10)}
+	dat.files["twice/2.txt"] = fileInfo{0777, 444, 333, getRandomBytes(200)}
+	dat.files["one/two/three/four/five/six/seven/eight/nine/10.txt"] = fileInfo{0777, 333, 444, getRandomBytes(10240)}
+	dat.files["one/two/three/four/five/six/six"] = fileInfo{0777, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 	// Check unmount
-	_, err := swarmfs.Unmount(testMountDir)
-	if err != nil {
-		t.Fatalf("could not unmount  %v", bzzHash)
-	}
-	if !isDirEmpty(testMountDir) {
-		t.Fatalf("unmount didnt work for %v", testMountDir)
-	}
-
-}
-
-func (ta *testAPI) maxMounts(t *testing.T) {
-	files := make(map[string]fileInfo)
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir1, _ := ioutil.TempDir(os.TempDir(), "max-upload1")
-	bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1)
-	mount1, _ := ioutil.TempDir(os.TempDir(), "max-mount1")
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash1, mount1)
-	defer swarmfs1.Stop()
-
-	files["2.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir2, _ := ioutil.TempDir(os.TempDir(), "max-upload2")
-	bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2)
-	mount2, _ := ioutil.TempDir(os.TempDir(), "max-mount2")
-	swarmfs2 := mountDir(t, ta.api, files, bzzHash2, mount2)
-	defer swarmfs2.Stop()
-
-	files["3.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir3, _ := ioutil.TempDir(os.TempDir(), "max-upload3")
-	bzzHash3 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir3)
-	mount3, _ := ioutil.TempDir(os.TempDir(), "max-mount3")
-	swarmfs3 := mountDir(t, ta.api, files, bzzHash3, mount3)
-	defer swarmfs3.Stop()
-
-	files["4.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir4, _ := ioutil.TempDir(os.TempDir(), "max-upload4")
-	bzzHash4 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir4)
-	mount4, _ := ioutil.TempDir(os.TempDir(), "max-mount4")
-	swarmfs4 := mountDir(t, ta.api, files, bzzHash4, mount4)
-	defer swarmfs4.Stop()
-
-	files["5.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir5, _ := ioutil.TempDir(os.TempDir(), "max-upload5")
-	bzzHash5 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir5)
-	mount5, _ := ioutil.TempDir(os.TempDir(), "max-mount5")
-	swarmfs5 := mountDir(t, ta.api, files, bzzHash5, mount5)
-	defer swarmfs5.Stop()
-
-	files["6.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir6, _ := ioutil.TempDir(os.TempDir(), "max-upload6")
-	bzzHash6 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir6)
-	mount6, _ := ioutil.TempDir(os.TempDir(), "max-mount6")
-
-	os.RemoveAll(mount6)
-	os.MkdirAll(mount6, 0777)
-	_, err := swarmfs.Mount(bzzHash6, mount6)
+	_, err = dat.swarmfs.Unmount(dat.testMountDir)
+	if err != nil {
+		t.Fatalf("could not unmount  %v", dat.bzzHash)
+	}
+	log.Debug("Unmount successful")
+	if !isDirEmpty(dat.testMountDir) {
+		t.Fatalf("unmount didnt work for %v", dat.testMountDir)
+	}
+	log.Debug("subtest terminated")
+}
+
+func (ta *testAPI) maxMountsEncrypted(t *testing.T) {
+	log.Debug("Starting maxMountsEncrypted test")
+	ta.runMaxMounts(t, true)
+	log.Debug("Test maxMountsEncrypted terminated")
+}
+
+func (ta *testAPI) maxMountsNonEncrypted(t *testing.T) {
+	log.Debug("Starting maxMountsNonEncrypted test")
+	ta.runMaxMounts(t, false)
+	log.Debug("Test maxMountsNonEncrypted terminated")
+}
+
+//mount several different directories until the maximum has been reached
+func (ta *testAPI) runMaxMounts(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("runMaxMounts")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
+
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "max-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "max-mount1")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
+
+	dat.testUploadDir = filepath.Join(dat.testDir, "max-upload2")
+	dat.testMountDir = filepath.Join(dat.testDir, "max-mount2")
+	dat.files["2.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+
+	dat.testUploadDir = filepath.Join(dat.testDir, "max-upload3")
+	dat.testMountDir = filepath.Join(dat.testDir, "max-mount3")
+	dat.files["3.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+
+	dat.testUploadDir = filepath.Join(dat.testDir, "max-upload4")
+	dat.testMountDir = filepath.Join(dat.testDir, "max-mount4")
+	dat.files["4.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+
+	dat.testUploadDir = filepath.Join(dat.testDir, "max-upload5")
+	dat.testMountDir = filepath.Join(dat.testDir, "max-mount5")
+	dat.files["5.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+
+	//now try an additional mount, should fail due to max mounts reached
+	testUploadDir6 := filepath.Join(dat.testDir, "max-upload6")
+	err = os.MkdirAll(testUploadDir6, 0777)
+	if err != nil {
+		t.Fatalf("Couldn't create upload dir 6: %v", err)
+	}
+	dat.files["6.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	testMountDir6 := filepath.Join(dat.testDir, "max-mount6")
+	err = os.MkdirAll(testMountDir6, 0777)
+	if err != nil {
+		t.Fatalf("Couldn't create mount dir 5: %v", err)
+	}
+	bzzHash6 := createTestFilesAndUploadToSwarm(t, ta.api, dat.files, testUploadDir6, toEncrypt)
+	log.Debug("Created test files and uploaded to swarm with uploadDir6")
+	_, err = dat.swarmfs.Mount(bzzHash6, testMountDir6)
 	if err == nil {
-		t.Fatalf("Error: Going beyond max mounts  %v", bzzHash6)
+		t.Fatalf("Expected this mount to fail due to exceeding max number of allowed mounts, but succeeded. %v", bzzHash6)
 	}
+	log.Debug("Maximum mount reached, additional mount failed. Correct.")
+}
 
+func (ta *testAPI) remountEncrypted(t *testing.T) {
+	log.Debug("Starting remountEncrypted test")
+	ta.remount(t, true)
+	log.Debug("Test remountEncrypted terminated")
+}
+func (ta *testAPI) remountNonEncrypted(t *testing.T) {
+	log.Debug("Starting remountNonEncrypted test")
+	ta.remount(t, false)
+	log.Debug("Test remountNonEncrypted terminated")
 }
 
-func (ta *testAPI) remount(t *testing.T) {
-	files := make(map[string]fileInfo)
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	uploadDir1, _ := ioutil.TempDir(os.TempDir(), "re-upload1")
-	bzzHash1 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir1)
-	testMountDir1, _ := ioutil.TempDir(os.TempDir(), "re-mount1")
-	swarmfs := mountDir(t, ta.api, files, bzzHash1, testMountDir1)
-	defer swarmfs.Stop()
+//test remounting same hash second time and different hash in already mounted point
+func (ta *testAPI) remount(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("remount")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	uploadDir2, _ := ioutil.TempDir(os.TempDir(), "re-upload2")
-	bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir2)
-	testMountDir2, _ := ioutil.TempDir(os.TempDir(), "re-mount2")
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "remount-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "remount-mount1")
+	dat.files = make(map[string]fileInfo)
 
-	// try mounting the same hash second time
-	os.RemoveAll(testMountDir2)
-	os.MkdirAll(testMountDir2, 0777)
-	_, err := swarmfs.Mount(bzzHash1, testMountDir2)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
 	if err != nil {
-		t.Fatalf("Error mounting hash  %v", bzzHash1)
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
+
+	// try mounting the same hash second time
+	testMountDir2, err2 := addDir(dat.testDir, "remount-mount2")
+	if err2 != nil {
+		t.Fatalf("Error creating second mount dir: %v", err2)
+	}
+	_, err2 = dat.swarmfs.Mount(dat.bzzHash, testMountDir2)
+	if err2 != nil {
+		t.Fatalf("Error mounting hash second time on different dir  %v", dat.bzzHash)
 	}
 
 	// mount a different hash in already mounted point
-	_, err = swarmfs.Mount(bzzHash2, testMountDir1)
+	dat.files["2.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	testUploadDir2, err3 := addDir(dat.testDir, "remount-upload2")
+	if err3 != nil {
+		t.Fatalf("Error creating second upload dir: %v", err3)
+	}
+	bzzHash2 := createTestFilesAndUploadToSwarm(t, ta.api, dat.files, testUploadDir2, toEncrypt)
+	_, err = swarmfs.Mount(bzzHash2, dat.testMountDir)
 	if err == nil {
 		t.Fatalf("Error mounting hash  %v", bzzHash2)
 	}
+	log.Debug("Mount on existing mount point failed. Correct.")
 
 	// mount nonexistent hash
-	_, err = swarmfs.Mount("0xfea11223344", testMountDir1)
+	failDir, err3 := addDir(dat.testDir, "remount-fail")
+	if err3 != nil {
+		t.Fatalf("Error creating remount dir: %v", bzzHash2)
+	}
+	failHash := "0xfea11223344"
+	_, err = swarmfs.Mount(failHash, failDir)
 	if err == nil {
-		t.Fatalf("Error mounting hash  %v", bzzHash2)
+		t.Fatalf("Expected this mount to fail due to non existing hash. But succeeded %v", failHash)
 	}
+	log.Debug("Nonexistent hash hasn't been mounted. Correct.")
+}
+
+func (ta *testAPI) unmountEncrypted(t *testing.T) {
+	log.Debug("Starting unmountEncrypted test")
+	ta.unmount(t, true)
+	log.Debug("Test unmountEncrypted terminated")
+}
+
+func (ta *testAPI) unmountNonEncrypted(t *testing.T) {
+	log.Debug("Starting unmountNonEncrypted test")
+	ta.unmount(t, false)
+	log.Debug("Test unmountNonEncrypted terminated")
 }
 
-func (ta *testAPI) unmount(t *testing.T) {
-	files := make(map[string]fileInfo)
-	uploadDir, _ := ioutil.TempDir(os.TempDir(), "ex-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "ex-mount")
+//mount then unmount and check that it has been unmounted
+func (ta *testAPI) unmount(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("unmount")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, uploadDir)
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "ex-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "ex-mount1")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs.Stop()
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	swarmfs.Unmount(testMountDir)
+	_, err = dat.swarmfs.Unmount(dat.testMountDir)
+	if err != nil {
+		t.Fatalf("could not unmount  %v", dat.bzzHash)
+	}
+	log.Debug("Unmounted Dir")
 
 	mi := swarmfs.Listmounts()
+	log.Debug("Going to list mounts")
 	for _, minfo := range mi {
-		if minfo.MountPoint == testMountDir {
-			t.Fatalf("mount state not cleaned up in unmount case %v", testMountDir)
+		log.Debug("Mount point in list: ", "point", minfo.MountPoint)
+		if minfo.MountPoint == dat.testMountDir {
+			t.Fatalf("mount state not cleaned up in unmount case %v", dat.testMountDir)
 		}
 	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) unmountWhenResourceBusy(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "ex-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "ex-mount")
+func (ta *testAPI) unmountWhenResourceBusyEncrypted(t *testing.T) {
+	log.Debug("Starting unmountWhenResourceBusyEncrypted test")
+	ta.unmountWhenResourceBusy(t, true)
+	log.Debug("Test unmountWhenResourceBusyEncrypted terminated")
+}
+func (ta *testAPI) unmountWhenResourceBusyNonEncrypted(t *testing.T) {
+	log.Debug("Starting unmountWhenResourceBusyNonEncrypted test")
+	ta.unmountWhenResourceBusy(t, false)
+	log.Debug("Test unmountWhenResourceBusyNonEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+//unmount while a resource is busy; should fail
+func (ta *testAPI) unmountWhenResourceBusy(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("unmountWhenResourceBusy")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs.Stop()
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "ex-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "ex-mount1")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	actualPath := filepath.Join(testMountDir, "2.txt")
-	d, err := os.OpenFile(actualPath, os.O_RDWR, os.FileMode(0700))
-	d.Write(getRandomBtes(10))
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	_, err = swarmfs.Unmount(testMountDir)
+	//create a file in the mounted directory, then try to unmount - should fail
+	actualPath := filepath.Join(dat.testMountDir, "2.txt")
+	//d, err := os.OpenFile(actualPath, os.O_RDWR, os.FileMode(0700))
+	d, err := os.Create(actualPath)
 	if err != nil {
-		t.Fatalf("could not unmount  %v", bzzHash)
+		t.Fatalf("Couldn't create new file: %v", err)
 	}
-	d.Close()
+	//we need to manually close the file before mount for this test
+	//but let's defer too in case of errors
+	defer d.Close()
+	_, err = d.Write(getRandomBytes(10))
+	if err != nil {
+		t.Fatalf("Couldn't write to file: %v", err)
+	}
+	log.Debug("Bytes written")
 
-	mi := swarmfs.Listmounts()
+	_, err = dat.swarmfs.Unmount(dat.testMountDir)
+	if err == nil {
+		t.Fatalf("Expected mount to fail due to resource busy, but it succeeded...")
+	}
+	//free resources
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Couldn't close file!  %v", dat.bzzHash)
+	}
+	log.Debug("File closed")
+
+	//now unmount after explicitly closed file
+	_, err = dat.swarmfs.Unmount(dat.testMountDir)
+	if err != nil {
+		t.Fatalf("Expected mount to succeed after freeing resource, but it failed: %v", err)
+	}
+	//check if the dir is still mounted
+	mi := dat.swarmfs.Listmounts()
+	log.Debug("Going to list mounts")
 	for _, minfo := range mi {
-		if minfo.MountPoint == testMountDir {
-			t.Fatalf("mount state not cleaned up in unmount case %v", testMountDir)
+		log.Debug("Mount point in list: ", "point", minfo.MountPoint)
+		if minfo.MountPoint == dat.testMountDir {
+			t.Fatalf("mount state not cleaned up in unmount case %v", dat.testMountDir)
 		}
 	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) seekInMultiChunkFile(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "seek-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "seek-mount")
+func (ta *testAPI) seekInMultiChunkFileEncrypted(t *testing.T) {
+	log.Debug("Starting seekInMultiChunkFileEncrypted test")
+	ta.seekInMultiChunkFile(t, true)
+	log.Debug("Test seekInMultiChunkFileEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10240)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+func (ta *testAPI) seekInMultiChunkFileNonEncrypted(t *testing.T) {
+	log.Debug("Starting seekInMultiChunkFileNonEncrypted test")
+	ta.seekInMultiChunkFile(t, false)
+	log.Debug("Test seekInMultiChunkFileNonEncrypted terminated")
+}
 
-	swarmfs := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs.Stop()
+//open a file in a mounted dir and go to a certain position
+func (ta *testAPI) seekInMultiChunkFile(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("seekInMultiChunkFile")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	// Create a new file seek the second chunk
-	actualPath := filepath.Join(testMountDir, "1.txt")
-	d, _ := os.OpenFile(actualPath, os.O_RDONLY, os.FileMode(0700))
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "seek-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "seek-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10240)}
 
-	d.Seek(5000, 0)
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
+
+	// Open the file in the mounted dir and seek the second chunk
+	actualPath := filepath.Join(dat.testMountDir, "1.txt")
+	d, err := os.OpenFile(actualPath, os.O_RDONLY, os.FileMode(0700))
+	if err != nil {
+		t.Fatalf("Couldn't open file: %v", err)
+	}
+	log.Debug("Opened file")
+	defer func() {
+		err := d.Close()
+		if err != nil {
+			t.Fatalf("Error closing file! %v", err)
+		}
+	}()
+
+	_, err = d.Seek(5000, 0)
+	if err != nil {
+		t.Fatalf("Error seeking in file: %v", err)
+	}
 
 	contents := make([]byte, 1024)
-	d.Read(contents)
-	finfo := files["1.txt"]
+	_, err = d.Read(contents)
+	if err != nil {
+		t.Fatalf("Error reading file: %v", err)
+	}
+	log.Debug("Read contents")
+	finfo := dat.files["1.txt"]
 
 	if !bytes.Equal(finfo.contents[:6024][5000:], contents) {
 		t.Fatalf("File seek contents mismatch")
 	}
-	d.Close()
+	log.Debug("subtest terminated")
+}
+
+func (ta *testAPI) createNewFileEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileEncrypted test")
+	ta.createNewFile(t, true)
+	log.Debug("Test createNewFileEncrypted terminated")
+}
+
+func (ta *testAPI) createNewFileNonEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileNonEncrypted test")
+	ta.createNewFile(t, false)
+	log.Debug("Test createNewFileNonEncrypted terminated")
 }
 
-func (ta *testAPI) createNewFile(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "create-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "create-mount")
+//create a new file in a mounted swarm directory,
+//unmount the fuse dir and then remount to see if new file is still there
+func (ta *testAPI) createNewFile(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("createNewFile")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "create-upload1")
+	dat.testMountDir = filepath.Join(dat.testDir, "create-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
 	// Create a new file in the root dir and check
-	actualPath := filepath.Join(testMountDir, "2.txt")
+	actualPath := filepath.Join(dat.testMountDir, "2.txt")
 	d, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(0665))
 	if err1 != nil {
-		t.Fatalf("Could not create file %s : %v", actualPath, err1)
+		t.Fatalf("Could not open file %s : %v", actualPath, err1)
 	}
+	defer d.Close()
+	log.Debug("Opened file")
 	contents := make([]byte, 11)
-	rand.Read(contents)
-	d.Write(contents)
-	d.Close()
+	_, err = rand.Read(contents)
+	if err != nil {
+		t.Fatalf("Could not rand read contents %v", err)
+	}
+	log.Debug("content read")
+	_, err = d.Write(contents)
+	if err != nil {
+		t.Fatalf("Couldn't write contents: %v", err)
+	}
+	log.Debug("content written")
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Couldn't close file: %v", err)
+	}
+	log.Debug("file closed")
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
+	testMountDir2, err3 := addDir(dat.testDir, "create-mount2")
+	if err3 != nil {
+		t.Fatalf("Error creating mount dir2: %v", err3)
+	}
 	// mount again and see if things are okay
-	files["2.txt"] = fileInfo{0700, 333, 444, contents}
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	dat.files["2.txt"] = fileInfo{0700, 333, 444, contents}
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted again")
+
+	checkFile(t, testMountDir2, "2.txt", contents)
+	_, err2 = dat.swarmfs.Unmount(testMountDir2)
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	log.Debug("subtest terminated")
+}
 
-	checkFile(t, testMountDir, "2.txt", contents)
+func (ta *testAPI) createNewFileInsideDirectoryEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileInsideDirectoryEncrypted test")
+	ta.createNewFileInsideDirectory(t, true)
+	log.Debug("Test createNewFileInsideDirectoryEncrypted terminated")
 }
 
-func (ta *testAPI) createNewFileInsideDirectory(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "createinsidedir-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "createinsidedir-mount")
+func (ta *testAPI) createNewFileInsideDirectoryNonEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileInsideDirectoryNonEncrypted test")
+	ta.createNewFileInsideDirectory(t, false)
+	log.Debug("Test createNewFileInsideDirectoryNonEncrypted terminated")
+}
 
-	files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+//create a new file inside a directory inside the mount
+func (ta *testAPI) createNewFileInsideDirectory(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("createNewFileInsideDirectory")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "createinsidedir-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "createinsidedir-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
 	// Create a new file inside a existing dir and check
-	dirToCreate := filepath.Join(testMountDir, "one")
+	dirToCreate := filepath.Join(dat.testMountDir, "one")
 	actualPath := filepath.Join(dirToCreate, "2.txt")
 	d, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(0665))
 	if err1 != nil {
 		t.Fatalf("Could not create file %s : %v", actualPath, err1)
 	}
+	defer d.Close()
+	log.Debug("File opened")
 	contents := make([]byte, 11)
-	rand.Read(contents)
-	d.Write(contents)
-	d.Close()
+	_, err = rand.Read(contents)
+	if err != nil {
+		t.Fatalf("Error filling random bytes into byte array %v", err)
+	}
+	log.Debug("Content read")
+	_, err = d.Write(contents)
+	if err != nil {
+		t.Fatalf("Error writing random bytes into file %v", err)
+	}
+	log.Debug("Content written")
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Error closing file %v", err)
+	}
+	log.Debug("File closed")
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
+	testMountDir2, err3 := addDir(dat.testDir, "createinsidedir-mount2")
+	if err3 != nil {
+		t.Fatalf("Error creating mount dir2: %v", err3)
+	}
 	// mount again and see if things are okay
-	files["one/2.txt"] = fileInfo{0700, 333, 444, contents}
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	dat.files["one/2.txt"] = fileInfo{0700, 333, 444, contents}
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted again")
 
-	checkFile(t, testMountDir, "one/2.txt", contents)
+	checkFile(t, testMountDir2, "one/2.txt", contents)
+	_, err = dat.swarmfs.Unmount(testMountDir2)
+	if err != nil {
+		t.Fatalf("could not unmount  %v", dat.bzzHash)
+	}
+	log.Debug("subtest terminated")
+}
+
+func (ta *testAPI) createNewFileInsideNewDirectoryEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileInsideNewDirectoryEncrypted test")
+	ta.createNewFileInsideNewDirectory(t, true)
+	log.Debug("Test createNewFileInsideNewDirectoryEncrypted terminated")
 }
 
-func (ta *testAPI) createNewFileInsideNewDirectory(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "createinsidenewdir-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "createinsidenewdir-mount")
+func (ta *testAPI) createNewFileInsideNewDirectoryNonEncrypted(t *testing.T) {
+	log.Debug("Starting createNewFileInsideNewDirectoryNonEncrypted test")
+	ta.createNewFileInsideNewDirectory(t, false)
+	log.Debug("Test createNewFileInsideNewDirectoryNonEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+//create a new directory in mount and a new file
+func (ta *testAPI) createNewFileInsideNewDirectory(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("createNewFileInsideNewDirectory")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "createinsidenewdir-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "createinsidenewdir-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
 	// Create a new file inside a existing dir and check
-	dirToCreate := filepath.Join(testMountDir, "one")
-	os.MkdirAll(dirToCreate, 0777)
+	dirToCreate, err2 := addDir(dat.testMountDir, "one")
+	if err2 != nil {
+		t.Fatalf("Error creating mount dir2: %v", err2)
+	}
 	actualPath := filepath.Join(dirToCreate, "2.txt")
 	d, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(0665))
 	if err1 != nil {
 		t.Fatalf("Could not create file %s : %v", actualPath, err1)
 	}
+	defer d.Close()
+	log.Debug("File opened")
 	contents := make([]byte, 11)
-	rand.Read(contents)
-	d.Write(contents)
-	d.Close()
+	_, err = rand.Read(contents)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to byte array: %v", err)
+	}
+	log.Debug("content read")
+	_, err = d.Write(contents)
+	if err != nil {
+		t.Fatalf("Error writing to file: %v", err)
+	}
+	log.Debug("content written")
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Error closing file: %v", err)
+	}
+	log.Debug("File closed")
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
 	// mount again and see if things are okay
-	files["one/2.txt"] = fileInfo{0700, 333, 444, contents}
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	dat.files["one/2.txt"] = fileInfo{0700, 333, 444, contents}
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, dat.testMountDir)
+	log.Debug("Directory mounted again")
+
+	checkFile(t, dat.testMountDir, "one/2.txt", contents)
+	_, err2 = dat.swarmfs.Unmount(dat.testMountDir)
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	log.Debug("subtest terminated")
+}
 
-	checkFile(t, testMountDir, "one/2.txt", contents)
+func (ta *testAPI) removeExistingFileEncrypted(t *testing.T) {
+	log.Debug("Starting removeExistingFileEncrypted test")
+	ta.removeExistingFile(t, true)
+	log.Debug("Test removeExistingFileEncrypted terminated")
 }
 
-func (ta *testAPI) removeExistingFile(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "remove-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "remove-mount")
+func (ta *testAPI) removeExistingFileNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeExistingFileNonEncrypted test")
+	ta.removeExistingFile(t, false)
+	log.Debug("Test removeExistingFileNonEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+//remove existing file in mount
+func (ta *testAPI) removeExistingFile(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeExistingFile")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "remove-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "remove-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	// Remove a file in the root dir and check
-	actualPath := filepath.Join(testMountDir, "five.txt")
-	os.Remove(actualPath)
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	// Remove a file in the root dir and check
+	actualPath := filepath.Join(dat.testMountDir, "five.txt")
+	err = os.Remove(actualPath)
+	if err != nil {
+		t.Fatalf("Error removing file! %v", err)
+	}
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
 	// mount again and see if things are okay
-	delete(files, "five.txt")
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	delete(dat.files, "five.txt")
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, dat.testMountDir)
+	_, err = os.Stat(actualPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	_, err2 = dat.swarmfs.Unmount(dat.testMountDir)
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	log.Debug("subtest terminated")
+}
+
+func (ta *testAPI) removeExistingFileInsideDirEncrypted(t *testing.T) {
+	log.Debug("Starting removeExistingFileInsideDirEncrypted test")
+	ta.removeExistingFileInsideDir(t, true)
+	log.Debug("Test removeExistingFileInsideDirEncrypted terminated")
+}
+
+func (ta *testAPI) removeExistingFileInsideDirNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeExistingFileInsideDirNonEncrypted test")
+	ta.removeExistingFileInsideDir(t, false)
+	log.Debug("Test removeExistingFileInsideDirNonEncrypted terminated")
 }
 
-func (ta *testAPI) removeExistingFileInsideDir(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "remove-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "remove-mount")
+//remove a file inside a directory inside a mount
+func (ta *testAPI) removeExistingFileInsideDir(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeExistingFileInsideDir")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["one/five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["one/six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "remove-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "remove-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["one/five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["one/six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
 	// Remove a file in the root dir and check
-	actualPath := filepath.Join(testMountDir, "one/five.txt")
-	os.Remove(actualPath)
-
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	actualPath := filepath.Join(dat.testMountDir, "one")
+	actualPath = filepath.Join(actualPath, "five.txt")
+	err = os.Remove(actualPath)
+	if err != nil {
+		t.Fatalf("Error removing file! %v", err)
+	}
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
 	// mount again and see if things are okay
-	delete(files, "one/five.txt")
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	delete(dat.files, "one/five.txt")
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, dat.testMountDir)
+	_, err = os.Stat(actualPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+
+	okPath := filepath.Join(dat.testMountDir, "one")
+	okPath = filepath.Join(okPath, "six.txt")
+	_, err = os.Stat(okPath)
+	if err != nil {
+		t.Fatal("Expected file to be present in re-mount after removal, but it is not there")
+	}
+	_, err2 = dat.swarmfs.Unmount(dat.testMountDir)
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	log.Debug("subtest terminated")
+}
+
+func (ta *testAPI) removeNewlyAddedFileEncrypted(t *testing.T) {
+	log.Debug("Starting removeNewlyAddedFileEncrypted test")
+	ta.removeNewlyAddedFile(t, true)
+	log.Debug("Test removeNewlyAddedFileEncrypted terminated")
 }
 
-func (ta *testAPI) removeNewlyAddedFile(t *testing.T) {
+func (ta *testAPI) removeNewlyAddedFileNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeNewlyAddedFileNonEncrypted test")
+	ta.removeNewlyAddedFile(t, false)
+	log.Debug("Test removeNewlyAddedFileNonEncrypted terminated")
+}
 
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "removenew-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "removenew-mount")
+//add a file in mount and then remove it; on remount file should not be there
+func (ta *testAPI) removeNewlyAddedFile(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeNewlyAddedFile")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "removenew-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "removenew-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	// Adda a new file and remove it
-	dirToCreate := filepath.Join(testMountDir, "one")
-	os.MkdirAll(dirToCreate, os.FileMode(0665))
+	// Add a a new file and remove it
+	dirToCreate := filepath.Join(dat.testMountDir, "one")
+	err = os.MkdirAll(dirToCreate, os.FileMode(0665))
+	if err != nil {
+		t.Fatalf("Error creating dir in mounted dir: %v", err)
+	}
 	actualPath := filepath.Join(dirToCreate, "2.txt")
 	d, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(0665))
 	if err1 != nil {
 		t.Fatalf("Could not create file %s : %v", actualPath, err1)
 	}
+	defer d.Close()
+	log.Debug("file opened")
 	contents := make([]byte, 11)
-	rand.Read(contents)
-	d.Write(contents)
-	d.Close()
+	_, err = rand.Read(contents)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to byte array: %v", err)
+	}
+	log.Debug("content read")
+	_, err = d.Write(contents)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to file: %v", err)
+	}
+	log.Debug("content written")
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Error closing file: %v", err)
+	}
+	log.Debug("file closed")
 
-	checkFile(t, testMountDir, "one/2.txt", contents)
+	checkFile(t, dat.testMountDir, "one/2.txt", contents)
+	log.Debug("file checked")
 
-	os.Remove(actualPath)
+	err = os.Remove(actualPath)
+	if err != nil {
+		t.Fatalf("Error removing file: %v", err)
+	}
+	log.Debug("file removed")
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
+	testMountDir2, err3 := addDir(dat.testDir, "removenew-mount2")
+	if err3 != nil {
+		t.Fatalf("Error creating mount dir2: %v", err3)
+	}
 	// mount again and see if things are okay
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted again")
 
-	if bzzHash != mi.LatestManifest {
-		t.Fatalf("same contents different hash orig(%v): new(%v)", bzzHash, mi.LatestManifest)
+	if dat.bzzHash != mi.LatestManifest {
+		t.Fatalf("same contents different hash orig(%v): new(%v)", dat.bzzHash, mi.LatestManifest)
 	}
+	_, err2 = dat.swarmfs.Unmount(testMountDir2)
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) addNewFileAndModifyContents(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "modifyfile-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "modifyfile-mount")
+func (ta *testAPI) addNewFileAndModifyContentsEncrypted(t *testing.T) {
+	log.Debug("Starting addNewFileAndModifyContentsEncrypted test")
+	ta.addNewFileAndModifyContents(t, true)
+	log.Debug("Test addNewFileAndModifyContentsEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+func (ta *testAPI) addNewFileAndModifyContentsNonEncrypted(t *testing.T) {
+	log.Debug("Starting addNewFileAndModifyContentsNonEncrypted test")
+	ta.addNewFileAndModifyContents(t, false)
+	log.Debug("Test addNewFileAndModifyContentsNonEncrypted terminated")
+}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+//add a new file and modify content; remount and check the modified file is intact
+func (ta *testAPI) addNewFileAndModifyContents(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("addNewFileAndModifyContents")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	// Create a new file in the root dir and check
-	actualPath := filepath.Join(testMountDir, "2.txt")
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "modifyfile-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "modifyfile-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
+
+	// Create a new file in the root dir
+	actualPath := filepath.Join(dat.testMountDir, "2.txt")
 	d, err1 := os.OpenFile(actualPath, os.O_RDWR|os.O_CREATE, os.FileMode(0665))
 	if err1 != nil {
 		t.Fatalf("Could not create file %s : %v", actualPath, err1)
 	}
+	defer d.Close()
+	//write some random data into the file
+	log.Debug("file opened")
 	line1 := []byte("Line 1")
-	rand.Read(line1)
-	d.Write(line1)
-	d.Close()
+	_, err = rand.Read(line1)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to byte array: %v", err)
+	}
+	log.Debug("line read")
+	_, err = d.Write(line1)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to file: %v", err)
+	}
+	log.Debug("line written")
+	err = d.Close()
+	if err != nil {
+		t.Fatalf("Error closing file: %v", err)
+	}
+	log.Debug("file closed")
 
-	mi1, err2 := swarmfs1.Unmount(testMountDir)
+	//unmount the hash on the mounted dir
+	mi1, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v", err2)
 	}
+	log.Debug("Directory unmounted")
 
-	// mount again and see if things are okay
-	files["2.txt"] = fileInfo{0700, 333, 444, line1}
-	swarmfs2 := mountDir(t, ta.api, files, mi1.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
-
-	checkFile(t, testMountDir, "2.txt", line1)
-
-	mi2, err3 := swarmfs2.Unmount(testMountDir)
+	//mount on a different dir to see if modified file is correct
+	testMountDir2, err3 := addDir(dat.testDir, "modifyfile-mount2")
 	if err3 != nil {
-		t.Fatalf("Could not unmount %v", err3)
+		t.Fatalf("Error creating mount dir2: %v", err3)
 	}
+	dat.files["2.txt"] = fileInfo{0700, 333, 444, line1}
+	_ = mountDir(t, ta.api, dat.files, mi1.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted again")
 
-	// mount again and modify
-	swarmfs3 := mountDir(t, ta.api, files, mi2.LatestManifest, testMountDir)
-	defer swarmfs3.Stop()
+	checkFile(t, testMountDir2, "2.txt", line1)
+	log.Debug("file checked")
 
-	fd, err4 := os.OpenFile(actualPath, os.O_RDWR|os.O_APPEND, os.FileMode(0665))
+	//unmount second dir
+	mi2, err4 := dat.swarmfs.Unmount(testMountDir2)
 	if err4 != nil {
-		t.Fatalf("Could not create file %s : %v", actualPath, err4)
+		t.Fatalf("Could not unmount %v", err4)
 	}
-	line2 := []byte("Line 2")
-	rand.Read(line2)
-	fd.Seek(int64(len(line1)), 0)
-	fd.Write(line2)
-	fd.Close()
+	log.Debug("Directory unmounted again")
+
+	//mount again on original dir and modify the file
+	//let's clean up the mounted dir first: remove...
+	err = os.RemoveAll(dat.testMountDir)
+	if err != nil {
+		t.Fatalf("Error cleaning up mount dir: %v", err)
+	}
+	//...and re-create
+	err = os.MkdirAll(dat.testMountDir, 0777)
+	if err != nil {
+		t.Fatalf("Error re-creating mount dir: %v", err)
+	}
+	//now remount
+	_ = mountDir(t, ta.api, dat.files, mi2.LatestManifest, dat.testMountDir)
+	log.Debug("Directory mounted yet again")
 
-	mi3, err5 := swarmfs3.Unmount(testMountDir)
+	//open the file....
+	fd, err5 := os.OpenFile(actualPath, os.O_RDWR|os.O_APPEND, os.FileMode(0665))
 	if err5 != nil {
-		t.Fatalf("Could not unmount %v", err5)
+		t.Fatalf("Could not create file %s : %v", actualPath, err5)
+	}
+	defer fd.Close()
+	log.Debug("file opened")
+	//...and modify something
+	line2 := []byte("Line 2")
+	_, err = rand.Read(line2)
+	if err != nil {
+		t.Fatalf("Error modifying random bytes to byte array: %v", err)
+	}
+	log.Debug("line read")
+	_, err = fd.Seek(int64(len(line1)), 0)
+	if err != nil {
+		t.Fatalf("Error seeking position for modification: %v", err)
 	}
+	_, err = fd.Write(line2)
+	if err != nil {
+		t.Fatalf("Error modifying file: %v", err)
+	}
+	log.Debug("line written")
+	err = fd.Close()
+	if err != nil {
+		t.Fatalf("Error closing modified file; %v", err)
+	}
+	log.Debug("file closed")
 
-	// mount again and see if things are okay
+	//unmount the modified directory
+	mi3, err6 := dat.swarmfs.Unmount(dat.testMountDir)
+	if err6 != nil {
+		t.Fatalf("Could not unmount %v", err6)
+	}
+	log.Debug("Directory unmounted yet again")
+
+	//now remount on a different dir and check that the modified file is ok
+	testMountDir4, err7 := addDir(dat.testDir, "modifyfile-mount4")
+	if err7 != nil {
+		t.Fatalf("Could not unmount %v", err7)
+	}
 	b := [][]byte{line1, line2}
 	line1and2 := bytes.Join(b, []byte(""))
-	files["2.txt"] = fileInfo{0700, 333, 444, line1and2}
-	swarmfs4 := mountDir(t, ta.api, files, mi3.LatestManifest, testMountDir)
-	defer swarmfs4.Stop()
+	dat.files["2.txt"] = fileInfo{0700, 333, 444, line1and2}
+	_ = mountDir(t, ta.api, dat.files, mi3.LatestManifest, testMountDir4)
+	log.Debug("Directory mounted final time")
 
-	checkFile(t, testMountDir, "2.txt", line1and2)
+	checkFile(t, testMountDir4, "2.txt", line1and2)
+	_, err = dat.swarmfs.Unmount(testMountDir4)
+	if err != nil {
+		t.Fatalf("Could not unmount %v", err)
+	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) removeEmptyDir(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-mount")
+func (ta *testAPI) removeEmptyDirEncrypted(t *testing.T) {
+	log.Debug("Starting removeEmptyDirEncrypted test")
+	ta.removeEmptyDir(t, true)
+	log.Debug("Test removeEmptyDirEncrypted terminated")
+}
 
-	files["1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+func (ta *testAPI) removeEmptyDirNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeEmptyDirNonEncrypted test")
+	ta.removeEmptyDir(t, false)
+	log.Debug("Test removeEmptyDirNonEncrypted terminated")
+}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+//remove an empty dir inside mount
+func (ta *testAPI) removeEmptyDir(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeEmptyDir")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	os.MkdirAll(filepath.Join(testMountDir, "newdir"), 0777)
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "rmdir-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "rmdir-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	mi, err3 := swarmfs1.Unmount(testMountDir)
-	if err3 != nil {
-		t.Fatalf("Could not unmount %v", err3)
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
 	}
-	if bzzHash != mi.LatestManifest {
-		t.Fatalf("same contents different hash orig(%v): new(%v)", bzzHash, mi.LatestManifest)
+	defer dat.swarmfs.Stop()
+
+	_, err2 := addDir(dat.testMountDir, "newdir")
+	if err2 != nil {
+		t.Fatalf("Could not unmount %v", err2)
+	}
+	mi, err := dat.swarmfs.Unmount(dat.testMountDir)
+	if err != nil {
+		t.Fatalf("Could not unmount %v", err)
+	}
+	log.Debug("Directory unmounted")
+	//by just adding an empty dir, the hash doesn't change; test this
+	if dat.bzzHash != mi.LatestManifest {
+		t.Fatalf("same contents different hash orig(%v): new(%v)", dat.bzzHash, mi.LatestManifest)
 	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) removeDirWhichHasFiles(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmdir-mount")
+func (ta *testAPI) removeDirWhichHasFilesEncrypted(t *testing.T) {
+	log.Debug("Starting removeDirWhichHasFilesEncrypted test")
+	ta.removeDirWhichHasFiles(t, true)
+	log.Debug("Test removeDirWhichHasFilesEncrypted terminated")
+}
+func (ta *testAPI) removeDirWhichHasFilesNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeDirWhichHasFilesNonEncrypted test")
+	ta.removeDirWhichHasFiles(t, false)
+	log.Debug("Test removeDirWhichHasFilesNonEncrypted terminated")
+}
 
-	files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/five.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/six.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+//remove a directory with a file; check on remount file isn't there
+func (ta *testAPI) removeDirWhichHasFiles(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeDirWhichHasFiles")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "rmdir-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "rmdir-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/five.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/six.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
 
-	dirPath := filepath.Join(testMountDir, "two")
-	os.RemoveAll(dirPath)
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	//delete a directory inside the mounted dir with all its files
+	dirPath := filepath.Join(dat.testMountDir, "two")
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("Error removing directory in mounted dir: %v", err)
+	}
+
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v ", err2)
 	}
+	log.Debug("Directory unmounted")
 
-	// mount again and see if things are okay
-	delete(files, "two/five.txt")
-	delete(files, "two/six.txt")
+	//we deleted files in the OS, so let's delete them also in the files map
+	delete(dat.files, "two/five.txt")
+	delete(dat.files, "two/six.txt")
 
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	// mount again and see if deleted files have been deleted indeed
+	testMountDir2, err3 := addDir(dat.testDir, "remount-mount2")
+	if err3 != nil {
+		t.Fatalf("Could not unmount %v", err3)
+	}
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted")
+	actualPath := filepath.Join(dirPath, "five.txt")
+	_, err = os.Stat(actualPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	_, err = os.Stat(dirPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	_, err = dat.swarmfs.Unmount(testMountDir2)
+	if err != nil {
+		t.Fatalf("Could not unmount %v", err)
+	}
+	log.Debug("subtest terminated")
 }
 
-func (ta *testAPI) removeDirWhichHasSubDirs(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "rmsubdir-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "rmsubdir-mount")
-
-	files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/three/2.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/three/3.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/four/5.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/four/6.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
-	files["two/four/six/7.txt"] = fileInfo{0700, 333, 444, getRandomBtes(10)}
+func (ta *testAPI) removeDirWhichHasSubDirsEncrypted(t *testing.T) {
+	log.Debug("Starting removeDirWhichHasSubDirsEncrypted test")
+	ta.removeDirWhichHasSubDirs(t, true)
+	log.Debug("Test removeDirWhichHasSubDirsEncrypted terminated")
+}
 
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+func (ta *testAPI) removeDirWhichHasSubDirsNonEncrypted(t *testing.T) {
+	log.Debug("Starting removeDirWhichHasSubDirsNonEncrypted test")
+	ta.removeDirWhichHasSubDirs(t, false)
+	log.Debug("Test removeDirWhichHasSubDirsNonEncrypted terminated")
+}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+//remove a directory with subdirectories inside mount; on remount check they are not there
+func (ta *testAPI) removeDirWhichHasSubDirs(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("removeDirWhichHasSubDirs")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
+
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "rmsubdir-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "rmsubdir-mount")
+	dat.files = make(map[string]fileInfo)
+	dat.files["one/1.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/three/2.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/three/3.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/four/5.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/four/6.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+	dat.files["two/four/six/7.txt"] = fileInfo{0700, 333, 444, getRandomBytes(10)}
+
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
 
-	dirPath := filepath.Join(testMountDir, "two")
-	os.RemoveAll(dirPath)
+	dirPath := filepath.Join(dat.testMountDir, "two")
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("Error removing directory in mounted dir: %v", err)
+	}
 
-	mi, err2 := swarmfs1.Unmount(testMountDir)
+	//delete a directory inside the mounted dir with all its files
+	mi, err2 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err2 != nil {
 		t.Fatalf("Could not unmount %v ", err2)
 	}
+	log.Debug("Directory unmounted")
+
+	//we deleted files in the OS, so let's delete them also in the files map
+	delete(dat.files, "two/three/2.txt")
+	delete(dat.files, "two/three/3.txt")
+	delete(dat.files, "two/four/5.txt")
+	delete(dat.files, "two/four/6.txt")
+	delete(dat.files, "two/four/six/7.txt")
 
 	// mount again and see if things are okay
-	delete(files, "two/three/2.txt")
-	delete(files, "two/three/3.txt")
-	delete(files, "two/four/5.txt")
-	delete(files, "two/four/6.txt")
-	delete(files, "two/four/six/7.txt")
+	testMountDir2, err3 := addDir(dat.testDir, "remount-mount2")
+	if err3 != nil {
+		t.Fatalf("Could not unmount %v", err3)
+	}
+	_ = mountDir(t, ta.api, dat.files, mi.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted again")
+	actualPath := filepath.Join(dirPath, "three")
+	actualPath = filepath.Join(actualPath, "2.txt")
+	_, err = os.Stat(actualPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	actualPath = filepath.Join(dirPath, "four")
+	_, err = os.Stat(actualPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	_, err = os.Stat(dirPath)
+	if err == nil {
+		t.Fatal("Expected file to not be present in re-mount after removal, but it is there")
+	}
+	_, err = dat.swarmfs.Unmount(testMountDir2)
+	if err != nil {
+		t.Fatalf("Could not unmount %v", err)
+	}
+	log.Debug("subtest terminated")
+}
 
-	swarmfs2 := mountDir(t, ta.api, files, mi.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+func (ta *testAPI) appendFileContentsToEndEncrypted(t *testing.T) {
+	log.Debug("Starting appendFileContentsToEndEncrypted test")
+	ta.appendFileContentsToEnd(t, true)
+	log.Debug("Test appendFileContentsToEndEncrypted terminated")
 }
 
-func (ta *testAPI) appendFileContentsToEnd(t *testing.T) {
-	files := make(map[string]fileInfo)
-	testUploadDir, _ := ioutil.TempDir(os.TempDir(), "appendlargefile-upload")
-	testMountDir, _ := ioutil.TempDir(os.TempDir(), "appendlargefile-mount")
+func (ta *testAPI) appendFileContentsToEndNonEncrypted(t *testing.T) {
+	log.Debug("Starting appendFileContentsToEndNonEncrypted test")
+	ta.appendFileContentsToEnd(t, false)
+	log.Debug("Test appendFileContentsToEndNonEncrypted terminated")
+}
+
+//append contents to the end of a file; remount and check it's intact
+func (ta *testAPI) appendFileContentsToEnd(t *testing.T, toEncrypt bool) {
+	dat, err := ta.initSubtest("appendFileContentsToEnd")
+	if err != nil {
+		t.Fatalf("Couldn't initialize subtest dirs: %v", err)
+	}
+	defer os.RemoveAll(dat.testDir)
+
+	dat.toEncrypt = toEncrypt
+	dat.testUploadDir = filepath.Join(dat.testDir, "appendlargefile-upload")
+	dat.testMountDir = filepath.Join(dat.testDir, "appendlargefile-mount")
+	dat.files = make(map[string]fileInfo)
 
 	line1 := make([]byte, 10)
-	rand.Read(line1)
-	files["1.txt"] = fileInfo{0700, 333, 444, line1}
-	bzzHash := createTestFilesAndUploadToSwarm(t, ta.api, files, testUploadDir)
+	_, err = rand.Read(line1)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to byte array: %v", err)
+	}
 
-	swarmfs1 := mountDir(t, ta.api, files, bzzHash, testMountDir)
-	defer swarmfs1.Stop()
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, line1}
 
-	actualPath := filepath.Join(testMountDir, "1.txt")
+	dat, err = ta.uploadAndMount(dat, t)
+	if err != nil {
+		t.Fatalf("Error during upload of files to swarm / mount of swarm dir: %v", err)
+	}
+	defer dat.swarmfs.Stop()
+
+	actualPath := filepath.Join(dat.testMountDir, "1.txt")
 	fd, err4 := os.OpenFile(actualPath, os.O_RDWR|os.O_APPEND, os.FileMode(0665))
 	if err4 != nil {
 		t.Fatalf("Could not create file %s : %v", actualPath, err4)
 	}
+	defer fd.Close()
+	log.Debug("file opened")
 	line2 := make([]byte, 5)
-	rand.Read(line2)
-	fd.Seek(int64(len(line1)), 0)
-	fd.Write(line2)
-	fd.Close()
+	_, err = rand.Read(line2)
+	if err != nil {
+		t.Fatalf("Error writing random bytes to byte array: %v", err)
+	}
+	log.Debug("line read")
+	_, err = fd.Seek(int64(len(line1)), 0)
+	if err != nil {
+		t.Fatalf("Error searching for position to append: %v", err)
+	}
+	_, err = fd.Write(line2)
+	if err != nil {
+		t.Fatalf("Error appending: %v", err)
+	}
+	log.Debug("line written")
+	err = fd.Close()
+	if err != nil {
+		t.Fatalf("Error closing file: %v", err)
+	}
+	log.Debug("file closed")
 
-	mi1, err5 := swarmfs1.Unmount(testMountDir)
+	mi1, err5 := dat.swarmfs.Unmount(dat.testMountDir)
 	if err5 != nil {
 		t.Fatalf("Could not unmount %v ", err5)
 	}
+	log.Debug("Directory unmounted")
 
-	// mount again and see if things are okay
+	// mount again and see if appended file is correct
 	b := [][]byte{line1, line2}
 	line1and2 := bytes.Join(b, []byte(""))
-	files["1.txt"] = fileInfo{0700, 333, 444, line1and2}
-	swarmfs2 := mountDir(t, ta.api, files, mi1.LatestManifest, testMountDir)
-	defer swarmfs2.Stop()
+	dat.files["1.txt"] = fileInfo{0700, 333, 444, line1and2}
+	testMountDir2, err6 := addDir(dat.testDir, "remount-mount2")
+	if err6 != nil {
+		t.Fatalf("Could not unmount %v", err6)
+	}
+	_ = mountDir(t, ta.api, dat.files, mi1.LatestManifest, testMountDir2)
+	log.Debug("Directory mounted")
+
+	checkFile(t, testMountDir2, "1.txt", line1and2)
 
-	checkFile(t, testMountDir, "1.txt", line1and2)
+	_, err = dat.swarmfs.Unmount(testMountDir2)
+	if err != nil {
+		t.Fatalf("Could not unmount %v", err)
+	}
+	log.Debug("subtest terminated")
 }
 
+//run all the tests
 func TestFUSE(t *testing.T) {
+	//create a data directory for swarm
 	datadir, err := ioutil.TempDir("", "fuse")
 	if err != nil {
 		t.Fatalf("unable to create temp dir: %v", err)
 	}
-	os.RemoveAll(datadir)
+	defer os.RemoveAll(datadir)
 
-	dpa, err := storage.NewLocalDPA(datadir)
+	fileStore, err := storage.NewLocalFileStore(datadir, make([]byte, 32))
 	if err != nil {
 		t.Fatal(err)
 	}
-	ta := &testAPI{api: api.NewApi(dpa, nil)}
-	dpa.Start()
-	defer dpa.Stop()
-
-	t.Run("mountListAndUmount", ta.mountListAndUnmount)
-	t.Run("maxMounts", ta.maxMounts)
-	t.Run("remount", ta.remount)
-	t.Run("unmount", ta.unmount)
-	t.Run("unmountWhenResourceBusy", ta.unmountWhenResourceBusy)
-	t.Run("seekInMultiChunkFile", ta.seekInMultiChunkFile)
-	t.Run("createNewFile", ta.createNewFile)
-	t.Run("createNewFileInsideDirectory", ta.createNewFileInsideDirectory)
-	t.Run("createNewFileInsideNewDirectory", ta.createNewFileInsideNewDirectory)
-	t.Run("removeExistingFile", ta.removeExistingFile)
-	t.Run("removeExistingFileInsideDir", ta.removeExistingFileInsideDir)
-	t.Run("removeNewlyAddedFile", ta.removeNewlyAddedFile)
-	t.Run("addNewFileAndModifyContents", ta.addNewFileAndModifyContents)
-	t.Run("removeEmptyDir", ta.removeEmptyDir)
-	t.Run("removeDirWhichHasFiles", ta.removeDirWhichHasFiles)
-	t.Run("removeDirWhichHasSubDirs", ta.removeDirWhichHasSubDirs)
-	t.Run("appendFileContentsToEnd", ta.appendFileContentsToEnd)
+	ta := &testAPI{api: api.NewAPI(fileStore, nil, nil)}
+
+	//run a short suite of tests
+	//approx time: 28s
+	t.Run("mountListAndUnmountEncrypted", ta.mountListAndUnmountEncrypted)
+	t.Run("remountEncrypted", ta.remountEncrypted)
+	t.Run("unmountWhenResourceBusyNonEncrypted", ta.unmountWhenResourceBusyNonEncrypted)
+	t.Run("removeExistingFileEncrypted", ta.removeExistingFileEncrypted)
+	t.Run("addNewFileAndModifyContentsNonEncrypted", ta.addNewFileAndModifyContentsNonEncrypted)
+	t.Run("removeDirWhichHasFilesNonEncrypted", ta.removeDirWhichHasFilesNonEncrypted)
+	t.Run("appendFileContentsToEndEncrypted", ta.appendFileContentsToEndEncrypted)
+
+	//provide longrunning flag to execute all tests
+	//approx time with longrunning: 140s
+	if *longrunning {
+		t.Run("mountListAndUnmountNonEncrypted", ta.mountListAndUnmountNonEncrypted)
+		t.Run("maxMountsEncrypted", ta.maxMountsEncrypted)
+		t.Run("maxMountsNonEncrypted", ta.maxMountsNonEncrypted)
+		t.Run("remountNonEncrypted", ta.remountNonEncrypted)
+		t.Run("unmountEncrypted", ta.unmountEncrypted)
+		t.Run("unmountNonEncrypted", ta.unmountNonEncrypted)
+		t.Run("unmountWhenResourceBusyEncrypted", ta.unmountWhenResourceBusyEncrypted)
+		t.Run("unmountWhenResourceBusyNonEncrypted", ta.unmountWhenResourceBusyNonEncrypted)
+		t.Run("seekInMultiChunkFileEncrypted", ta.seekInMultiChunkFileEncrypted)
+		t.Run("seekInMultiChunkFileNonEncrypted", ta.seekInMultiChunkFileNonEncrypted)
+		t.Run("createNewFileEncrypted", ta.createNewFileEncrypted)
+		t.Run("createNewFileNonEncrypted", ta.createNewFileNonEncrypted)
+		t.Run("createNewFileInsideDirectoryEncrypted", ta.createNewFileInsideDirectoryEncrypted)
+		t.Run("createNewFileInsideDirectoryNonEncrypted", ta.createNewFileInsideDirectoryNonEncrypted)
+		t.Run("createNewFileInsideNewDirectoryEncrypted", ta.createNewFileInsideNewDirectoryEncrypted)
+		t.Run("createNewFileInsideNewDirectoryNonEncrypted", ta.createNewFileInsideNewDirectoryNonEncrypted)
+		t.Run("removeExistingFileNonEncrypted", ta.removeExistingFileNonEncrypted)
+		t.Run("removeExistingFileInsideDirEncrypted", ta.removeExistingFileInsideDirEncrypted)
+		t.Run("removeExistingFileInsideDirNonEncrypted", ta.removeExistingFileInsideDirNonEncrypted)
+		t.Run("removeNewlyAddedFileEncrypted", ta.removeNewlyAddedFileEncrypted)
+		t.Run("removeNewlyAddedFileNonEncrypted", ta.removeNewlyAddedFileNonEncrypted)
+		t.Run("addNewFileAndModifyContentsEncrypted", ta.addNewFileAndModifyContentsEncrypted)
+		t.Run("removeEmptyDirEncrypted", ta.removeEmptyDirEncrypted)
+		t.Run("removeEmptyDirNonEncrypted", ta.removeEmptyDirNonEncrypted)
+		t.Run("removeDirWhichHasFilesEncrypted", ta.removeDirWhichHasFilesEncrypted)
+		t.Run("removeDirWhichHasSubDirsEncrypted", ta.removeDirWhichHasSubDirsEncrypted)
+		t.Run("removeDirWhichHasSubDirsNonEncrypted", ta.removeDirWhichHasSubDirsNonEncrypted)
+		t.Run("appendFileContentsToEndNonEncrypted", ta.appendFileContentsToEndNonEncrypted)
+	}
 }
diff --git a/swarm/fuse/swarmfs_unix.go b/swarm/fuse/swarmfs_unix.go
index 75742845a..74dd84a90 100644
--- a/swarm/fuse/swarmfs_unix.go
+++ b/swarm/fuse/swarmfs_unix.go
@@ -30,15 +30,16 @@ import (
 	"bazil.org/fuse"
 	"bazil.org/fuse/fs"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/swarm/api"
+	"github.com/ethereum/go-ethereum/swarm/log"
 )
 
 var (
-	errEmptyMountPoint = errors.New("need non-empty mount point")
-	errMaxMountCount   = errors.New("max FUSE mount count reached")
-	errMountTimeout    = errors.New("mount timeout")
-	errAlreadyMounted  = errors.New("mount point is already serving")
+	errEmptyMountPoint      = errors.New("need non-empty mount point")
+	errNoRelativeMountPoint = errors.New("invalid path for mount point (need absolute path)")
+	errMaxMountCount        = errors.New("max FUSE mount count reached")
+	errMountTimeout         = errors.New("mount timeout")
+	errAlreadyMounted       = errors.New("mount point is already serving")
 )
 
 func isFUSEUnsupportedError(err error) bool {
@@ -48,18 +49,20 @@ func isFUSEUnsupportedError(err error) bool {
 	return err == fuse.ErrOSXFUSENotFound
 }
 
-// information about every active mount
+// MountInfo contains information about every active mount
 type MountInfo struct {
 	MountPoint     string
 	StartManifest  string
 	LatestManifest string
 	rootDir        *SwarmDir
 	fuseConnection *fuse.Conn
-	swarmApi       *api.Api
+	swarmApi       *api.API
 	lock           *sync.RWMutex
+	serveClose     chan struct{}
 }
 
-func NewMountInfo(mhash, mpoint string, sapi *api.Api) *MountInfo {
+func NewMountInfo(mhash, mpoint string, sapi *api.API) *MountInfo {
+	log.Debug("swarmfs NewMountInfo", "hash", mhash, "mount point", mpoint)
 	newMountInfo := &MountInfo{
 		MountPoint:     mpoint,
 		StartManifest:  mhash,
@@ -68,50 +71,57 @@ func NewMountInfo(mhash, mpoint string, sapi *api.Api) *MountInfo {
 		fuseConnection: nil,
 		swarmApi:       sapi,
 		lock:           &sync.RWMutex{},
+		serveClose:     make(chan struct{}),
 	}
 	return newMountInfo
 }
 
-func (self *SwarmFS) Mount(mhash, mountpoint string) (*MountInfo, error) {
-
+func (swarmfs *SwarmFS) Mount(mhash, mountpoint string) (*MountInfo, error) {
+	log.Info("swarmfs", "mounting hash", mhash, "mount point", mountpoint)
 	if mountpoint == "" {
 		return nil, errEmptyMountPoint
 	}
+	if !strings.HasPrefix(mountpoint, "/") {
+		return nil, errNoRelativeMountPoint
+	}
 	cleanedMountPoint, err := filepath.Abs(filepath.Clean(mountpoint))
 	if err != nil {
 		return nil, err
 	}
+	log.Trace("swarmfs mount", "cleanedMountPoint", cleanedMountPoint)
 
-	self.swarmFsLock.Lock()
-	defer self.swarmFsLock.Unlock()
+	swarmfs.swarmFsLock.Lock()
+	defer swarmfs.swarmFsLock.Unlock()
 
-	noOfActiveMounts := len(self.activeMounts)
+	noOfActiveMounts := len(swarmfs.activeMounts)
+	log.Debug("swarmfs mount", "# active mounts", noOfActiveMounts)
 	if noOfActiveMounts >= maxFuseMounts {
 		return nil, errMaxMountCount
 	}
 
-	if _, ok := self.activeMounts[cleanedMountPoint]; ok {
+	if _, ok := swarmfs.activeMounts[cleanedMountPoint]; ok {
 		return nil, errAlreadyMounted
 	}
 
-	log.Info(fmt.Sprintf("Attempting to mount %s ", cleanedMountPoint))
-	_, manifestEntryMap, err := self.swarmApi.BuildDirectoryTree(mhash, true)
+	log.Trace("swarmfs mount: getting manifest tree")
+	_, manifestEntryMap, err := swarmfs.swarmApi.BuildDirectoryTree(mhash, true)
 	if err != nil {
 		return nil, err
 	}
 
-	mi := NewMountInfo(mhash, cleanedMountPoint, self.swarmApi)
+	log.Trace("swarmfs mount: building mount info")
+	mi := NewMountInfo(mhash, cleanedMountPoint, swarmfs.swarmApi)
 
 	dirTree := map[string]*SwarmDir{}
 	rootDir := NewSwarmDir("/", mi)
-	dirTree["/"] = rootDir
+	log.Trace("swarmfs mount", "rootDir", rootDir)
 	mi.rootDir = rootDir
 
+	log.Trace("swarmfs mount: traversing manifest map")
 	for suffix, entry := range manifestEntryMap {
-		key := common.Hex2Bytes(entry.Hash)
+		addr := common.Hex2Bytes(entry.Hash)
 		fullpath := "/" + suffix
 		basepath := filepath.Dir(fullpath)
-
 		parentDir := rootDir
 		dirUntilNow := ""
 		paths := strings.Split(basepath, "/")
@@ -128,105 +138,143 @@ func (self *SwarmFS) Mount(mhash, mountpoint string) (*MountInfo, error) {
 				} else {
 					parentDir = dirTree[dirUntilNow]
 				}
-
 			}
 		}
 		thisFile := NewSwarmFile(basepath, filepath.Base(fullpath), mi)
-		thisFile.key = key
+		thisFile.addr = addr
 
 		parentDir.files = append(parentDir.files, thisFile)
 	}
 
 	fconn, err := fuse.Mount(cleanedMountPoint, fuse.FSName("swarmfs"), fuse.VolumeName(mhash))
 	if isFUSEUnsupportedError(err) {
-		log.Warn("Fuse not installed", "mountpoint", cleanedMountPoint, "err", err)
+		log.Error("swarmfs error - FUSE not installed", "mountpoint", cleanedMountPoint, "err", err)
 		return nil, err
 	} else if err != nil {
 		fuse.Unmount(cleanedMountPoint)
-		log.Warn("Error mounting swarm manifest", "mountpoint", cleanedMountPoint, "err", err)
+		log.Error("swarmfs error mounting swarm manifest", "mountpoint", cleanedMountPoint, "err", err)
 		return nil, err
 	}
 	mi.fuseConnection = fconn
 
 	serverr := make(chan error, 1)
 	go func() {
-		log.Info(fmt.Sprintf("Serving %s at %s", mhash, cleanedMountPoint))
+		log.Info("swarmfs", "serving hash", mhash, "at", cleanedMountPoint)
 		filesys := &SwarmRoot{root: rootDir}
+		//start serving the actual file system; see note below
 		if err := fs.Serve(fconn, filesys); err != nil {
-			log.Warn(fmt.Sprintf("Could not Serve SwarmFileSystem error: %v", err))
+			log.Warn("swarmfs could not serve the requested hash", "error", err)
 			serverr <- err
 		}
-
+		mi.serveClose <- struct{}{}
 	}()
 
+	/*
+	   IMPORTANT NOTE: the fs.Serve function is blocking;
+	   Serve builds up the actual fuse file system by calling the
+	   Attr functions on each SwarmFile, creating the file inodes;
+	   specifically calling the swarm's LazySectionReader.Size() to set the file size.
+
+	   This can take some time, and it appears that if we access the fuse file system
+	   too early, we can bring the tests to deadlock. The assumption so far is that
+	   at this point, the fuse driver didn't finish to initialize the file system.
+
+	   Accessing files too early not only deadlocks the tests, but locks the access
+	   of the fuse file completely, resulting in blocked resources at OS system level.
+	   Even a simple `ls /tmp/testDir/testMountDir` could deadlock in a shell.
+
+	   Workaround so far is to wait some time to give the OS enough time to initialize
+	   the fuse file system. During tests, this seemed to address the issue.
+
+	   HOWEVER IT SHOULD BE NOTED THAT THIS MAY ONLY BE AN EFFECT,
+	   AND THE DEADLOCK CAUSED BY SOMETHING ELSE BLOCKING ACCESS DUE TO SOME RACE CONDITION
+	   (caused in the bazil.org library and/or the SwarmRoot, SwarmDir and SwarmFile implementations)
+	*/
+	time.Sleep(2 * time.Second)
+
+	timer := time.NewTimer(mountTimeout)
+	defer timer.Stop()
 	// Check if the mount process has an error to report.
 	select {
-	case <-time.After(mountTimeout):
-		fuse.Unmount(cleanedMountPoint)
+	case <-timer.C:
+		log.Warn("swarmfs timed out mounting over FUSE", "mountpoint", cleanedMountPoint, "err", err)
+		err := fuse.Unmount(cleanedMountPoint)
+		if err != nil {
+			return nil, err
+		}
 		return nil, errMountTimeout
-
 	case err := <-serverr:
-		fuse.Unmount(cleanedMountPoint)
-		log.Warn("Error serving swarm FUSE FS", "mountpoint", cleanedMountPoint, "err", err)
+		log.Warn("swarmfs error serving over FUSE", "mountpoint", cleanedMountPoint, "err", err)
+		err = fuse.Unmount(cleanedMountPoint)
 		return nil, err
 
 	case <-fconn.Ready:
-		log.Info("Now serving swarm FUSE FS", "manifest", mhash, "mountpoint", cleanedMountPoint)
+		//this signals that the actual mount point from the fuse.Mount call is ready;
+		//it does not signal though that the file system from fs.Serve is actually fully built up
+		if err := fconn.MountError; err != nil {
+			log.Error("Mounting error from fuse driver: ", "err", err)
+			return nil, err
+		}
+		log.Info("swarmfs now served over FUSE", "manifest", mhash, "mountpoint", cleanedMountPoint)
 	}
 
-	self.activeMounts[cleanedMountPoint] = mi
+	timer.Stop()
+	swarmfs.activeMounts[cleanedMountPoint] = mi
 	return mi, nil
 }
 
-func (self *SwarmFS) Unmount(mountpoint string) (*MountInfo, error) {
-
-	self.swarmFsLock.Lock()
-	defer self.swarmFsLock.Unlock()
+func (swarmfs *SwarmFS) Unmount(mountpoint string) (*MountInfo, error) {
+	swarmfs.swarmFsLock.Lock()
+	defer swarmfs.swarmFsLock.Unlock()
 
 	cleanedMountPoint, err := filepath.Abs(filepath.Clean(mountpoint))
 	if err != nil {
 		return nil, err
 	}
 
-	mountInfo := self.activeMounts[cleanedMountPoint]
+	mountInfo := swarmfs.activeMounts[cleanedMountPoint]
 
 	if mountInfo == nil || mountInfo.MountPoint != cleanedMountPoint {
-		return nil, fmt.Errorf("%s is not mounted", cleanedMountPoint)
+		return nil, fmt.Errorf("swarmfs %s is not mounted", cleanedMountPoint)
 	}
 	err = fuse.Unmount(cleanedMountPoint)
 	if err != nil {
 		err1 := externalUnmount(cleanedMountPoint)
 		if err1 != nil {
-			errStr := fmt.Sprintf("UnMount error: %v", err)
+			errStr := fmt.Sprintf("swarmfs unmount error: %v", err)
 			log.Warn(errStr)
 			return nil, err1
 		}
 	}
 
-	mountInfo.fuseConnection.Close()
-	delete(self.activeMounts, cleanedMountPoint)
+	err = mountInfo.fuseConnection.Close()
+	if err != nil {
+		return nil, err
+	}
+	delete(swarmfs.activeMounts, cleanedMountPoint)
 
-	succString := fmt.Sprintf("UnMounting %v succeeded", cleanedMountPoint)
+	<-mountInfo.serveClose
+
+	succString := fmt.Sprintf("swarmfs unmounting %v succeeded", cleanedMountPoint)
 	log.Info(succString)
 
 	return mountInfo, nil
 }
 
-func (self *SwarmFS) Listmounts() []*MountInfo {
-	self.swarmFsLock.RLock()
-	defer self.swarmFsLock.RUnlock()
-
-	rows := make([]*MountInfo, 0, len(self.activeMounts))
-	for _, mi := range self.activeMounts {
+func (swarmfs *SwarmFS) Listmounts() []*MountInfo {
+	swarmfs.swarmFsLock.RLock()
+	defer swarmfs.swarmFsLock.RUnlock()
+	rows := make([]*MountInfo, 0, len(swarmfs.activeMounts))
+	for _, mi := range swarmfs.activeMounts {
 		rows = append(rows, mi)
 	}
 	return rows
 }
 
-func (self *SwarmFS) Stop() bool {
-	for mp := range self.activeMounts {
-		mountInfo := self.activeMounts[mp]
-		self.Unmount(mountInfo.MountPoint)
+func (swarmfs *SwarmFS) Stop() bool {
+	for mp := range swarmfs.activeMounts {
+		mountInfo := swarmfs.activeMounts[mp]
+		swarmfs.Unmount(mountInfo.MountPoint)
 	}
 	return true
 }
diff --git a/swarm/fuse/swarmfs_util.go b/swarm/fuse/swarmfs_util.go
index 169b67487..9bbb0f6ac 100644
--- a/swarm/fuse/swarmfs_util.go
+++ b/swarm/fuse/swarmfs_util.go
@@ -24,7 +24,7 @@ import (
 	"os/exec"
 	"runtime"
 
-	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/swarm/log"
 )
 
 func externalUnmount(mountPoint string) error {
@@ -38,11 +38,11 @@ func externalUnmount(mountPoint string) error {
 	// Try FUSE-specific commands if umount didn't work.
 	switch runtime.GOOS {
 	case "darwin":
-		return exec.CommandContext(ctx, "diskutil", "umount", "force", mountPoint).Run()
+		return exec.CommandContext(ctx, "diskutil", "umount", mountPoint).Run()
 	case "linux":
 		return exec.CommandContext(ctx, "fusermount", "-u", mountPoint).Run()
 	default:
-		return fmt.Errorf("unmount: unimplemented")
+		return fmt.Errorf("swarmfs unmount: unimplemented")
 	}
 }
 
@@ -54,14 +54,14 @@ func addFileToSwarm(sf *SwarmFile, content []byte, size int) error {
 
 	sf.lock.Lock()
 	defer sf.lock.Unlock()
-	sf.key = fkey
+	sf.addr = fkey
 	sf.fileSize = int64(size)
 
 	sf.mountInfo.lock.Lock()
 	defer sf.mountInfo.lock.Unlock()
 	sf.mountInfo.LatestManifest = mhash
 
-	log.Info("Added new file:", "fname", sf.name, "New Manifest hash", mhash)
+	log.Info("swarmfs added new file:", "fname", sf.name, "new Manifest hash", mhash)
 	return nil
 }
 
@@ -75,7 +75,7 @@ func removeFileFromSwarm(sf *SwarmFile) error {
 	defer sf.mountInfo.lock.Unlock()
 	sf.mountInfo.LatestManifest = mkey
 
-	log.Info("Removed file:", "fname", sf.name, "New Manifest hash", mkey)
+	log.Info("swarmfs removed file:", "fname", sf.name, "new Manifest hash", mkey)
 	return nil
 }
 
@@ -102,20 +102,20 @@ func removeDirectoryFromSwarm(sd *SwarmDir) error {
 }
 
 func appendToExistingFileInSwarm(sf *SwarmFile, content []byte, offset int64, length int64) error {
-	fkey, mhash, err := sf.mountInfo.swarmApi.AppendFile(sf.mountInfo.LatestManifest, sf.path, sf.name, sf.fileSize, content, sf.key, offset, length, true)
+	fkey, mhash, err := sf.mountInfo.swarmApi.AppendFile(sf.mountInfo.LatestManifest, sf.path, sf.name, sf.fileSize, content, sf.addr, offset, length, true)
 	if err != nil {
 		return err
 	}
 
 	sf.lock.Lock()
 	defer sf.lock.Unlock()
-	sf.key = fkey
+	sf.addr = fkey
 	sf.fileSize = sf.fileSize + int64(len(content))
 
 	sf.mountInfo.lock.Lock()
 	defer sf.mountInfo.lock.Unlock()
 	sf.mountInfo.LatestManifest = mhash
 
-	log.Info("Appended file:", "fname", sf.name, "New Manifest hash", mhash)
+	log.Info("swarmfs appended file:", "fname", sf.name, "new Manifest hash", mhash)
 	return nil
 }