mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
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
This commit is contained in:
Robert Griesemer
parent
790c9b59d6
commit
f65e42d039
3 changed files with 328 additions and 245 deletions
|
|
@ -19,6 +19,7 @@ type EncodeT struct {
|
|||
x uint64;
|
||||
b []byte;
|
||||
}
|
||||
|
||||
var encodeT = []EncodeT{
|
||||
EncodeT{0x00, []byte{0x00}},
|
||||
EncodeT{0x0F, []byte{0x0F}},
|
||||
|
|
@ -46,10 +47,10 @@ 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);
|
||||
|
|
@ -57,17 +58,17 @@ func TestUintCodec(t *testing.T) {
|
|||
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
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -78,16 +79,16 @@ 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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -100,7 +101,7 @@ func TestIntCodec(t *testing.T) {
|
|||
verifyInt(-i, t);
|
||||
verifyInt(^i, t);
|
||||
if u&(1<<63) != 0 {
|
||||
break
|
||||
break;
|
||||
}
|
||||
}
|
||||
verifyInt(-1 << 63, t); // a tricky case
|
||||
|
|
@ -130,192 +131,224 @@ func TestScalarEncInstructions(t *testing.T) {
|
|||
|
||||
// bool
|
||||
{
|
||||
data := struct { a bool } { true };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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") };
|
||||
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" };
|
||||
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,194 +378,228 @@ func TestScalarDecInstructions(t *testing.T) {
|
|||
|
||||
// bool
|
||||
{
|
||||
var data struct { a bool };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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 };
|
||||
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";
|
||||
|
|
@ -591,7 +658,7 @@ func TestOverflow(t *testing.T) {
|
|||
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{
|
||||
mini: math.MinInt8 - 1,
|
||||
|
|
@ -600,7 +667,7 @@ func TestOverflow(t *testing.T) {
|
|||
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
|
||||
|
|
@ -616,7 +683,7 @@ func TestOverflow(t *testing.T) {
|
|||
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{
|
||||
mini: math.MinInt16 - 1,
|
||||
|
|
@ -625,7 +692,7 @@ func TestOverflow(t *testing.T) {
|
|||
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
|
||||
|
|
@ -641,7 +708,7 @@ func TestOverflow(t *testing.T) {
|
|||
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{
|
||||
mini: math.MinInt32 - 1,
|
||||
|
|
@ -650,7 +717,7 @@ func TestOverflow(t *testing.T) {
|
|||
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
|
||||
|
|
@ -665,7 +732,7 @@ 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
|
||||
|
|
@ -680,7 +747,7 @@ 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
|
||||
|
|
@ -695,7 +762,7 @@ 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
|
||||
|
|
@ -711,7 +778,7 @@ func TestOverflow(t *testing.T) {
|
|||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -719,7 +786,7 @@ func TestOverflow(t *testing.T) {
|
|||
func TestNesting(t *testing.T) {
|
||||
type RT struct {
|
||||
a string;
|
||||
next *RT
|
||||
next *RT;
|
||||
}
|
||||
rt := new(RT);
|
||||
rt.a = "level1";
|
||||
|
|
@ -764,9 +831,15 @@ 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{};
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue