1) Change default gofmt default settings for
parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
1st set of files.
R=rsc
CC=agl, golang-dev, iant, ken2, r
https://golang.org/cl/180047
diff --git a/src/pkg/bufio/bufio_test.go b/src/pkg/bufio/bufio_test.go
index bdd4800..83152e9 100644
--- a/src/pkg/bufio/bufio_test.go
+++ b/src/pkg/bufio/bufio_test.go
@@ -5,68 +5,68 @@
package bufio
import (
- "bytes";
- "fmt";
- "io";
- "os";
- "strings";
- "testing";
- "testing/iotest";
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "testing"
+ "testing/iotest"
)
// Reads from a reader and rot13s the result.
type rot13Reader struct {
- r io.Reader;
+ r io.Reader
}
func newRot13Reader(r io.Reader) *rot13Reader {
- r13 := new(rot13Reader);
- r13.r = r;
- return r13;
+ r13 := new(rot13Reader)
+ r13.r = r
+ return r13
}
func (r13 *rot13Reader) Read(p []byte) (int, os.Error) {
- n, e := r13.r.Read(p);
+ n, e := r13.r.Read(p)
if e != nil {
return n, e
}
for i := 0; i < n; i++ {
- c := p[i] | 0x20; // lowercase byte
+ c := p[i] | 0x20 // lowercase byte
if 'a' <= c && c <= 'm' {
p[i] += 13
} else if 'n' <= c && c <= 'z' {
p[i] -= 13
}
}
- return n, nil;
+ return n, nil
}
// Call ReadByte to accumulate the text of a file
func readBytes(buf *Reader) string {
- var b [1000]byte;
- nb := 0;
+ var b [1000]byte
+ nb := 0
for {
- c, e := buf.ReadByte();
+ c, e := buf.ReadByte()
if e == os.EOF {
break
}
if e != nil {
panic("Data: " + e.String())
}
- b[nb] = c;
- nb++;
+ b[nb] = c
+ nb++
}
- return string(b[0:nb]);
+ return string(b[0:nb])
}
func TestReaderSimple(t *testing.T) {
- data := "hello world";
- b := NewReader(bytes.NewBufferString(data));
+ data := "hello world"
+ b := NewReader(bytes.NewBufferString(data))
if s := readBytes(b); s != "hello world" {
t.Errorf("simple hello world test failed: got %q", s)
}
- b = NewReader(newRot13Reader(bytes.NewBufferString(data)));
+ b = NewReader(newRot13Reader(bytes.NewBufferString(data)))
if s := readBytes(b); s != "uryyb jbeyq" {
t.Error("rot13 hello world test failed: got %q", s)
}
@@ -74,8 +74,8 @@
type readMaker struct {
- name string;
- fn func(io.Reader) io.Reader;
+ name string
+ fn func(io.Reader) io.Reader
}
var readMakers = []readMaker{
@@ -88,37 +88,37 @@
// Call ReadString (which ends up calling everything else)
// to accumulate the text of a file.
func readLines(b *Reader) string {
- s := "";
+ s := ""
for {
- s1, e := b.ReadString('\n');
+ s1, e := b.ReadString('\n')
if e == os.EOF {
break
}
if e != nil {
panic("GetLines: " + e.String())
}
- s += s1;
+ s += s1
}
- return s;
+ return s
}
// Call Read to accumulate the text of a file
func reads(buf *Reader, m int) string {
- var b [1000]byte;
- nb := 0;
+ var b [1000]byte
+ nb := 0
for {
- n, e := buf.Read(b[nb : nb+m]);
- nb += n;
+ n, e := buf.Read(b[nb : nb+m])
+ nb += n
if e == os.EOF {
break
}
}
- return string(b[0:nb]);
+ return string(b[0:nb])
}
type bufReader struct {
- name string;
- fn func(*Reader) string;
+ name string
+ fn func(*Reader) string
}
var bufreaders = []bufReader{
@@ -138,27 +138,27 @@
}
func TestReader(t *testing.T) {
- var texts [31]string;
- str := "";
- all := "";
+ var texts [31]string
+ str := ""
+ all := ""
for i := 0; i < len(texts)-1; i++ {
- texts[i] = str + "\n";
- all += texts[i];
- str += string(i%26 + 'a');
+ texts[i] = str + "\n"
+ all += texts[i]
+ str += string(i%26 + 'a')
}
- texts[len(texts)-1] = all;
+ texts[len(texts)-1] = all
for h := 0; h < len(texts); h++ {
- text := texts[h];
+ text := texts[h]
for i := 0; i < len(readMakers); i++ {
for j := 0; j < len(bufreaders); j++ {
for k := 0; k < len(bufsizes); k++ {
- readmaker := readMakers[i];
- bufreader := bufreaders[j];
- bufsize := bufsizes[k];
- read := readmaker.fn(bytes.NewBufferString(text));
- buf, _ := NewReaderSize(read, bufsize);
- s := bufreader.fn(buf);
+ readmaker := readMakers[i]
+ bufreader := bufreaders[j]
+ bufsize := bufsizes[k]
+ read := readmaker.fn(bytes.NewBufferString(text))
+ buf, _ := NewReaderSize(read, bufsize)
+ s := bufreader.fn(buf)
if s != text {
t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q",
readmaker.name, bufreader.name, bufsize, text, s)
@@ -171,37 +171,37 @@
// A StringReader delivers its data one string segment at a time via Read.
type StringReader struct {
- data []string;
- step int;
+ data []string
+ step int
}
func (r *StringReader) Read(p []byte) (n int, err os.Error) {
if r.step < len(r.data) {
- s := r.data[r.step];
+ s := r.data[r.step]
for i := 0; i < len(s); i++ {
p[i] = s[i]
}
- n = len(s);
- r.step++;
+ n = len(s)
+ r.step++
} else {
err = os.EOF
}
- return;
+ return
}
func readRuneSegments(t *testing.T, segments []string) {
- got := "";
- want := strings.Join(segments, "");
- r := NewReader(&StringReader{data: segments});
+ got := ""
+ want := strings.Join(segments, "")
+ r := NewReader(&StringReader{data: segments})
for {
- rune, _, err := r.ReadRune();
+ rune, _, err := r.ReadRune()
if err != nil {
if err != os.EOF {
return
}
- break;
+ break
}
- got += string(rune);
+ got += string(rune)
}
if got != want {
t.Errorf("segments=%v got=%s want=%s", segments, got, want)
@@ -226,46 +226,46 @@
}
func TestWriter(t *testing.T) {
- var data [8192]byte;
+ var data [8192]byte
for i := 0; i < len(data); i++ {
data[i] = byte(' ' + i%('~'-' '))
}
- w := new(bytes.Buffer);
+ w := new(bytes.Buffer)
for i := 0; i < len(bufsizes); i++ {
for j := 0; j < len(bufsizes); j++ {
- nwrite := bufsizes[i];
- bs := bufsizes[j];
+ nwrite := bufsizes[i]
+ bs := bufsizes[j]
// Write nwrite bytes using buffer size bs.
// Check that the right amount makes it out
// and that the data is correct.
- w.Reset();
- buf, e := NewWriterSize(w, bs);
- context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs);
+ w.Reset()
+ buf, e := NewWriterSize(w, bs)
+ context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
if e != nil {
- t.Errorf("%s: NewWriterSize %d: %v", context, bs, e);
- continue;
+ t.Errorf("%s: NewWriterSize %d: %v", context, bs, e)
+ continue
}
- n, e1 := buf.Write(data[0:nwrite]);
+ n, e1 := buf.Write(data[0:nwrite])
if e1 != nil || n != nwrite {
- t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1);
- continue;
+ t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1)
+ continue
}
if e = buf.Flush(); e != nil {
t.Errorf("%s: buf.Flush = %v", context, e)
}
- written := w.Bytes();
+ written := w.Bytes()
if len(written) != nwrite {
t.Errorf("%s: %d bytes written", context, len(written))
}
for l := 0; l < len(written); l++ {
if written[i] != data[i] {
- t.Errorf("%s: wrong bytes written");
- t.Errorf("want=%s", data[0:len(written)]);
- t.Errorf("have=%s", written);
+ t.Errorf("%s: wrong bytes written")
+ t.Errorf("want=%s", data[0:len(written)])
+ t.Errorf("have=%s", written)
}
}
}
@@ -275,9 +275,9 @@
// Check that write errors are returned properly.
type errorWriterTest struct {
- n, m int;
- err os.Error;
- expect os.Error;
+ n, m int
+ err os.Error
+ expect os.Error
}
func (w errorWriterTest) Write(p []byte) (int, os.Error) {
@@ -295,13 +295,13 @@
func TestWriteErrors(t *testing.T) {
for _, w := range errorWriterTests {
- buf := NewWriter(w);
- _, e := buf.Write(strings.Bytes("hello world"));
+ buf := NewWriter(w)
+ _, e := buf.Write(strings.Bytes("hello world"))
if e != nil {
- t.Errorf("Write hello to %v: %v", w, e);
- continue;
+ t.Errorf("Write hello to %v: %v", w, e)
+ continue
}
- e = buf.Flush();
+ e = buf.Flush()
if e != w.expect {
t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect)
}
@@ -309,13 +309,13 @@
}
func TestNewReaderSizeIdempotent(t *testing.T) {
- const BufSize = 1000;
- b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize);
+ const BufSize = 1000
+ b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize)
if err != nil {
t.Error("NewReaderSize create fail", err)
}
// Does it recognize itself?
- b1, err2 := NewReaderSize(b, BufSize);
+ b1, err2 := NewReaderSize(b, BufSize)
if err2 != nil {
t.Error("NewReaderSize #2 create fail", err2)
}
@@ -323,7 +323,7 @@
t.Error("NewReaderSize did not detect underlying Reader")
}
// Does it wrap if existing buffer is too small?
- b2, err3 := NewReaderSize(b, 2*BufSize);
+ b2, err3 := NewReaderSize(b, 2*BufSize)
if err3 != nil {
t.Error("NewReaderSize #3 create fail", err3)
}
@@ -333,13 +333,13 @@
}
func TestNewWriterSizeIdempotent(t *testing.T) {
- const BufSize = 1000;
- b, err := NewWriterSize(new(bytes.Buffer), BufSize);
+ const BufSize = 1000
+ b, err := NewWriterSize(new(bytes.Buffer), BufSize)
if err != nil {
t.Error("NewWriterSize create fail", err)
}
// Does it recognize itself?
- b1, err2 := NewWriterSize(b, BufSize);
+ b1, err2 := NewWriterSize(b, BufSize)
if err2 != nil {
t.Error("NewWriterSize #2 create fail", err2)
}
@@ -347,7 +347,7 @@
t.Error("NewWriterSize did not detect underlying Writer")
}
// Does it wrap if existing buffer is too small?
- b2, err3 := NewWriterSize(b, 2*BufSize);
+ b2, err3 := NewWriterSize(b, 2*BufSize)
if err3 != nil {
t.Error("NewWriterSize #3 create fail", err3)
}
@@ -357,22 +357,22 @@
}
func TestWriteString(t *testing.T) {
- const BufSize = 8;
- buf := new(bytes.Buffer);
- b, err := NewWriterSize(buf, BufSize);
+ const BufSize = 8
+ buf := new(bytes.Buffer)
+ b, err := NewWriterSize(buf, BufSize)
if err != nil {
t.Error("NewWriterSize create fail", err)
}
- b.WriteString("0"); // easy
- b.WriteString("123456"); // still easy
- b.WriteString("7890"); // easy after flush
- b.WriteString("abcdefghijklmnopqrstuvwxy"); // hard
- b.WriteString("z");
- b.Flush();
+ b.WriteString("0") // easy
+ b.WriteString("123456") // still easy
+ b.WriteString("7890") // easy after flush
+ b.WriteString("abcdefghijklmnopqrstuvwxy") // hard
+ b.WriteString("z")
+ b.Flush()
if b.err != nil {
t.Error("WriteString", b.err)
}
- s := "01234567890abcdefghijklmnopqrstuvwxyz";
+ s := "01234567890abcdefghijklmnopqrstuvwxyz"
if string(buf.Bytes()) != s {
t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes()))
}
