diff options
author | Robert Griesemer <gri@golang.org> | 2009-11-05 14:53:42 -0800 |
---|---|---|
committer | Robert Griesemer <gri@golang.org> | 2009-11-05 14:53:42 -0800 |
commit | 78bf13b8de900438976cf897675518b61ba3881d (patch) | |
tree | 3fe13dc1e54b17cfde23a61dc545d4dafd9f4e53 /src/pkg/gob | |
parent | b1fa00c84cf18841d97428d77664122bffa8cf10 (diff) | |
download | go-78bf13b8de900438976cf897675518b61ba3881d.tar.gz |
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
Diffstat (limited to 'src/pkg/gob')
-rw-r--r-- | src/pkg/gob/codec_test.go | 499 | ||||
-rw-r--r-- | src/pkg/gob/decode.go | 6 | ||||
-rw-r--r-- | src/pkg/gob/encoder_test.go | 68 |
3 files changed, 328 insertions, 245 deletions
diff --git a/src/pkg/gob/codec_test.go b/src/pkg/gob/codec_test.go index 3c75e4f85..745f2c0de 100644 --- 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 f7cff5836..48221f117 100644 --- 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 9efd00a60..5f12b172f 100644 --- 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); |