gofmt-ify gob

(the one-line struct types used in composite literals will become
one line again in another cleanup round; don't worry about them now)

R=r
http://go/go-review/1016056

diff --git a/src/pkg/gob/codec_test.go b/src/pkg/gob/codec_test.go
index 3c75e4f855402cf1ea1fc5e0a7d986fefbaee222..745f2c0de7557d20eda56a05467bd4f737107bcf 100644 (file)
--- a/src/pkg/gob/codec_test.go
+++ b/src/pkg/gob/codec_test.go
@@ -19,21 +19,22 @@ type EncodeT struct {
        x       uint64;
        b       []byte;
 }
-var encodeT = []EncodeT {
-       EncodeT{ 0x00,  []byte{0x00} },
-       EncodeT{ 0x0F,  []byte{0x0F} },
-       EncodeT{ 0xFF,  []byte{0xFF, 0xFF} },
-       EncodeT{ 0xFFFF,        []byte{0xFE, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFF,      []byte{0xFD, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFFFF,    []byte{0xFC, 0xFF, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFFFFFF,  []byte{0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFFFFFFFF,        []byte{0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFFFFFFFFFF,      []byte{0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0xFFFFFFFFFFFFFFFF,    []byte{0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} },
-       EncodeT{ 0x1111,        []byte{0xFE, 0x11, 0x11} },
-       EncodeT{ 0x1111111111111111,    []byte{0xF8, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11} },
-       EncodeT{ 0x8888888888888888,    []byte{0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88} },
-       EncodeT{ 1<<63, []byte{0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },
+
+var encodeT = []EncodeT{
+       EncodeT{0x00, []byte{0x00}},
+       EncodeT{0x0F, []byte{0x0F}},
+       EncodeT{0xFF, []byte{0xFF, 0xFF}},
+       EncodeT{0xFFFF, []byte{0xFE, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFF, []byte{0xFD, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFFFF, []byte{0xFC, 0xFF, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFFFFFF, []byte{0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFFFFFFFF, []byte{0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFFFFFFFFFF, []byte{0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0xFFFFFFFFFFFFFFFF, []byte{0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
+       EncodeT{0x1111, []byte{0xFE, 0x11, 0x11}},
+       EncodeT{0x1111111111111111, []byte{0xF8, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}},
+       EncodeT{0x8888888888888888, []byte{0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88}},
+       EncodeT{1<<63, []byte{0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 }
 
 
@@ -46,28 +47,28 @@ func TestUintCodec(t *testing.T) {
                b.Reset();
                encodeUint(encState, tt.x);
                if encState.err != nil {
-                       t.Error("encodeUint:", tt.x, encState.err)
+                       t.Error("encodeUint:", tt.x, encState.err);
                }
                if !bytes.Equal(tt.b, b.Bytes()) {
-                       t.Errorf("encodeUint: %#x encode: expected % x got % x", tt.x, tt.b, b.Bytes())
+                       t.Errorf("encodeUint: %#x encode: expected % x got % x", tt.x, tt.b, b.Bytes());
                }
        }
        decState := newDecodeState(b);
-       for u := uint64(0); ; u = (u+1) * 7 {
+       for u := uint64(0); ; u = (u+1)*7 {
                b.Reset();
                encodeUint(encState, u);
                if encState.err != nil {
-                       t.Error("encodeUint:", u, encState.err)
+                       t.Error("encodeUint:", u, encState.err);
                }
                v := decodeUint(decState);
                if decState.err != nil {
-                       t.Error("DecodeUint:", u, decState.err)
+                       t.Error("DecodeUint:", u, decState.err);
                }
                if u != v {
-                       t.Errorf("Encode/Decode: sent %#x received %#x\n", u, v)
+                       t.Errorf("Encode/Decode: sent %#x received %#x\n", u, v);
                }
-               if u & (1<<63) != 0 {
-                       break
+               if u&(1<<63) != 0 {
+                       break;
                }
        }
 }
@@ -78,32 +79,32 @@ func verifyInt(i int64, t *testing.T) {
        encState.b = b;
        encodeInt(encState, i);
        if encState.err != nil {
-               t.Error("encodeInt:", i, encState.err)
+               t.Error("encodeInt:", i, encState.err);
        }
        decState := newDecodeState(b);
        decState.buf = make([]byte, 8);
        j := decodeInt(decState);
        if decState.err != nil {
-               t.Error("DecodeInt:", i, decState.err)
+               t.Error("DecodeInt:", i, decState.err);
        }
        if i != j {
-               t.Errorf("Encode/Decode: sent %#x received %#x\n", uint64(i), uint64(j))
+               t.Errorf("Encode/Decode: sent %#x received %#x\n", uint64(i), uint64(j));
        }
 }
 
 // Test basic encode/decode routines for signed integers
 func TestIntCodec(t *testing.T) {
-       for u := uint64(0); ; u = (u+1) * 7 {
+       for u := uint64(0); ; u = (u+1)*7 {
                // Do positive and negative values
                i := int64(u);
                verifyInt(i, t);
                verifyInt(-i, t);
                verifyInt(^i, t);
-               if u & (1<<63) != 0 {
-                       break
+               if u&(1<<63) != 0 {
+                       break;
                }
        }
-       verifyInt(-1<<63, t);   // a tricky case
+       verifyInt(-1 << 63, t); // a tricky case
 }
 
 // The result of encoding a true boolean with field number 7
@@ -130,192 +131,224 @@ func TestScalarEncInstructions(t *testing.T) {
 
        // bool
        {
-               data := struct { a bool } { true };
-               instr := &encInstr{ encBool, 6, 0, 0 };
+               data := struct {
+                       a bool;
+               }{true};
+               instr := &encInstr{encBool, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(boolResult, b.Bytes()) {
-                       t.Errorf("bool enc instructions: expected % x got % x", boolResult, b.Bytes())
+                       t.Errorf("bool enc instructions: expected % x got % x", boolResult, b.Bytes());
                }
        }
 
        // int
        {
                b.Reset();
-               data := struct { a int } { 17 };
-               instr := &encInstr{ encInt, 6, 0, 0 };
+               data := struct {
+                       a int;
+               }{17};
+               instr := &encInstr{encInt, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(signedResult, b.Bytes()) {
-                       t.Errorf("int enc instructions: expected % x got % x", signedResult, b.Bytes())
+                       t.Errorf("int enc instructions: expected % x got % x", signedResult, b.Bytes());
                }
        }
 
        // uint
        {
                b.Reset();
-               data := struct { a uint } { 17 };
-               instr := &encInstr{ encUint, 6, 0, 0 };
+               data := struct {
+                       a uint;
+               }{17};
+               instr := &encInstr{encUint, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(unsignedResult, b.Bytes()) {
-                       t.Errorf("uint enc instructions: expected % x got % x", unsignedResult, b.Bytes())
+                       t.Errorf("uint enc instructions: expected % x got % x", unsignedResult, b.Bytes());
                }
        }
 
        // int8
        {
                b.Reset();
-               data := struct { a int8 } { 17 };
-               instr := &encInstr{ encInt8, 6, 0, 0 };
+               data := struct {
+                       a int8;
+               }{17};
+               instr := &encInstr{encInt8, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(signedResult, b.Bytes()) {
-                       t.Errorf("int8 enc instructions: expected % x got % x", signedResult, b.Bytes())
+                       t.Errorf("int8 enc instructions: expected % x got % x", signedResult, b.Bytes());
                }
        }
 
        // uint8
        {
                b.Reset();
-               data := struct { a uint8 } { 17 };
-               instr := &encInstr{ encUint8, 6, 0, 0 };
+               data := struct {
+                       a uint8;
+               }{17};
+               instr := &encInstr{encUint8, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(unsignedResult, b.Bytes()) {
-                       t.Errorf("uint8 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
+                       t.Errorf("uint8 enc instructions: expected % x got % x", unsignedResult, b.Bytes());
                }
        }
 
        // int16
        {
                b.Reset();
-               data := struct { a int16 } { 17 };
-               instr := &encInstr{ encInt16, 6, 0, 0 };
+               data := struct {
+                       a int16;
+               }{17};
+               instr := &encInstr{encInt16, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(signedResult, b.Bytes()) {
-                       t.Errorf("int16 enc instructions: expected % x got % x", signedResult, b.Bytes())
+                       t.Errorf("int16 enc instructions: expected % x got % x", signedResult, b.Bytes());
                }
        }
 
        // uint16
        {
                b.Reset();
-               data := struct { a uint16 } { 17 };
-               instr := &encInstr{ encUint16, 6, 0, 0 };
+               data := struct {
+                       a uint16;
+               }{17};
+               instr := &encInstr{encUint16, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(unsignedResult, b.Bytes()) {
-                       t.Errorf("uint16 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
+                       t.Errorf("uint16 enc instructions: expected % x got % x", unsignedResult, b.Bytes());
                }
        }
 
        // int32
        {
                b.Reset();
-               data := struct { a int32 } { 17 };
-               instr := &encInstr{ encInt32, 6, 0, 0 };
+               data := struct {
+                       a int32;
+               }{17};
+               instr := &encInstr{encInt32, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(signedResult, b.Bytes()) {
-                       t.Errorf("int32 enc instructions: expected % x got % x", signedResult, b.Bytes())
+                       t.Errorf("int32 enc instructions: expected % x got % x", signedResult, b.Bytes());
                }
        }
 
        // uint32
        {
                b.Reset();
-               data := struct { a uint32 } { 17 };
-               instr := &encInstr{ encUint32, 6, 0, 0 };
+               data := struct {
+                       a uint32;
+               }{17};
+               instr := &encInstr{encUint32, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(unsignedResult, b.Bytes()) {
-                       t.Errorf("uint32 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
+                       t.Errorf("uint32 enc instructions: expected % x got % x", unsignedResult, b.Bytes());
                }
        }
 
        // int64
        {
                b.Reset();
-               data := struct { a int64 } { 17 };
-               instr := &encInstr{ encInt64, 6, 0, 0 };
+               data := struct {
+                       a int64;
+               }{17};
+               instr := &encInstr{encInt64, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(signedResult, b.Bytes()) {
-                       t.Errorf("int64 enc instructions: expected % x got % x", signedResult, b.Bytes())
+                       t.Errorf("int64 enc instructions: expected % x got % x", signedResult, b.Bytes());
                }
        }
 
        // uint64
        {
                b.Reset();
-               data := struct { a uint64 } { 17 };
-               instr := &encInstr{ encUint64, 6, 0, 0 };
+               data := struct {
+                       a uint64;
+               }{17};
+               instr := &encInstr{encUint64, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(unsignedResult, b.Bytes()) {
-                       t.Errorf("uint64 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
+                       t.Errorf("uint64 enc instructions: expected % x got % x", unsignedResult, b.Bytes());
                }
        }
 
        // float
        {
                b.Reset();
-               data := struct { a float } { 17 };
-               instr := &encInstr{ encFloat, 6, 0, 0 };
+               data := struct {
+                       a float;
+               }{17};
+               instr := &encInstr{encFloat, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(floatResult, b.Bytes()) {
-                       t.Errorf("float enc instructions: expected % x got % x", floatResult, b.Bytes())
+                       t.Errorf("float enc instructions: expected % x got % x", floatResult, b.Bytes());
                }
        }
 
        // float32
        {
                b.Reset();
-               data := struct { a float32 } { 17 };
-               instr := &encInstr{ encFloat32, 6, 0, 0 };
+               data := struct {
+                       a float32;
+               }{17};
+               instr := &encInstr{encFloat32, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(floatResult, b.Bytes()) {
-                       t.Errorf("float32 enc instructions: expected % x got % x", floatResult, b.Bytes())
+                       t.Errorf("float32 enc instructions: expected % x got % x", floatResult, b.Bytes());
                }
        }
 
        // float64
        {
                b.Reset();
-               data := struct { a float64 } { 17 };
-               instr := &encInstr{ encFloat64, 6, 0, 0 };
+               data := struct {
+                       a float64;
+               }{17};
+               instr := &encInstr{encFloat64, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(floatResult, b.Bytes()) {
-                       t.Errorf("float64 enc instructions: expected % x got % x", floatResult, b.Bytes())
+                       t.Errorf("float64 enc instructions: expected % x got % x", floatResult, b.Bytes());
                }
        }
 
        // bytes == []uint8
        {
                b.Reset();
-               data := struct { a []byte } { strings.Bytes("hello") };
-               instr := &encInstr{ encUint8Array, 6, 0, 0 };
+               data := struct {
+                       a []byte;
+               }{strings.Bytes("hello")};
+               instr := &encInstr{encUint8Array, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(bytesResult, b.Bytes()) {
-                       t.Errorf("bytes enc instructions: expected % x got % x", bytesResult, b.Bytes())
+                       t.Errorf("bytes enc instructions: expected % x got % x", bytesResult, b.Bytes());
                }
        }
 
        // string
        {
                b.Reset();
-               data := struct { a string } { "hello" };
-               instr := &encInstr{ encString, 6, 0, 0 };
+               data := struct {
+                       a string;
+               }{"hello"};
+               instr := &encInstr{encString, 6, 0, 0};
                state := newencoderState(b);
                instr.op(instr, state, unsafe.Pointer(&data));
                if !bytes.Equal(bytesResult, b.Bytes()) {
-                       t.Errorf("string enc instructions: expected % x got % x", bytesResult, b.Bytes())
+                       t.Errorf("string enc instructions: expected % x got % x", bytesResult, b.Bytes());
                }
        }
 }
@@ -345,205 +378,239 @@ func TestScalarDecInstructions(t *testing.T) {
 
        // bool
        {
-               var data struct { a bool };
-               instr := &decInstr{ decBool, 6, 0, 0, ovfl };
+               var data struct {
+                       a bool;
+               }
+               instr := &decInstr{decBool, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(boolResult);
                execDec("bool", instr, state, t, unsafe.Pointer(&data));
                if data.a != true {
-                       t.Errorf("bool a = %v not true", data.a)
+                       t.Errorf("bool a = %v not true", data.a);
                }
        }
        // int
        {
-               var data struct { a int };
-               instr := &decInstr{ decOpMap[valueKind(data.a)], 6, 0, 0, ovfl };
+               var data struct {
+                       a int;
+               }
+               instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
                state := newDecodeStateFromData(signedResult);
                execDec("int", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("int a = %v not 17", data.a)
+                       t.Errorf("int a = %v not 17", data.a);
                }
        }
 
        // uint
        {
-               var data struct { a uint };
-               instr := &decInstr{ decOpMap[valueKind(data.a)], 6, 0, 0, ovfl };
+               var data struct {
+                       a uint;
+               }
+               instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uint", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uint a = %v not 17", data.a)
+                       t.Errorf("uint a = %v not 17", data.a);
                }
        }
 
        // int8
        {
-               var data struct { a int8 };
-               instr := &decInstr{ decInt8, 6, 0, 0, ovfl };
+               var data struct {
+                       a int8;
+               }
+               instr := &decInstr{decInt8, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(signedResult);
                execDec("int8", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("int8 a = %v not 17", data.a)
+                       t.Errorf("int8 a = %v not 17", data.a);
                }
        }
 
        // uint8
        {
-               var data struct { a uint8 };
-               instr := &decInstr{ decUint8, 6, 0, 0, ovfl };
+               var data struct {
+                       a uint8;
+               }
+               instr := &decInstr{decUint8, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uint8", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uint8 a = %v not 17", data.a)
+                       t.Errorf("uint8 a = %v not 17", data.a);
                }
        }
 
        // int16
        {
-               var data struct { a int16 };
-               instr := &decInstr{ decInt16, 6, 0, 0, ovfl };
+               var data struct {
+                       a int16;
+               }
+               instr := &decInstr{decInt16, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(signedResult);
                execDec("int16", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("int16 a = %v not 17", data.a)
+                       t.Errorf("int16 a = %v not 17", data.a);
                }
        }
 
        // uint16
        {
-               var data struct { a uint16 };
-               instr := &decInstr{ decUint16, 6, 0, 0, ovfl };
+               var data struct {
+                       a uint16;
+               }
+               instr := &decInstr{decUint16, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uint16", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uint16 a = %v not 17", data.a)
+                       t.Errorf("uint16 a = %v not 17", data.a);
                }
        }
 
        // int32
        {
-               var data struct { a int32 };
-               instr := &decInstr{ decInt32, 6, 0, 0, ovfl };
+               var data struct {
+                       a int32;
+               }
+               instr := &decInstr{decInt32, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(signedResult);
                execDec("int32", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("int32 a = %v not 17", data.a)
+                       t.Errorf("int32 a = %v not 17", data.a);
                }
        }
 
        // uint32
        {
-               var data struct { a uint32 };
-               instr := &decInstr{ decUint32, 6, 0, 0, ovfl };
+               var data struct {
+                       a uint32;
+               }
+               instr := &decInstr{decUint32, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uint32", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uint32 a = %v not 17", data.a)
+                       t.Errorf("uint32 a = %v not 17", data.a);
                }
        }
 
        // uintptr
        {
-               var data struct { a uintptr };
-               instr := &decInstr{ decOpMap[valueKind(data.a)], 6, 0, 0, ovfl };
+               var data struct {
+                       a uintptr;
+               }
+               instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uintptr", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uintptr a = %v not 17", data.a)
+                       t.Errorf("uintptr a = %v not 17", data.a);
                }
        }
 
        // int64
        {
-               var data struct { a int64 };
-               instr := &decInstr{ decInt64, 6, 0, 0, ovfl };
+               var data struct {
+                       a int64;
+               }
+               instr := &decInstr{decInt64, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(signedResult);
                execDec("int64", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("int64 a = %v not 17", data.a)
+                       t.Errorf("int64 a = %v not 17", data.a);
                }
        }
 
        // uint64
        {
-               var data struct { a uint64 };
-               instr := &decInstr{ decUint64, 6, 0, 0, ovfl };
+               var data struct {
+                       a uint64;
+               }
+               instr := &decInstr{decUint64, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(unsignedResult);
                execDec("uint64", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("uint64 a = %v not 17", data.a)
+                       t.Errorf("uint64 a = %v not 17", data.a);
                }
        }
 
        // float
        {
-               var data struct { a float };
-               instr := &decInstr{ decOpMap[valueKind(data.a)], 6, 0, 0, ovfl };
+               var data struct {
+                       a float;
+               }
+               instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
                state := newDecodeStateFromData(floatResult);
                execDec("float", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("float a = %v not 17", data.a)
+                       t.Errorf("float a = %v not 17", data.a);
                }
        }
 
        // float32
        {
-               var data struct { a float32 };
-               instr := &decInstr{ decFloat32, 6, 0, 0, ovfl };
+               var data struct {
+                       a float32;
+               }
+               instr := &decInstr{decFloat32, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(floatResult);
                execDec("float32", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("float32 a = %v not 17", data.a)
+                       t.Errorf("float32 a = %v not 17", data.a);
                }
        }
 
        // float64
        {
-               var data struct { a float64 };
-               instr := &decInstr{ decFloat64, 6, 0, 0, ovfl };
+               var data struct {
+                       a float64;
+               }
+               instr := &decInstr{decFloat64, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(floatResult);
                execDec("float64", instr, state, t, unsafe.Pointer(&data));
                if data.a != 17 {
-                       t.Errorf("float64 a = %v not 17", data.a)
+                       t.Errorf("float64 a = %v not 17", data.a);
                }
        }
 
        // bytes == []uint8
        {
-               var data struct { a []byte };
-               instr := &decInstr{ decUint8Array, 6, 0, 0, ovfl };
+               var data struct {
+                       a []byte;
+               }
+               instr := &decInstr{decUint8Array, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(bytesResult);
                execDec("bytes", instr, state, t, unsafe.Pointer(&data));
                if string(data.a) != "hello" {
-                       t.Errorf(`bytes a = %q not "hello"`, string(data.a))
+                       t.Errorf(`bytes a = %q not "hello"`, string(data.a));
                }
        }
 
        // string
        {
-               var data struct { a string };
-               instr := &decInstr{ decString, 6, 0, 0, ovfl };
+               var data struct {
+                       a string;
+               }
+               instr := &decInstr{decString, 6, 0, 0, ovfl};
                state := newDecodeStateFromData(bytesResult);
                execDec("bytes", instr, state, t, unsafe.Pointer(&data));
                if data.a != "hello" {
-                       t.Errorf(`bytes a = %q not "hello"`, data.a)
+                       t.Errorf(`bytes a = %q not "hello"`, data.a);
                }
        }
 }
 
 func TestEndToEnd(t *testing.T) {
        type T2 struct {
-               t string
+               t string;
        }
        s1 := "string1";
        s2 := "string2";
        type T1 struct {
-               a, b,c int;
-               n *[3]float;
-               strs *[2]string;
-               int64s *[]int64;
-               s string;
-               y []byte;
-               t *T2;
+               a, b, c int;
+               n       *[3]float;
+               strs    *[2]string;
+               int64s  *[]int64;
+               s       string;
+               y       []byte;
+               t       *T2;
        }
        t1 := &T1{
                a: 17,
@@ -580,82 +647,82 @@ func TestOverflow(t *testing.T) {
 
        // int8
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxi: math.MaxInt8 + 1,
        };
        type outi8 struct {
-               maxi int8;
-               mini int8;
+               maxi    int8;
+               mini    int8;
        }
        var o1 outi8;
        encode(b, it);
        err = decode(b, id, &o1);
        if err == nil || err.String() != `value for "maxi" out of range` {
-               t.Error("wrong overflow error for int8:", err)
+               t.Error("wrong overflow error for int8:", err);
        }
-       it = inputT {
+       it = inputT{
                mini: math.MinInt8 - 1,
        };
        b.Reset();
        encode(b, it);
        err = decode(b, id, &o1);
        if err == nil || err.String() != `value for "mini" out of range` {
-               t.Error("wrong underflow error for int8:", err)
+               t.Error("wrong underflow error for int8:", err);
        }
 
        // int16
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxi: math.MaxInt16 + 1,
        };
        type outi16 struct {
-               maxi int16;
-               mini int16;
+               maxi    int16;
+               mini    int16;
        }
        var o2 outi16;
        encode(b, it);
        err = decode(b, id, &o2);
        if err == nil || err.String() != `value for "maxi" out of range` {
-               t.Error("wrong overflow error for int16:", err)
+               t.Error("wrong overflow error for int16:", err);
        }
-       it = inputT {
+       it = inputT{
                mini: math.MinInt16 - 1,
        };
        b.Reset();
        encode(b, it);
        err = decode(b, id, &o2);
        if err == nil || err.String() != `value for "mini" out of range` {
-               t.Error("wrong underflow error for int16:", err)
+               t.Error("wrong underflow error for int16:", err);
        }
 
        // int32
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxi: math.MaxInt32 + 1,
        };
        type outi32 struct {
-               maxi int32;
-               mini int32;
+               maxi    int32;
+               mini    int32;
        }
        var o3 outi32;
        encode(b, it);
        err = decode(b, id, &o3);
        if err == nil || err.String() != `value for "maxi" out of range` {
-               t.Error("wrong overflow error for int32:", err)
+               t.Error("wrong overflow error for int32:", err);
        }
-       it = inputT {
+       it = inputT{
                mini: math.MinInt32 - 1,
        };
        b.Reset();
        encode(b, it);
        err = decode(b, id, &o3);
        if err == nil || err.String() != `value for "mini" out of range` {
-               t.Error("wrong underflow error for int32:", err)
+               t.Error("wrong underflow error for int32:", err);
        }
 
        // uint8
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxu: math.MaxUint8 + 1,
        };
        type outu8 struct {
@@ -665,12 +732,12 @@ func TestOverflow(t *testing.T) {
        encode(b, it);
        err = decode(b, id, &o4);
        if err == nil || err.String() != `value for "maxu" out of range` {
-               t.Error("wrong overflow error for uint8:", err)
+               t.Error("wrong overflow error for uint8:", err);
        }
 
        // uint16
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxu: math.MaxUint16 + 1,
        };
        type outu16 struct {
@@ -680,12 +747,12 @@ func TestOverflow(t *testing.T) {
        encode(b, it);
        err = decode(b, id, &o5);
        if err == nil || err.String() != `value for "maxu" out of range` {
-               t.Error("wrong overflow error for uint16:", err)
+               t.Error("wrong overflow error for uint16:", err);
        }
 
        // uint32
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxu: math.MaxUint32 + 1,
        };
        type outu32 struct {
@@ -695,31 +762,31 @@ func TestOverflow(t *testing.T) {
        encode(b, it);
        err = decode(b, id, &o6);
        if err == nil || err.String() != `value for "maxu" out of range` {
-               t.Error("wrong overflow error for uint32:", err)
+               t.Error("wrong overflow error for uint32:", err);
        }
 
        // float32
        b.Reset();
-       it = inputT {
+       it = inputT{
                maxf: math.MaxFloat32 * 2,
        };
        type outf32 struct {
-               maxf float32;
-               minf float32;
+               maxf    float32;
+               minf    float32;
        }
        var o7 outf32;
        encode(b, it);
        err = decode(b, id, &o7);
        if err == nil || err.String() != `value for "maxf" out of range` {
-               t.Error("wrong overflow error for float32:", err)
+               t.Error("wrong overflow error for float32:", err);
        }
 }
 
 
 func TestNesting(t *testing.T) {
        type RT struct {
-               a string;
-               next *RT
+               a       string;
+               next    *RT;
        }
        rt := new(RT);
        rt.a = "level1";
@@ -742,31 +809,37 @@ func TestNesting(t *testing.T) {
 
 // These three structures have the same data with different indirections
 type T0 struct {
-       a int;
-       b int;
-       c int;
-       d int;
+       a       int;
+       b       int;
+       c       int;
+       d       int;
 }
 type T1 struct {
-       a int;
-       b *int;
-       c **int;
-       d ***int;
+       a       int;
+       b       *int;
+       c       **int;
+       d       ***int;
 }
 type T2 struct {
-       a ***int;
-       b **int;
-       c *int;
-       d int;
+       a       ***int;
+       b       **int;
+       c       *int;
+       d       int;
 }
 
 func TestAutoIndirection(t *testing.T) {
        // First transfer t1 into t0
        var t1 T1;
        t1.a = 17;
-       t1.b = new(int); *t1.b = 177;
-       t1.c = new(*int); *t1.c = new(int); **t1.c = 1777;
-       t1.d = new(**int); *t1.d = new(*int); **t1.d = new(int); ***t1.d = 17777;
+       t1.b = new(int);
+       *t1.b = 177;
+       t1.c = new(*int);
+       *t1.c = new(int);
+       **t1.c = 1777;
+       t1.d = new(**int);
+       *t1.d = new(*int);
+       **t1.d = new(int);
+       ***t1.d = 17777;
        b := new(bytes.Buffer);
        encode(b, t1);
        var t0 T0;
@@ -779,9 +852,15 @@ func TestAutoIndirection(t *testing.T) {
        // Now transfer t2 into t0
        var t2 T2;
        t2.d = 17777;
-       t2.c = new(int); *t2.c = 1777;
-       t2.b = new(*int); *t2.b = new(int); **t2.b = 177;
-       t2.a = new(**int); *t2.a = new(*int); **t2.a = new(int); ***t2.a = 17;
+       t2.c = new(int);
+       *t2.c = 1777;
+       t2.b = new(*int);
+       *t2.b = new(int);
+       **t2.b = 177;
+       t2.a = new(**int);
+       *t2.a = new(*int);
+       **t2.a = new(int);
+       ***t2.a = 17;
        b.Reset();
        encode(b, t2);
        t0 = T0{};
@@ -825,15 +904,15 @@ func TestAutoIndirection(t *testing.T) {
 }
 
 type RT0 struct {
-       a int;
-       b string;
-       c float;
+       a       int;
+       b       string;
+       c       float;
 }
 type RT1 struct {
-       c float;
-       b string;
-       a int;
-       notSet string;
+       c       float;
+       b       string;
+       a       int;
+       notSet  string;
 }
 
 func TestReorderedFields(t *testing.T) {
@@ -854,15 +933,15 @@ func TestReorderedFields(t *testing.T) {
 
 // Like an RT0 but with fields we'll ignore on the decode side.
 type IT0 struct {
-       a int64;
-       b string;
-       ignore_d []int;
-       ignore_e [3]float;
-       ignore_f bool;
-       ignore_g string;
-       ignore_h []byte;
-       ignore_i *RT1;
-       c float;
+       a               int64;
+       b               string;
+       ignore_d        []int;
+       ignore_e        [3]float;
+       ignore_f        bool;
+       ignore_g        string;
+       ignore_h        []byte;
+       ignore_i        *RT1;
+       c               float;
 }
 
 func TestIgnoredFields(t *testing.T) {
@@ -870,14 +949,14 @@ func TestIgnoredFields(t *testing.T) {
        it0.a = 17;
        it0.b = "hello";
        it0.c = 3.14159;
-       it0.ignore_d = []int{ 1, 2, 3 };
-       it0.ignore_e[0]  = 1.0;
-       it0.ignore_e[1]  = 2.0;
-       it0.ignore_e[2]  = 3.0;
+       it0.ignore_d = []int{1, 2, 3};
+       it0.ignore_e[0] = 1.0;
+       it0.ignore_e[1] = 2.0;
+       it0.ignore_e[2] = 3.0;
        it0.ignore_f = true;
        it0.ignore_g = "pay no attention";
        it0.ignore_h = strings.Bytes("to the curtain");
-       it0.ignore_i = &RT1{ 3.1, "hi", 7, "hello" };
+       it0.ignore_i = &RT1{3.1, "hi", 7, "hello"};
 
        b := new(bytes.Buffer);
        encode(b, it0);
@@ -894,8 +973,8 @@ func TestIgnoredFields(t *testing.T) {
 }
 
 type Bad0 struct {
-       inter interface{};
-       c float;
+       inter   interface{};
+       c       float;
 }
 
 func TestInvalidField(t *testing.T) {
@@ -904,8 +983,8 @@ func TestInvalidField(t *testing.T) {
        b := new(bytes.Buffer);
        err := encode(b, &bad0);
        if err == nil {
-               t.Error("expected error; got none")
+               t.Error("expected error; got none");
        } else if strings.Index(err.String(), "interface") < 0 {
-               t.Error("expected type error; got", err)
+               t.Error("expected type error; got", err);
        }
 }

diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index f7cff583610b46b50b7d7daa813389389de7de88..48221f117fec70d03ad605e66a32e54f520b135e 100644 (file)
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -358,7 +358,7 @@ func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer,
        if indir > 0 {
                up := unsafe.Pointer(p);
                if indir > 1 {
-                       up = decIndirect(up, indir)
+                       up = decIndirect(up, indir);
                }
                if *(*unsafe.Pointer)(up) == nil {
                        // Allocate object by making a slice of bytes and recording the
@@ -579,9 +579,7 @@ func decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
                        if err != nil {
                                return nil, err;
                        }
-                       op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
-                               state.err = ignoreSlice(state, elemOp);
-                       };
+                       op = func(i *decInstr, state *decodeState, p unsafe.Pointer) { state.err = ignoreSlice(state, elemOp) };
 
                case *arrayType:
                        elemId := wireId.gobType().(*arrayType).Elem;

diff --git a/src/pkg/gob/encoder_test.go b/src/pkg/gob/encoder_test.go
index 9efd00a602fb9daf0e7f4528c72a2c9869e653c5..5f12b172f64a7909b4deec144fb8dae1ca8409df 100644 (file)
--- a/src/pkg/gob/encoder_test.go
+++ b/src/pkg/gob/encoder_test.go
@@ -17,23 +17,23 @@ type ET2 struct {
 }
 
 type ET1 struct {
-       a int;
-       et2 *ET2;
-       next *ET1;
+       a       int;
+       et2     *ET2;
+       next    *ET1;
 }
 
 // Like ET1 but with a different name for a field
 type ET3 struct {
-       a int;
-       et2 *ET2;
-       differentNext *ET1;
+       a               int;
+       et2             *ET2;
+       differentNext   *ET1;
 }
 
 // Like ET1 but with a different type for a field
 type ET4 struct {
-       a int;
-       et2 *ET1;
-       next int;
+       a       int;
+       et2     *ET1;
+       next    int;
 }
 
 func TestBasicEncoder(t *testing.T) {
@@ -44,7 +44,7 @@ func TestBasicEncoder(t *testing.T) {
        et1.et2 = new(ET2);
        enc.Encode(et1);
        if enc.state.err != nil {
-               t.Error("encoder fail:", enc.state.err)
+               t.Error("encoder fail:", enc.state.err);
        }
 
        // Decode the result by hand to verify;
@@ -114,14 +114,14 @@ func TestBasicEncoder(t *testing.T) {
        }
        // 9) EOF
        if b.Len() != 0 {
-               t.Error("not at eof;", b.Len(), "bytes left")
+               t.Error("not at eof;", b.Len(), "bytes left");
        }
 
        // Now do it again. This time we should see only the type id and value.
        b.Reset();
        enc.Encode(et1);
        if enc.state.err != nil {
-               t.Error("2nd round: encoder fail:", enc.state.err)
+               t.Error("2nd round: encoder fail:", enc.state.err);
        }
        // The length.
        length = decodeUint(state);
@@ -144,7 +144,7 @@ func TestBasicEncoder(t *testing.T) {
        }
        // 7a) EOF
        if b.Len() != 0 {
-               t.Error("2nd round: not at eof;", b.Len(), "bytes left")
+               t.Error("2nd round: not at eof;", b.Len(), "bytes left");
        }
 }
 
@@ -156,7 +156,7 @@ func TestEncoderDecoder(t *testing.T) {
        et1.et2 = new(ET2);
        enc.Encode(et1);
        if enc.state.err != nil {
-               t.Error("encoder fail:", enc.state.err)
+               t.Error("encoder fail:", enc.state.err);
        }
        dec := NewDecoder(b);
        newEt1 := new(ET1);
@@ -169,7 +169,7 @@ func TestEncoderDecoder(t *testing.T) {
                t.Fatalf("invalid data for et1: expected %+v; got %+v\n", *et1, *newEt1);
        }
        if b.Len() != 0 {
-               t.Error("not at eof;", b.Len(), "bytes left")
+               t.Error("not at eof;", b.Len(), "bytes left");
        }
 
        enc.Encode(et1);
@@ -182,13 +182,13 @@ func TestEncoderDecoder(t *testing.T) {
                t.Fatalf("round 2: invalid data for et1: expected %+v; got %+v\n", *et1, *newEt1);
        }
        if b.Len() != 0 {
-               t.Error("round 2: not at eof;", b.Len(), "bytes left")
+               t.Error("round 2: not at eof;", b.Len(), "bytes left");
        }
 
        // Now test with a running encoder/decoder pair that we recognize a type mismatch.
        enc.Encode(et1);
        if enc.state.err != nil {
-               t.Error("round 3: encoder fail:", enc.state.err)
+               t.Error("round 3: encoder fail:", enc.state.err);
        }
        newEt2 := new(ET2);
        dec.Decode(newEt2);
@@ -207,7 +207,7 @@ func badTypeCheck(e interface{}, shouldFail bool, msg string, t *testing.T) {
        et1.et2 = new(ET2);
        enc.Encode(et1);
        if enc.state.err != nil {
-               t.Error("encoder fail:", enc.state.err)
+               t.Error("encoder fail:", enc.state.err);
        }
        dec := NewDecoder(b);
        dec.Decode(e);
@@ -244,15 +244,15 @@ func TestBadData(t *testing.T) {
 
 // Types not supported by the Encoder (only structs work at the top level).
 // Basic types work implicitly.
-var unsupportedValues = []interface{} {
+var unsupportedValues = []interface{}{
        3,
        "hi",
        7.2,
-       []int{ 1, 2, 3 },
-       [3]int{ 1, 2, 3 },
+       []int{1, 2, 3},
+       [3]int{1, 2, 3},
        make(chan int),
        func(a int) bool { return true },
-       make(map[string] int),
+       make(map[string]int),
        new(interface{}),
 }
 
@@ -262,7 +262,7 @@ func TestUnsupported(t *testing.T) {
        for _, v := range unsupportedValues {
                err := enc.Encode(v);
                if err == nil {
-                       t.Errorf("expected error for %T; got none", v)
+                       t.Errorf("expected error for %T; got none", v);
                }
        }
 }
@@ -272,39 +272,45 @@ func encAndDec(in, out interface{}) os.Error {
        enc := NewEncoder(b);
        enc.Encode(in);
        if enc.state.err != nil {
-               return enc.state.err
+               return enc.state.err;
        }
        dec := NewDecoder(b);
        dec.Decode(out);
        if dec.state.err != nil {
-               return dec.state.err
+               return dec.state.err;
        }
        return nil;
 }
 
 func TestTypeToPtrType(t *testing.T) {
        // Encode a T, decode a *T
-       type Type0 struct { a int }
+       type Type0 struct {
+               a int;
+       }
        t0 := Type0{7};
        t0p := (*Type0)(nil);
        if err := encAndDec(t0, t0p); err != nil {
-               t.Error(err)
+               t.Error(err);
        }
 }
 
 func TestPtrTypeToType(t *testing.T) {
        // Encode a *T, decode a T
-       type Type1 struct { a uint }
+       type Type1 struct {
+               a uint;
+       }
        t1p := &Type1{17};
        var t1 Type1;
        if err := encAndDec(t1, t1p); err != nil {
-               t.Error(err)
+               t.Error(err);
        }
 }
 
 func TestTypeToPtrPtrPtrPtrType(t *testing.T) {
        // Encode a *T, decode a T
-       type Type2 struct { a ****float }
+       type Type2 struct {
+               a ****float;
+       }
        t2 := Type2{};
        t2.a = new(***float);
        *t2.a = new(**float);
@@ -313,7 +319,7 @@ func TestTypeToPtrPtrPtrPtrType(t *testing.T) {
        ****t2.a = 27.4;
        t2pppp := new(***Type2);
        if err := encAndDec(t2, t2pppp); err != nil {
-               t.Error(err)
+               t.Error(err);
        }
        if ****(****t2pppp).a != ****t2.a {
                t.Errorf("wrong value after decode: %g not %g", ****(****t2pppp).a, ****t2.a);