summaryrefslogtreecommitdiff
path: root/src/pkg/os
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/os')
-rw-r--r--src/pkg/os/dir_darwin.go10
-rw-r--r--src/pkg/os/dir_linux.go14
-rw-r--r--src/pkg/os/dir_nacl.go14
-rw-r--r--src/pkg/os/env.go6
-rw-r--r--src/pkg/os/error.go2
-rw-r--r--src/pkg/os/exec.go26
-rw-r--r--src/pkg/os/file.go90
-rw-r--r--src/pkg/os/getwd.go16
-rw-r--r--src/pkg/os/os_test.go180
-rw-r--r--src/pkg/os/path.go26
-rw-r--r--src/pkg/os/path_test.go56
-rw-r--r--src/pkg/os/stat_darwin.go4
-rw-r--r--src/pkg/os/stat_linux.go4
-rw-r--r--src/pkg/os/stat_nacl.go4
-rw-r--r--src/pkg/os/sys_darwin.go2
-rw-r--r--src/pkg/os/sys_linux.go6
-rw-r--r--src/pkg/os/time.go2
17 files changed, 231 insertions, 231 deletions
diff --git a/src/pkg/os/dir_darwin.go b/src/pkg/os/dir_darwin.go
index c207a19fd..74781ae5b 100644
--- a/src/pkg/os/dir_darwin.go
+++ b/src/pkg/os/dir_darwin.go
@@ -29,7 +29,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
d := file.dirinfo;
size := count;
if size < 0 {
- size = 100;
+ size = 100
}
names = make([]string, 0, size); // Empty with room to grow.
for count != 0 {
@@ -44,7 +44,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
return names, NewSyscallError("getdirentries", errno);
}
if d.nbuf <= 0 {
- break; // EOF
+ break // EOF
}
}
// Drain the buffer
@@ -56,18 +56,18 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
}
d.bufp += int(dirent.Reclen);
if dirent.Ino == 0 { // File absent in directory.
- continue;
+ continue
}
bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
var name = string(bytes[0 : dirent.Namlen]);
if name == "." || name == ".." { // Useless names
- continue;
+ continue
}
count--;
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names));
for i := 0; i < len(names); i++ {
- nnames[i] = names[i];
+ nnames[i] = names[i]
}
names = nnames;
}
diff --git a/src/pkg/os/dir_linux.go b/src/pkg/os/dir_linux.go
index d6e77016c..0e73fefd6 100644
--- a/src/pkg/os/dir_linux.go
+++ b/src/pkg/os/dir_linux.go
@@ -16,7 +16,7 @@ const (
func clen(n []byte) int {
for i := 0; i < len(n); i++ {
if n[i] == 0 {
- return i;
+ return i
}
}
return len(n);
@@ -33,7 +33,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
d := file.dirinfo;
size := count;
if size < 0 {
- size = 100;
+ size = 100
}
names = make([]string, 0, size); // Empty with room to grow.
for count != 0 {
@@ -42,10 +42,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
var errno int;
d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
if errno != 0 {
- return names, NewSyscallError("getdents", errno);
+ return names, NewSyscallError("getdents", errno)
}
if d.nbuf <= 0 {
- break; // EOF
+ break // EOF
}
d.bufp = 0;
}
@@ -54,18 +54,18 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
d.bufp += int(dirent.Reclen);
if dirent.Ino == 0 { // File absent in directory.
- continue;
+ continue
}
bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
var name = string(bytes[0:clen(bytes)]);
if name == "." || name == ".." { // Useless names
- continue;
+ continue
}
count--;
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names));
for i := 0; i < len(names); i++ {
- nnames[i] = names[i];
+ nnames[i] = names[i]
}
names = nnames;
}
diff --git a/src/pkg/os/dir_nacl.go b/src/pkg/os/dir_nacl.go
index d6e77016c..0e73fefd6 100644
--- a/src/pkg/os/dir_nacl.go
+++ b/src/pkg/os/dir_nacl.go
@@ -16,7 +16,7 @@ const (
func clen(n []byte) int {
for i := 0; i < len(n); i++ {
if n[i] == 0 {
- return i;
+ return i
}
}
return len(n);
@@ -33,7 +33,7 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
d := file.dirinfo;
size := count;
if size < 0 {
- size = 100;
+ size = 100
}
names = make([]string, 0, size); // Empty with room to grow.
for count != 0 {
@@ -42,10 +42,10 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
var errno int;
d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
if errno != 0 {
- return names, NewSyscallError("getdents", errno);
+ return names, NewSyscallError("getdents", errno)
}
if d.nbuf <= 0 {
- break; // EOF
+ break // EOF
}
d.bufp = 0;
}
@@ -54,18 +54,18 @@ func (file *File) Readdirnames(count int) (names []string, err Error) {
dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
d.bufp += int(dirent.Reclen);
if dirent.Ino == 0 { // File absent in directory.
- continue;
+ continue
}
bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
var name = string(bytes[0:clen(bytes)]);
if name == "." || name == ".." { // Useless names
- continue;
+ continue
}
count--;
if len(names) == cap(names) {
nnames := make([]string, len(names), 2*len(names));
for i := 0; i < len(names); i++ {
- nnames[i] = names[i];
+ nnames[i] = names[i]
}
names = nnames;
}
diff --git a/src/pkg/os/env.go b/src/pkg/os/env.go
index 3523f57e4..e85864992 100644
--- a/src/pkg/os/env.go
+++ b/src/pkg/os/env.go
@@ -34,11 +34,11 @@ func Getenverror(key string) (value string, err Error) {
once.Do(copyenv);
if len(key) == 0 {
- return "", EINVAL;
+ return "", EINVAL
}
v, ok := env[key];
if !ok {
- return "", ENOENV;
+ return "", ENOENV
}
return v, nil;
}
@@ -56,7 +56,7 @@ func Setenv(key, value string) Error {
once.Do(copyenv);
if len(key) == 0 {
- return EINVAL;
+ return EINVAL
}
env[key] = value;
return nil;
diff --git a/src/pkg/os/error.go b/src/pkg/os/error.go
index 6bbf5371e..34f88de8d 100644
--- a/src/pkg/os/error.go
+++ b/src/pkg/os/error.go
@@ -97,7 +97,7 @@ func (e *SyscallError) String() string { return e.Syscall + ": " + e.Errno.Strin
// As a convenience, if errno is 0, NewSyscallError returns nil.
func NewSyscallError(syscall string, errno int) Error {
if errno == 0 {
- return nil;
+ return nil
}
return &SyscallError{syscall, Errno(errno)};
}
diff --git a/src/pkg/os/exec.go b/src/pkg/os/exec.go
index a279bf428..80c2913f0 100644
--- a/src/pkg/os/exec.go
+++ b/src/pkg/os/exec.go
@@ -20,15 +20,15 @@ func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File
intfd := make([]int, len(fd));
for i, f := range fd {
if f == nil {
- intfd[i] = -1;
+ intfd[i] = -1
} else {
- intfd[i] = f.Fd();
+ intfd[i] = f.Fd()
}
}
p, e := syscall.ForkExec(argv0, argv, envv, dir, intfd);
if e != 0 {
- return 0, &PathError{"fork/exec", argv0, Errno(e)};
+ return 0, &PathError{"fork/exec", argv0, Errno(e)}
}
return p, nil;
}
@@ -39,11 +39,11 @@ func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File
// ForkExec is almost always a better way to execute a program.
func Exec(argv0 string, argv []string, envv []string) Error {
if envv == nil {
- envv = Environ();
+ envv = Environ()
}
e := syscall.Exec(argv0, argv, envv);
if e != 0 {
- return &PathError{"exec", argv0, Errno(e)};
+ return &PathError{"exec", argv0, Errno(e)}
}
return nil;
}
@@ -86,7 +86,7 @@ func Wait(pid int, options int) (w *Waitmsg, err Error) {
}
pid1, e := syscall.Wait4(pid, &status, options, rusage);
if e != 0 {
- return nil, NewSyscallError("wait", e);
+ return nil, NewSyscallError("wait", e)
}
w = new(Waitmsg);
w.Pid = pid1;
@@ -98,12 +98,12 @@ func Wait(pid int, options int) (w *Waitmsg, err Error) {
// Convert i to decimal string.
func itod(i int) string {
if i == 0 {
- return "0";
+ return "0"
}
u := uint64(i);
if i < 0 {
- u = -u;
+ u = -u
}
// Assemble decimal in reverse order.
@@ -127,19 +127,19 @@ func (w Waitmsg) String() string {
res := "";
switch {
case w.Exited():
- res = "exit status " + itod(w.ExitStatus());
+ res = "exit status " + itod(w.ExitStatus())
case w.Signaled():
- res = "signal " + itod(w.Signal());
+ res = "signal " + itod(w.Signal())
case w.Stopped():
res = "stop signal " + itod(w.StopSignal());
if w.StopSignal() == syscall.SIGTRAP && w.TrapCause() != 0 {
- res += " (trap " + itod(w.TrapCause()) + ")";
+ res += " (trap " + itod(w.TrapCause()) + ")"
}
case w.Continued():
- res = "continued";
+ res = "continued"
}
if w.CoreDump() {
- res += " (core dumped)";
+ res += " (core dumped)"
}
return res;
}
diff --git a/src/pkg/os/file.go b/src/pkg/os/file.go
index 0afdca39c..d378b7025 100644
--- a/src/pkg/os/file.go
+++ b/src/pkg/os/file.go
@@ -34,7 +34,7 @@ func (file *File) Name() string { return file.name }
// NewFile returns a new File with the given file descriptor and name.
func NewFile(fd int, name string) *File {
if fd < 0 {
- return nil;
+ return nil
}
return &File{fd, name, nil, 0};
}
@@ -70,13 +70,13 @@ const (
func Open(name string, flag int, perm int) (file *File, err Error) {
r, e := syscall.Open(name, flag | syscall.O_CLOEXEC, perm);
if e != 0 {
- return nil, &PathError{"open", name, Errno(e)};
+ return nil, &PathError{"open", name, Errno(e)}
}
// There's a race here with fork/exec, which we are
// content to live with. See ../syscall/exec.go
if syscall.O_CLOEXEC == 0 { // O_CLOEXEC not supported
- syscall.CloseOnExec(r);
+ syscall.CloseOnExec(r)
}
return NewFile(r, name), nil;
@@ -86,11 +86,11 @@ func Open(name string, flag int, perm int) (file *File, err Error) {
// It returns an Error, if any.
func (file *File) Close() Error {
if file == nil {
- return EINVAL;
+ return EINVAL
}
var err Error;
if e := syscall.Close(file.fd); e != 0 {
- err = &PathError{"close", file.name, Errno(e)};
+ err = &PathError{"close", file.name, Errno(e)}
}
file.fd = -1; // so it can't be closed again
return err;
@@ -112,17 +112,17 @@ var EOF Error = eofError(0)
// EOF is signaled by a zero count with err set to EOF.
func (file *File) Read(b []byte) (n int, err Error) {
if file == nil {
- return 0, EINVAL;
+ return 0, EINVAL
}
n, e := syscall.Read(file.fd, b);
if n < 0 {
- n = 0;
+ n = 0
}
if n == 0 && e == 0 {
- return 0, EOF;
+ return 0, EOF
}
if e != 0 {
- err = &PathError{"read", file.name, Errno(e)};
+ err = &PathError{"read", file.name, Errno(e)}
}
return n, err;
}
@@ -133,7 +133,7 @@ func (file *File) Read(b []byte) (n int, err Error) {
// ReadAt always returns a non-nil Error when n != len(b).
func (file *File) ReadAt(b []byte, off int64) (n int, err Error) {
if file == nil {
- return 0, EINVAL;
+ return 0, EINVAL
}
for len(b) > 0 {
m, e := syscall.Pread(file.fd, b, off);
@@ -153,22 +153,22 @@ func (file *File) ReadAt(b []byte, off int64) (n int, err Error) {
// Write returns a non-nil Error when n != len(b).
func (file *File) Write(b []byte) (n int, err Error) {
if file == nil {
- return 0, EINVAL;
+ return 0, EINVAL
}
n, e := syscall.Write(file.fd, b);
if n < 0 {
- n = 0;
+ n = 0
}
if e == syscall.EPIPE {
file.nepipe++;
if file.nepipe >= 10 {
- Exit(syscall.EPIPE);
+ Exit(syscall.EPIPE)
}
} else {
- file.nepipe = 0;
+ file.nepipe = 0
}
if e != 0 {
- err = &PathError{"write", file.name, Errno(e)};
+ err = &PathError{"write", file.name, Errno(e)}
}
return n, err;
}
@@ -178,7 +178,7 @@ func (file *File) Write(b []byte) (n int, err Error) {
// WriteAt returns a non-nil Error when n != len(b).
func (file *File) WriteAt(b []byte, off int64) (n int, err Error) {
if file == nil {
- return 0, EINVAL;
+ return 0, EINVAL
}
for len(b) > 0 {
m, e := syscall.Pwrite(file.fd, b, off);
@@ -200,10 +200,10 @@ func (file *File) WriteAt(b []byte, off int64) (n int, err Error) {
func (file *File) Seek(offset int64, whence int) (ret int64, err Error) {
r, e := syscall.Seek(file.fd, offset, whence);
if e == 0 && file.dirinfo != nil && r != 0 {
- e = syscall.EISDIR;
+ e = syscall.EISDIR
}
if e != 0 {
- return 0, &PathError{"seek", file.name, Errno(e)};
+ return 0, &PathError{"seek", file.name, Errno(e)}
}
return r, nil;
}
@@ -212,7 +212,7 @@ func (file *File) Seek(offset int64, whence int) (ret int64, err Error) {
// an array of bytes.
func (file *File) WriteString(s string) (ret int, err Error) {
if file == nil {
- return 0, EINVAL;
+ return 0, EINVAL
}
b := syscall.StringByteSlice(s);
b = b[0 : len(b)-1];
@@ -243,7 +243,7 @@ func Pipe() (r *File, w *File, err Error) {
func Mkdir(name string, perm int) Error {
e := syscall.Mkdir(name, perm);
if e != 0 {
- return &PathError{"mkdir", name, Errno(e)};
+ return &PathError{"mkdir", name, Errno(e)}
}
return nil;
}
@@ -257,13 +257,13 @@ func Stat(name string) (dir *Dir, err Error) {
var lstat, stat syscall.Stat_t;
e := syscall.Lstat(name, &lstat);
if e != 0 {
- return nil, &PathError{"stat", name, Errno(e)};
+ return nil, &PathError{"stat", name, Errno(e)}
}
statp := &lstat;
if lstat.Mode & syscall.S_IFMT == syscall.S_IFLNK {
e := syscall.Stat(name, &stat);
if e == 0 {
- statp = &stat;
+ statp = &stat
}
}
return dirFromStat(name, new(Dir), &lstat, statp), nil;
@@ -275,7 +275,7 @@ func (file *File) Stat() (dir *Dir, err Error) {
var stat syscall.Stat_t;
e := syscall.Fstat(file.fd, &stat);
if e != 0 {
- return nil, &PathError{"stat", file.name, Errno(e)};
+ return nil, &PathError{"stat", file.name, Errno(e)}
}
return dirFromStat(file.name, new(Dir), &stat, &stat), nil;
}
@@ -287,7 +287,7 @@ func Lstat(name string) (dir *Dir, err Error) {
var stat syscall.Stat_t;
e := syscall.Lstat(name, &stat);
if e != 0 {
- return nil, &PathError{"lstat", name, Errno(e)};
+ return nil, &PathError{"lstat", name, Errno(e)}
}
return dirFromStat(name, new(Dir), &stat, &stat), nil;
}
@@ -300,20 +300,20 @@ func Lstat(name string) (dir *Dir, err Error) {
func (file *File) Readdir(count int) (dirs []Dir, err Error) {
dirname := file.name;
if dirname == "" {
- dirname = ".";
+ dirname = "."
}
dirname += "/";
names, err1 := file.Readdirnames(count);
if err1 != nil {
- return nil, err1;
+ return nil, err1
}
dirs = make([]Dir, len(names));
for i, filename := range names {
dirp, err := Lstat(dirname+filename);
if dirp == nil || err != nil {
- dirs[i].Name = filename; // rest is already zeroed out
+ dirs[i].Name = filename // rest is already zeroed out
} else {
- dirs[i] = *dirp;
+ dirs[i] = *dirp
}
}
return;
@@ -322,7 +322,7 @@ func (file *File) Readdir(count int) (dirs []Dir, err Error) {
// Chdir changes the current working directory to the named directory.
func Chdir(dir string) Error {
if e := syscall.Chdir(dir); e != 0 {
- return &PathError{"chdir", dir, Errno(e)};
+ return &PathError{"chdir", dir, Errno(e)}
}
return nil;
}
@@ -331,7 +331,7 @@ func Chdir(dir string) Error {
// which must be a directory.
func (f *File) Chdir() Error {
if e := syscall.Fchdir(f.fd); e != 0 {
- return &PathError{"chdir", f.name, Errno(e)};
+ return &PathError{"chdir", f.name, Errno(e)}
}
return nil;
}
@@ -344,11 +344,11 @@ func Remove(name string) Error {
// doing a Stat plus the right one.
e := syscall.Unlink(name);
if e == 0 {
- return nil;
+ return nil
}
e1 := syscall.Rmdir(name);
if e1 == 0 {
- return nil;
+ return nil
}
// Both failed: figure out which error to return.
@@ -361,7 +361,7 @@ func Remove(name string) Error {
// both errors will be ENOTDIR, so it's okay to
// use the error from unlink.
if e1 != syscall.ENOTDIR {
- e = e1;
+ e = e1
}
return &PathError{"remove", name, Errno(e)};
}
@@ -376,14 +376,14 @@ type LinkError struct {
}
func (e *LinkError) String() string {
- return e.Op + " " + e.Old + " " + e.New + ": " + e.Error.String();
+ return e.Op + " " + e.Old + " " + e.New + ": " + e.Error.String()
}
// Link creates a hard link.
func Link(oldname, newname string) Error {
e := syscall.Link(oldname, newname);
if e != 0 {
- return &LinkError{"link", oldname, newname, Errno(e)};
+ return &LinkError{"link", oldname, newname, Errno(e)}
}
return nil;
}
@@ -392,7 +392,7 @@ func Link(oldname, newname string) Error {
func Symlink(oldname, newname string) Error {
e := syscall.Symlink(oldname, newname);
if e != 0 {
- return &LinkError{"symlink", oldname, newname, Errno(e)};
+ return &LinkError{"symlink", oldname, newname, Errno(e)}
}
return nil;
}
@@ -404,10 +404,10 @@ func Readlink(name string) (string, Error) {
b := make([]byte, len);
n, e := syscall.Readlink(name, b);
if e != 0 {
- return "", &PathError{"readlink", name, Errno(e)};
+ return "", &PathError{"readlink", name, Errno(e)}
}
if n < len {
- return string(b[0:n]), nil;
+ return string(b[0:n]), nil
}
}
// Silence 6g.
@@ -418,7 +418,7 @@ func Readlink(name string) (string, Error) {
// If the file is a symbolic link, it changes the uid and gid of the link's target.
func Chmod(name string, mode int) Error {
if e := syscall.Chmod(name, mode); e != 0 {
- return &PathError{"chmod", name, Errno(e)};
+ return &PathError{"chmod", name, Errno(e)}
}
return nil;
}
@@ -426,7 +426,7 @@ func Chmod(name string, mode int) Error {
// Chmod changes the mode of the file to mode.
func (f *File) Chmod(mode int) Error {
if e := syscall.Fchmod(f.fd, mode); e != 0 {
- return &PathError{"chmod", f.name, Errno(e)};
+ return &PathError{"chmod", f.name, Errno(e)}
}
return nil;
}
@@ -435,7 +435,7 @@ func (f *File) Chmod(mode int) Error {
// If the file is a symbolic link, it changes the uid and gid of the link's target.
func Chown(name string, uid, gid int) Error {
if e := syscall.Chown(name, uid, gid); e != 0 {
- return &PathError{"chown", name, Errno(e)};
+ return &PathError{"chown", name, Errno(e)}
}
return nil;
}
@@ -444,7 +444,7 @@ func Chown(name string, uid, gid int) Error {
// If the file is a symbolic link, it changes the uid and gid of the link itself.
func Lchown(name string, uid, gid int) Error {
if e := syscall.Lchown(name, uid, gid); e != 0 {
- return &PathError{"lchown", name, Errno(e)};
+ return &PathError{"lchown", name, Errno(e)}
}
return nil;
}
@@ -452,7 +452,7 @@ func Lchown(name string, uid, gid int) Error {
// Chown changes the numeric uid and gid of the named file.
func (f *File) Chown(uid, gid int) Error {
if e := syscall.Fchown(f.fd, uid, gid); e != 0 {
- return &PathError{"chown", f.name, Errno(e)};
+ return &PathError{"chown", f.name, Errno(e)}
}
return nil;
}
@@ -461,7 +461,7 @@ func (f *File) Chown(uid, gid int) Error {
// If the file is a symbolic link, it changes the size of the link's target.
func Truncate(name string, size int64) Error {
if e := syscall.Truncate(name, size); e != 0 {
- return &PathError{"truncate", name, Errno(e)};
+ return &PathError{"truncate", name, Errno(e)}
}
return nil;
}
@@ -470,7 +470,7 @@ func Truncate(name string, size int64) Error {
// It does not change the I/O offset.
func (f *File) Truncate(size int64) Error {
if e := syscall.Ftruncate(f.fd, size); e != 0 {
- return &PathError{"truncate", f.name, Errno(e)};
+ return &PathError{"truncate", f.name, Errno(e)}
}
return nil;
}
diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go
index bb8637b2b..1f7580d22 100644
--- a/src/pkg/os/getwd.go
+++ b/src/pkg/os/getwd.go
@@ -22,7 +22,7 @@ func Getwd() (string, Error) {
// Otherwise, we're trying to find our way back to ".".
dot, err := Stat(".");
if err != nil {
- return "", err;
+ return "", err
}
// Clumsy but widespread kludge:
@@ -31,7 +31,7 @@ func Getwd() (string, Error) {
if len(pwd) > 0 && pwd[0] == '/' {
d, err := Stat(pwd);
if err == nil && d.Dev == dot.Dev && d.Ino == dot.Ino {
- return pwd, nil;
+ return pwd, nil
}
}
@@ -40,10 +40,10 @@ func Getwd() (string, Error) {
root, err := Stat("/");
if err != nil {
// Can't stat root - no hope.
- return "", err;
+ return "", err
}
if root.Dev == dot.Dev && root.Ino == dot.Ino {
- return "/", nil;
+ return "/", nil
}
// General algorithm: find name in parent
@@ -52,11 +52,11 @@ func Getwd() (string, Error) {
pwd = "";
for parent := ".."; ; parent = "../"+parent {
if len(parent) >= 1024 { // Sanity check
- return "", ENAMETOOLONG;
+ return "", ENAMETOOLONG
}
fd, err := Open(parent, O_RDONLY, 0);
if err != nil {
- return "", err;
+ return "", err
}
for {
@@ -79,11 +79,11 @@ func Getwd() (string, Error) {
Found:
pd, err := fd.Stat();
if err != nil {
- return "", err;
+ return "", err
}
fd.Close();
if pd.Dev == root.Dev && pd.Ino == root.Ino {
- break;
+ break
}
// Set up for next round.
dot = pd;
diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go
index 832ce6083..9eb032768 100644
--- a/src/pkg/os/os_test.go
+++ b/src/pkg/os/os_test.go
@@ -36,7 +36,7 @@ func size(name string, t *testing.T) uint64 {
file, err := Open(name, O_RDONLY, 0);
defer file.Close();
if err != nil {
- t.Fatal("open failed:", err);
+ t.Fatal("open failed:", err)
}
var buf [100]byte;
len := 0;
@@ -44,10 +44,10 @@ func size(name string, t *testing.T) uint64 {
n, e := file.Read(&buf);
len += n;
if e == EOF {
- break;
+ break
}
if e != nil {
- t.Fatal("read failed:", err);
+ t.Fatal("read failed:", err)
}
}
return uint64(len);
@@ -56,14 +56,14 @@ func size(name string, t *testing.T) uint64 {
func TestStat(t *testing.T) {
dir, err := Stat("/etc/passwd");
if err != nil {
- t.Fatal("stat failed:", err);
+ t.Fatal("stat failed:", err)
}
if dir.Name != "passwd" {
- t.Error("name should be passwd; is", dir.Name);
+ t.Error("name should be passwd; is", dir.Name)
}
filesize := size("/etc/passwd", t);
if dir.Size != filesize {
- t.Error("size should be", filesize, "; is", dir.Size);
+ t.Error("size should be", filesize, "; is", dir.Size)
}
}
@@ -71,32 +71,32 @@ func TestFstat(t *testing.T) {
file, err1 := Open("/etc/passwd", O_RDONLY, 0);
defer file.Close();
if err1 != nil {
- t.Fatal("open failed:", err1);
+ t.Fatal("open failed:", err1)
}
dir, err2 := file.Stat();
if err2 != nil {
- t.Fatal("fstat failed:", err2);
+ t.Fatal("fstat failed:", err2)
}
if dir.Name != "passwd" {
- t.Error("name should be passwd; is", dir.Name);
+ t.Error("name should be passwd; is", dir.Name)
}
filesize := size("/etc/passwd", t);
if dir.Size != filesize {
- t.Error("size should be", filesize, "; is", dir.Size);
+ t.Error("size should be", filesize, "; is", dir.Size)
}
}
func TestLstat(t *testing.T) {
dir, err := Lstat("/etc/passwd");
if err != nil {
- t.Fatal("lstat failed:", err);
+ t.Fatal("lstat failed:", err)
}
if dir.Name != "passwd" {
- t.Error("name should be passwd; is", dir.Name);
+ t.Error("name should be passwd; is", dir.Name)
}
filesize := size("/etc/passwd", t);
if dir.Size != filesize {
- t.Error("size should be", filesize, "; is", dir.Size);
+ t.Error("size should be", filesize, "; is", dir.Size)
}
}
@@ -104,27 +104,27 @@ func testReaddirnames(dir string, contents []string, t *testing.T) {
file, err := Open(dir, O_RDONLY, 0);
defer file.Close();
if err != nil {
- t.Fatalf("open %q failed: %v", dir, err);
+ t.Fatalf("open %q failed: %v", dir, err)
}
s, err2 := file.Readdirnames(-1);
if err2 != nil {
- t.Fatalf("readdirnames %q failed: %v", err2);
+ t.Fatalf("readdirnames %q failed: %v", err2)
}
for _, m := range contents {
found := false;
for _, n := range s {
if n == "." || n == ".." {
- t.Errorf("got %s in directory", n);
+ t.Errorf("got %s in directory", n)
}
if m == n {
if found {
- t.Error("present twice:", m);
+ t.Error("present twice:", m)
}
found = true;
}
}
if !found {
- t.Error("could not find", m);
+ t.Error("could not find", m)
}
}
}
@@ -133,24 +133,24 @@ func testReaddir(dir string, contents []string, t *testing.T) {
file, err := Open(dir, O_RDONLY, 0);
defer file.Close();
if err != nil {
- t.Fatalf("open %q failed: %v", dir, err);
+ t.Fatalf("open %q failed: %v", dir, err)
}
s, err2 := file.Readdir(-1);
if err2 != nil {
- t.Fatalf("readdir %q failed: %v", dir, err2);
+ t.Fatalf("readdir %q failed: %v", dir, err2)
}
for _, m := range contents {
found := false;
for _, n := range s {
if m == n.Name {
if found {
- t.Error("present twice:", m);
+ t.Error("present twice:", m)
}
found = true;
}
}
if !found {
- t.Error("could not find", m);
+ t.Error("could not find", m)
}
}
}
@@ -172,10 +172,10 @@ func smallReaddirnames(file *File, length int, t *testing.T) []string {
for {
d, err := file.Readdirnames(1);
if err != nil {
- t.Fatalf("readdir %q failed: %v", file.Name(), err);
+ t.Fatalf("readdir %q failed: %v", file.Name(), err)
}
if len(d) == 0 {
- break;
+ break
}
names[count] = d[0];
count++;
@@ -190,20 +190,20 @@ func TestReaddirnamesOneAtATime(t *testing.T) {
file, err := Open(dir, O_RDONLY, 0);
defer file.Close();
if err != nil {
- t.Fatalf("open %q failed: %v", dir, err);
+ t.Fatalf("open %q failed: %v", dir, err)
}
all, err1 := file.Readdirnames(-1);
if err1 != nil {
- t.Fatalf("readdirnames %q failed: %v", dir, err1);
+ t.Fatalf("readdirnames %q failed: %v", dir, err1)
}
file1, err2 := Open(dir, O_RDONLY, 0);
if err2 != nil {
- t.Fatalf("open %q failed: %v", dir, err2);
+ t.Fatalf("open %q failed: %v", dir, err2)
}
small := smallReaddirnames(file1, len(all)+100, t); // +100 in case we screw up
for i, n := range all {
if small[i] != n {
- t.Errorf("small read %q %q mismatch: %v", small[i], n);
+ t.Errorf("small read %q %q mismatch: %v", small[i], n)
}
}
}
@@ -213,27 +213,27 @@ func TestHardLink(t *testing.T) {
Remove(from); // Just in case.
file, err := Open(to, O_CREAT|O_WRONLY, 0666);
if err != nil {
- t.Fatalf("open %q failed: %v", to, err);
+ t.Fatalf("open %q failed: %v", to, err)
}
defer Remove(to);
if err = file.Close(); err != nil {
- t.Errorf("close %q failed: %v", to, err);
+ t.Errorf("close %q failed: %v", to, err)
}
err = Link(to, from);
if err != nil {
- t.Fatalf("link %q, %q failed: %v", to, from, err);
+ t.Fatalf("link %q, %q failed: %v", to, from, err)
}
defer Remove(from);
tostat, err := Stat(to);
if err != nil {
- t.Fatalf("stat %q failed: %v", to, err);
+ t.Fatalf("stat %q failed: %v", to, err)
}
fromstat, err := Stat(from);
if err != nil {
- t.Fatalf("stat %q failed: %v", from, err);
+ t.Fatalf("stat %q failed: %v", from, err)
}
if tostat.Dev != fromstat.Dev || tostat.Ino != fromstat.Ino {
- t.Errorf("link %q, %q did not create hard link", to, from);
+ t.Errorf("link %q, %q did not create hard link", to, from)
}
}
@@ -242,55 +242,55 @@ func TestSymLink(t *testing.T) {
Remove(from); // Just in case.
file, err := Open(to, O_CREAT|O_WRONLY, 0666);
if err != nil {
- t.Fatalf("open %q failed: %v", to, err);
+ t.Fatalf("open %q failed: %v", to, err)
}
defer Remove(to);
if err = file.Close(); err != nil {
- t.Errorf("close %q failed: %v", to, err);
+ t.Errorf("close %q failed: %v", to, err)
}
err = Symlink(to, from);
if err != nil {
- t.Fatalf("symlink %q, %q failed: %v", to, from, err);
+ t.Fatalf("symlink %q, %q failed: %v", to, from, err)
}
defer Remove(from);
tostat, err := Stat(to);
if err != nil {
- t.Fatalf("stat %q failed: %v", to, err);
+ t.Fatalf("stat %q failed: %v", to, err)
}
if tostat.FollowedSymlink {
- t.Fatalf("stat %q claims to have followed a symlink", to);
+ t.Fatalf("stat %q claims to have followed a symlink", to)
}
fromstat, err := Stat(from);
if err != nil {
- t.Fatalf("stat %q failed: %v", from, err);
+ t.Fatalf("stat %q failed: %v", from, err)
}
if tostat.Dev != fromstat.Dev || tostat.Ino != fromstat.Ino {
- t.Errorf("symlink %q, %q did not create symlink", to, from);
+ t.Errorf("symlink %q, %q did not create symlink", to, from)
}
fromstat, err = Lstat(from);
if err != nil {
- t.Fatalf("lstat %q failed: %v", from, err);
+ t.Fatalf("lstat %q failed: %v", from, err)
}
if !fromstat.IsSymlink() {
- t.Fatalf("symlink %q, %q did not create symlink", to, from);
+ t.Fatalf("symlink %q, %q did not create symlink", to, from)
}
fromstat, err = Stat(from);
if err != nil {
- t.Fatalf("stat %q failed: %v", from, err);
+ t.Fatalf("stat %q failed: %v", from, err)
}
if !fromstat.FollowedSymlink {
- t.Fatalf("stat %q did not follow symlink");
+ t.Fatalf("stat %q did not follow symlink")
}
s, err := Readlink(from);
if err != nil {
- t.Fatalf("readlink %q failed: %v", from, err);
+ t.Fatalf("readlink %q failed: %v", from, err)
}
if s != to {
- t.Fatalf("after symlink %q != %q", s, to);
+ t.Fatalf("after symlink %q != %q", s, to)
}
file, err = Open(from, O_RDONLY, 0);
if err != nil {
- t.Fatalf("open %q failed: %v", from, err);
+ t.Fatalf("open %q failed: %v", from, err)
}
file.Close();
}
@@ -301,26 +301,26 @@ func TestLongSymlink(t *testing.T) {
from := "longsymlinktestfrom";
err := Symlink(s, from);
if err != nil {
- t.Fatalf("symlink %q, %q failed: %v", s, from, err);
+ t.Fatalf("symlink %q, %q failed: %v", s, from, err)
}
defer Remove(from);
r, err := Readlink(from);
if err != nil {
- t.Fatalf("readlink %q failed: %v", from, err);
+ t.Fatalf("readlink %q failed: %v", from, err)
}
if r != s {
- t.Fatalf("after symlink %q != %q", r, s);
+ t.Fatalf("after symlink %q != %q", r, s)
}
}
func TestForkExec(t *testing.T) {
r, w, err := Pipe();
if err != nil {
- t.Fatalf("Pipe: %v", err);
+ t.Fatalf("Pipe: %v", err)
}
pid, err := ForkExec("/bin/pwd", []string{"pwd"}, nil, "/", []*File{nil, w, Stderr});
if err != nil {
- t.Fatalf("ForkExec: %v", err);
+ t.Fatalf("ForkExec: %v", err)
}
w.Close();
@@ -329,7 +329,7 @@ func TestForkExec(t *testing.T) {
output := b.String();
expect := "/\n";
if output != expect {
- t.Errorf("exec /bin/pwd returned %q wanted %q", output, expect);
+ t.Errorf("exec /bin/pwd returned %q wanted %q", output, expect)
}
Wait(pid, 0);
}
@@ -337,10 +337,10 @@ func TestForkExec(t *testing.T) {
func checkMode(t *testing.T, path string, mode uint32) {
dir, err := Stat(path);
if err != nil {
- t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err);
+ t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
}
if dir.Mode & 0777 != mode {
- t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode, 0777);
+ t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode, 0777)
}
}
@@ -349,16 +349,16 @@ func TestChmod(t *testing.T) {
const Path = "_obj/_TestChmod_";
fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %s: %s", Path, err);
+ t.Fatalf("create %s: %s", Path, err)
}
if err = Chmod(Path, 0456); err != nil {
- t.Fatalf("chmod %s 0456: %s", Path, err);
+ t.Fatalf("chmod %s 0456: %s", Path, err)
}
checkMode(t, Path, 0456);
if err = fd.Chmod(0123); err != nil {
- t.Fatalf("fchmod %s 0123: %s", Path, err);
+ t.Fatalf("fchmod %s 0123: %s", Path, err)
}
checkMode(t, Path, 0123);
@@ -369,13 +369,13 @@ func TestChmod(t *testing.T) {
func checkUidGid(t *testing.T, path string, uid, gid int) {
dir, err := Stat(path);
if err != nil {
- t.Fatalf("Stat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err);
+ t.Fatalf("Stat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err)
}
if dir.Uid != uint32(uid) {
- t.Errorf("Stat %q: uid %d want %d", path, dir.Uid, uid);
+ t.Errorf("Stat %q: uid %d want %d", path, dir.Uid, uid)
}
if dir.Gid != uint32(gid) {
- t.Errorf("Stat %q: gid %d want %d", path, dir.Gid, gid);
+ t.Errorf("Stat %q: gid %d want %d", path, dir.Gid, gid)
}
}
@@ -388,11 +388,11 @@ func TestChown(t *testing.T) {
const Path = "/tmp/_TestChown_";
fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %s: %s", Path, err);
+ t.Fatalf("create %s: %s", Path, err)
}
dir, err := fd.Stat();
if err != nil {
- t.Fatalf("fstat %s: %s", Path, err);
+ t.Fatalf("fstat %s: %s", Path, err)
}
defer fd.Close();
defer Remove(Path);
@@ -402,25 +402,25 @@ func TestChown(t *testing.T) {
gid := Getgid();
t.Log("gid:", gid);
if err = Chown(Path, -1, gid); err != nil {
- t.Fatalf("chown %s -1 %d: %s", Path, gid, err);
+ t.Fatalf("chown %s -1 %d: %s", Path, gid, err)
}
checkUidGid(t, Path, int(dir.Uid), gid);
// Then try all the auxiliary groups.
groups, err := Getgroups();
if err != nil {
- t.Fatalf("getgroups: %s", err);
+ t.Fatalf("getgroups: %s", err)
}
t.Log("groups: ", groups);
for _, g := range groups {
if err = Chown(Path, -1, g); err != nil {
- t.Fatalf("chown %s -1 %d: %s", Path, g, err);
+ t.Fatalf("chown %s -1 %d: %s", Path, g, err)
}
checkUidGid(t, Path, int(dir.Uid), g);
// change back to gid to test fd.Chown
if err = fd.Chown(-1, gid); err != nil {
- t.Fatalf("fchown %s -1 %d: %s", Path, gid, err);
+ t.Fatalf("fchown %s -1 %d: %s", Path, gid, err)
}
checkUidGid(t, Path, int(dir.Uid), gid);
}
@@ -429,10 +429,10 @@ func TestChown(t *testing.T) {
func checkSize(t *testing.T, path string, size uint64) {
dir, err := Stat(path);
if err != nil {
- t.Fatalf("Stat %q (looking for size %d): %s", path, size, err);
+ t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
}
if dir.Size != size {
- t.Errorf("Stat %q: size %d want %d", path, dir.Size, size);
+ t.Errorf("Stat %q: size %d want %d", path, dir.Size, size)
}
}
@@ -441,7 +441,7 @@ func TestTruncate(t *testing.T) {
const Path = "_obj/_TestTruncate_";
fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %s: %s", Path, err);
+ t.Fatalf("create %s: %s", Path, err)
}
checkSize(t, Path, 0);
@@ -462,7 +462,7 @@ func TestTruncate(t *testing.T) {
func TestChdirAndGetwd(t *testing.T) {
fd, err := Open(".", O_RDONLY, 0);
if err != nil {
- t.Fatalf("Open .: %s", err);
+ t.Fatalf("Open .: %s", err)
}
// These are chosen carefully not to be symlinks on a Mac
// (unlike, say, /var, /etc, and /tmp).
@@ -470,7 +470,7 @@ func TestChdirAndGetwd(t *testing.T) {
for mode := 0; mode < 2; mode++ {
for _, d := range dirs {
if mode == 0 {
- err = Chdir(d);
+ err = Chdir(d)
} else {
fd1, err := Open(d, O_RDONLY, 0);
if err != nil {
@@ -515,14 +515,14 @@ func TestTime(t *testing.T) {
// 365.24*86400 is an integer.
sec, nsec, err := Time();
if sec < (2009-1970)*36524*864 {
- t.Errorf("Time() = %d, %d, %s; not plausible", sec, nsec, err);
+ t.Errorf("Time() = %d, %d, %s; not plausible", sec, nsec, err)
}
}
func TestSeek(t *testing.T) {
f, err := Open("_obj/seektest", O_CREAT|O_RDWR|O_TRUNC, 0666);
if err != nil {
- t.Fatalf("open _obj/seektest: %s", err);
+ t.Fatalf("open _obj/seektest: %s", err)
}
const data = "hello, world\n";
@@ -546,7 +546,7 @@ func TestSeek(t *testing.T) {
for i, tt := range tests {
off, err := f.Seek(tt.in, tt.whence);
if off != tt.out || err != nil {
- t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out);
+ t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
}
}
f.Close();
@@ -585,7 +585,7 @@ func TestOpenError(t *testing.T) {
continue;
}
if s := err.String(); s != tt.error {
- t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, s, tt.error);
+ t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, s, tt.error)
}
}
}
@@ -594,11 +594,11 @@ func run(t *testing.T, cmd []string) string {
// Run /bin/hostname and collect output.
r, w, err := Pipe();
if err != nil {
- t.Fatal(err);
+ t.Fatal(err)
}
pid, err := ForkExec("/bin/hostname", []string{"hostname"}, nil, "/", []*File{nil, w, Stderr});
if err != nil {
- t.Fatal(err);
+ t.Fatal(err)
}
w.Close();
@@ -607,10 +607,10 @@ func run(t *testing.T, cmd []string) string {
Wait(pid, 0);
output := b.String();
if n := len(output); n > 0 && output[n-1] == '\n' {
- output = output[0 : n-1];
+ output = output[0 : n-1]
}
if output == "" {
- t.Fatalf("%v produced no output", cmd);
+ t.Fatalf("%v produced no output", cmd)
}
return output;
@@ -621,18 +621,18 @@ func TestHostname(t *testing.T) {
// Check internal Hostname() against the output of /bin/hostname.
hostname, err := Hostname();
if err != nil {
- t.Fatalf("%v", err);
+ t.Fatalf("%v", err)
}
want := run(t, []string{"/bin/hostname"});
if hostname != want {
- t.Errorf("Hostname() = %q, want %q", hostname, want);
+ t.Errorf("Hostname() = %q, want %q", hostname, want)
}
}
func TestReadAt(t *testing.T) {
f, err := Open("_obj/readtest", O_CREAT|O_RDWR|O_TRUNC, 0666);
if err != nil {
- t.Fatalf("open _obj/readtest: %s", err);
+ t.Fatalf("open _obj/readtest: %s", err)
}
const data = "hello, world\n";
io.WriteString(f, data);
@@ -640,31 +640,31 @@ func TestReadAt(t *testing.T) {
b := make([]byte, 5);
n, err := f.ReadAt(b, 7);
if err != nil || n != len(b) {
- t.Fatalf("ReadAt 7: %d, %r", n, err);
+ t.Fatalf("ReadAt 7: %d, %r", n, err)
}
if string(b) != "world" {
- t.Fatalf("ReadAt 7: have %q want %q", string(b), "world");
+ t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
}
}
func TestWriteAt(t *testing.T) {
f, err := Open("_obj/writetest", O_CREAT|O_RDWR|O_TRUNC, 0666);
if err != nil {
- t.Fatalf("open _obj/writetest: %s", err);
+ t.Fatalf("open _obj/writetest: %s", err)
}
const data = "hello, world\n";
io.WriteString(f, data);
n, err := f.WriteAt(strings.Bytes("WORLD"), 7);
if err != nil || n != 5 {
- t.Fatalf("WriteAt 7: %d, %v", n, err);
+ t.Fatalf("WriteAt 7: %d, %v", n, err)
}
b, err := io.ReadFile("_obj/writetest");
if err != nil {
- t.Fatalf("ReadFile _obj/writetest: %v", err);
+ t.Fatalf("ReadFile _obj/writetest: %v", err)
}
if string(b) != "hello, WORLD\n" {
- t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n");
+ t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n")
}
}
diff --git a/src/pkg/os/path.go b/src/pkg/os/path.go
index de4b020d4..057b20b05 100644
--- a/src/pkg/os/path.go
+++ b/src/pkg/os/path.go
@@ -17,7 +17,7 @@ func MkdirAll(path string, perm int) Error {
dir, err := Lstat(path);
if err == nil {
if dir.IsDirectory() {
- return nil;
+ return nil
}
return &PathError{"mkdir", path, ENOTDIR};
}
@@ -25,19 +25,19 @@ func MkdirAll(path string, perm int) Error {
// Doesn't already exist; make sure parent does.
i := len(path);
for i > 0 && path[i-1] == '/' { // Skip trailing slashes.
- i--;
+ i--
}
j := i;
for j > 0 && path[j-1] != '/' { // Scan backward over element.
- j--;
+ j--
}
if j > 0 {
// Create parent
err = MkdirAll(path[0 : j-1], perm);
if err != nil {
- return err;
+ return err
}
}
@@ -48,7 +48,7 @@ func MkdirAll(path string, perm int) Error {
// double-checking that directory doesn't exist.
dir, err1 := Lstat(path);
if err1 == nil && dir.IsDirectory() {
- return nil;
+ return nil
}
return err;
}
@@ -63,26 +63,26 @@ func RemoveAll(path string) Error {
// Simple case: if Remove works, we're done.
err := Remove(path);
if err == nil {
- return nil;
+ return nil
}
// Otherwise, is this a directory we need to recurse into?
dir, serr := Lstat(path);
if serr != nil {
if serr, ok := serr.(*PathError); ok && serr.Error == ENOENT {
- return nil;
+ return nil
}
return serr;
}
if !dir.IsDirectory() {
// Not a directory; return the error from Remove.
- return err;
+ return err
}
// Directory.
fd, err := Open(path, O_RDONLY, 0);
if err != nil {
- return err;
+ return err
}
defer fd.Close();
@@ -93,22 +93,22 @@ func RemoveAll(path string) Error {
for _, name := range names {
err1 := RemoveAll(path+"/"+name);
if err == nil {
- err = err1;
+ err = err1
}
}
// If Readdirnames returned an error, use it.
if err == nil {
- err = err1;
+ err = err1
}
if len(names) == 0 {
- break;
+ break
}
}
// Remove directory.
err1 := Remove(path);
if err == nil {
- err = err1;
+ err = err1
}
return err;
}
diff --git a/src/pkg/os/path_test.go b/src/pkg/os/path_test.go
index 61cba30ee..2dce2c597 100644
--- a/src/pkg/os/path_test.go
+++ b/src/pkg/os/path_test.go
@@ -15,47 +15,47 @@ func TestMkdirAll(t *testing.T) {
path := "_obj/_TestMkdirAll_/dir/./dir2";
err := MkdirAll(path, 0777);
if err != nil {
- t.Fatalf("MkdirAll %q: %s", path, err);
+ t.Fatalf("MkdirAll %q: %s", path, err)
}
// Already exists, should succeed.
err = MkdirAll(path, 0777);
if err != nil {
- t.Fatalf("MkdirAll %q (second time): %s", path, err);
+ t.Fatalf("MkdirAll %q (second time): %s", path, err)
}
// Make file.
fpath := path+"/file";
_, err = Open(fpath, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %q: %s", fpath, err);
+ t.Fatalf("create %q: %s", fpath, err)
}
// Can't make directory named after file.
err = MkdirAll(fpath, 0777);
if err == nil {
- t.Fatalf("MkdirAll %q: no error");
+ t.Fatalf("MkdirAll %q: no error")
}
perr, ok := err.(*PathError);
if !ok {
- t.Fatalf("MkdirAll %q returned %T, not *PathError", fpath, err);
+ t.Fatalf("MkdirAll %q returned %T, not *PathError", fpath, err)
}
if perr.Path != fpath {
- t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", fpath, perr.Path, fpath);
+ t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", fpath, perr.Path, fpath)
}
// Can't make subdirectory of file.
ffpath := fpath + "/subdir";
err = MkdirAll(ffpath, 0777);
if err == nil {
- t.Fatalf("MkdirAll %q: no error");
+ t.Fatalf("MkdirAll %q: no error")
}
perr, ok = err.(*PathError);
if !ok {
- t.Fatalf("MkdirAll %q returned %T, not *PathError", ffpath, err);
+ t.Fatalf("MkdirAll %q returned %T, not *PathError", ffpath, err)
}
if perr.Path != fpath {
- t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", ffpath, perr.Path, fpath);
+ t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", ffpath, perr.Path, fpath)
}
RemoveAll("_obj/_TestMkdirAll_");
@@ -69,82 +69,82 @@ func TestRemoveAll(t *testing.T) {
// Make directory with 1 file and remove.
if err := MkdirAll(path, 0777); err != nil {
- t.Fatalf("MkdirAll %q: %s", path, err);
+ t.Fatalf("MkdirAll %q: %s", path, err)
}
fd, err := Open(fpath, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %q: %s", fpath, err);
+ t.Fatalf("create %q: %s", fpath, err)
}
fd.Close();
if err = RemoveAll(path); err != nil {
- t.Fatalf("RemoveAll %q (first): %s", path, err);
+ t.Fatalf("RemoveAll %q (first): %s", path, err)
}
if _, err := Lstat(path); err == nil {
- t.Fatalf("Lstat %q succeeded after RemoveAll (first)", path);
+ t.Fatalf("Lstat %q succeeded after RemoveAll (first)", path)
}
// Make directory with file and subdirectory and remove.
if err = MkdirAll(dpath, 0777); err != nil {
- t.Fatalf("MkdirAll %q: %s", dpath, err);
+ t.Fatalf("MkdirAll %q: %s", dpath, err)
}
fd, err = Open(fpath, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %q: %s", fpath, err);
+ t.Fatalf("create %q: %s", fpath, err)
}
fd.Close();
fd, err = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %q: %s", fpath, err);
+ t.Fatalf("create %q: %s", fpath, err)
}
fd.Close();
if err = RemoveAll(path); err != nil {
- t.Fatalf("RemoveAll %q (second): %s", path, err);
+ t.Fatalf("RemoveAll %q (second): %s", path, err)
}
if _, err := Lstat(path); err == nil {
- t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path);
+ t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path)
}
// Make directory with file and subdirectory and trigger error.
if err = MkdirAll(dpath, 0777); err != nil {
- t.Fatalf("MkdirAll %q: %s", dpath, err);
+ t.Fatalf("MkdirAll %q: %s", dpath, err)
}
for _, s := range []string{fpath, dpath+"/file1", path+"/zzz"} {
fd, err = Open(s, O_WRONLY|O_CREAT, 0666);
if err != nil {
- t.Fatalf("create %q: %s", s, err);
+ t.Fatalf("create %q: %s", s, err)
}
fd.Close();
}
if err = Chmod(dpath, 0); err != nil {
- t.Fatalf("Chmod %q 0: %s", dpath, err);
+ t.Fatalf("Chmod %q 0: %s", dpath, err)
}
if err = RemoveAll(path); err == nil {
_, err := Lstat(path);
if err == nil {
- t.Errorf("Can lstat %q after supposed RemoveAll", path);
+ t.Errorf("Can lstat %q after supposed RemoveAll", path)
}
t.Fatalf("RemoveAll %q succeeded with chmod 0 subdirectory", path, err);
}
perr, ok := err.(*PathError);
if !ok {
- t.Fatalf("RemoveAll %q returned %T not *PathError", path, err);
+ t.Fatalf("RemoveAll %q returned %T not *PathError", path, err)
}
if perr.Path != dpath {
- t.Fatalf("RemoveAll %q failed at %q not %q", path, perr.Path, dpath);
+ t.Fatalf("RemoveAll %q failed at %q not %q", path, perr.Path, dpath)
}
if err = Chmod(dpath, 0777); err != nil {
- t.Fatalf("Chmod %q 0777: %s", dpath, err);
+ t.Fatalf("Chmod %q 0777: %s", dpath, err)
}
for _, s := range []string{fpath, path+"/zzz"} {
if _, err := Lstat(s); err == nil {
- t.Fatalf("Lstat %q succeeded after partial RemoveAll", s);
+ t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
}
}
if err = RemoveAll(path); err != nil {
- t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err);
+ t.Fatalf("RemoveAll %q after partial RemoveAll: %s", path, err)
}
if _, err := Lstat(path); err == nil {
- t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path);
+ t.Fatalf("Lstat %q succeeded after RemoveAll (final)", path)
}
}
diff --git a/src/pkg/os/stat_darwin.go b/src/pkg/os/stat_darwin.go
index 6ba402fa6..d712ee8e2 100644
--- a/src/pkg/os/stat_darwin.go
+++ b/src/pkg/os/stat_darwin.go
@@ -7,7 +7,7 @@ package os
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK;
+ return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
@@ -32,7 +32,7 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
}
dir.Name = name;
if isSymlink(lstat) && !isSymlink(stat) {
- dir.FollowedSymlink = true;
+ dir.FollowedSymlink = true
}
return dir;
}
diff --git a/src/pkg/os/stat_linux.go b/src/pkg/os/stat_linux.go
index fe4193a5b..c63697df7 100644
--- a/src/pkg/os/stat_linux.go
+++ b/src/pkg/os/stat_linux.go
@@ -7,7 +7,7 @@ package os
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK;
+ return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
@@ -32,7 +32,7 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
}
dir.Name = name;
if isSymlink(lstat) && !isSymlink(stat) {
- dir.FollowedSymlink = true;
+ dir.FollowedSymlink = true
}
return dir;
}
diff --git a/src/pkg/os/stat_nacl.go b/src/pkg/os/stat_nacl.go
index 5295106df..a5007d08c 100644
--- a/src/pkg/os/stat_nacl.go
+++ b/src/pkg/os/stat_nacl.go
@@ -7,7 +7,7 @@ package os
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK;
+ return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
@@ -32,7 +32,7 @@ func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
}
dir.Name = name;
if isSymlink(lstat) && !isSymlink(stat) {
- dir.FollowedSymlink = true;
+ dir.FollowedSymlink = true
}
return dir;
}
diff --git a/src/pkg/os/sys_darwin.go b/src/pkg/os/sys_darwin.go
index fb57f1733..c92845578 100644
--- a/src/pkg/os/sys_darwin.go
+++ b/src/pkg/os/sys_darwin.go
@@ -12,7 +12,7 @@ func Hostname() (name string, err Error) {
var errno int;
name, errno = syscall.Sysctl("kern.hostname");
if errno != 0 {
- return "", NewSyscallError("sysctl kern.hostname", errno);
+ return "", NewSyscallError("sysctl kern.hostname", errno)
}
return name, nil;
}
diff --git a/src/pkg/os/sys_linux.go b/src/pkg/os/sys_linux.go
index 12a99dff3..896be164d 100644
--- a/src/pkg/os/sys_linux.go
+++ b/src/pkg/os/sys_linux.go
@@ -11,18 +11,18 @@ package os
func Hostname() (name string, err Error) {
f, err := Open("/proc/sys/kernel/hostname", O_RDONLY, 0);
if err != nil {
- return "", err;
+ return "", err
}
defer f.Close();
var buf [512]byte; // Enough for a DNS name.
n, err := f.Read(&buf);
if err != nil {
- return "", err;
+ return "", err
}
if n > 0 && buf[n-1] == '\n' {
- n--;
+ n--
}
return string(buf[0:n]), nil;
}
diff --git a/src/pkg/os/time.go b/src/pkg/os/time.go
index 21d4df733..a82a39382 100644
--- a/src/pkg/os/time.go
+++ b/src/pkg/os/time.go
@@ -14,7 +14,7 @@ import "syscall"
func Time() (sec int64, nsec int64, err Error) {
var tv syscall.Timeval;
if errno := syscall.Gettimeofday(&tv); errno != 0 {
- return 0, 0, NewSyscallError("gettimeofday", errno);
+ return 0, 0, NewSyscallError("gettimeofday", errno)
}
return int64(tv.Sec), int64(tv.Usec)*1000, err;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-22 17:39:11 +0000