コード例 #1
0
func encode_door(t *testing.T, wr *stream.Stream) {
	wr.SetSize(0)
	wr.Seek(0, 0)
	e := binutil.NewProtobufEncoder(wr)
	door := comp
	e.PutInt32(1, door.I32)
	e.PutInt64(2, door.I64)
	e.PutSint32(3, door.S32)
	e.PutSint64(4, door.S64)
	e.PutSfixed32(5, door.D32)
	e.PutSfixed64(6, door.D64)
	e.PutUint32(10, door.U32)
	e.PutUint64(11, door.U64)
	e.PutFixed32(12, door.X32)
	e.PutFixed64(13, door.X64)
	e.PutFloat32(20, door.F32)
	e.PutFloat64(21, door.F64)
	e.PutBool(30, door.B)
	e.PutString(31, door.S)
	e.PutEnum(32, door.E)
	encode_pos(dm, &door.Poslist[0])
	e.PutBytes(40, dm.Buf()[:dm.Position()])
	encode_pos(dm, &door.Poslist[1])
	e.PutBytes(40, dm.Buf()[:dm.Position()])
}
コード例 #2
0
func encode_pos(wr *stream.Stream, pos *pbPos) {
	wr.SetSize(0)
	wr.Seek(0, 0)
	e := binutil.NewProtobufEncoder(wr)
	e.PutInt32(1, pos.X)
	e.PutInt32(2, pos.Y)
}
コード例 #3
0
func decode_door(t *testing.T, rd *stream.Stream, last int, door *pbDoor) {
	rd.Seek(0, 0)
	d := binutil.NewProtobufDecoder(rd)
	posidx := 0
	for rd.Position() < last {
		_, tag, wire, _ := d.Tag()
		switch tag {
		case 0:
			t.Fatalf("test protobuf decode: got tag 0 when parse door\n")
		case 1:
			_, door.I32, _ = d.Int32()
		case 3:
			_, door.S32, _ = d.Sint32()
		case 5:
			_, door.D32, _ = d.Sfixed32()
		case 2:
			_, door.I64, _ = d.Int64()
		case 4:
			_, door.S64, _ = d.Sint64()
		case 6:
			_, door.D64, _ = d.Sfixed64()

		case 10:
			_, door.U32, _ = d.Uint32()
		case 12:
			_, door.X32, _ = d.Fixed32()
		case 11:
			_, door.U64, _ = d.Uint64()
		case 13:
			_, door.X64, _ = d.Fixed64()

		case 20:
			_, door.F32, _ = d.Float32()
		case 21:
			_, door.F64, _ = d.Float64()

		case 30:
			_, door.B, _ = d.Bool()
		case 31:
			_, door.S, _ = d.String()
		case 32:
			_, door.E, _ = d.Enum()
		case 40:
			_, u, _ := d.Uint64()
			m, L := int64(u), int(u)
			dm.SetSize(m)
			d.GetBody(dm.Buf()[:m])
			decode_pos(t, dm, L, &door.Poslist[posidx])
			if dm.Position() != L {
				t.Fatalf("test protobuf decode: got pos fail\n")
			}
			posidx++
		default:
			d.Skip(wire)
		}
	}
	if rd.Position() != last {
		t.Fatalf("test protobuf decode: parse pos, error tail position\n")
	}
}
コード例 #4
0
func testByteOrder(t *testing.T, s *stream.Stream, in *byteorderSample) {
	s.SetSize(256)
	s.Seek(0, 0)
	data := s.Buf()
	whint := in.order.String()
	var m, n int
	m = in.order.PutUint8(data, byte(0x09))
	n = in.order.PutUint32(data[m:], uint32(0x1310))
	n += m
	L := len(in.output)
	if n != L {
		t.Fatalf("%s: outsize must %v, but got %v\n", whint, L, n)
	}
	for i, b := range in.output {
		if b != data[i] {
			t.Fatalf("%s: output[%d] must %2X, but got %2X\n", whint, i, b, data[i])
		}
	}
	for _, read := range in.reads {
		s.Seek(0, 0)
		rhint := read.order.String()
		var b byte
		var i uint32
		b, m = read.order.Uint8(data)
		i, n = read.order.Uint32(data[m:])
		n += m
		if n != L {
			t.Errorf("%s: read by %s: final position must be %v, but got %v\n", whint, rhint, L, n)
		} else if b != read.b {
			t.Errorf("%s: read by %s: expect %.2X, but got %.2X\n", whint, rhint, read.b, b)
		} else if i != read.i {
			t.Errorf("%s: read by %s: expect %.8X, but got %.8X\n", whint, rhint, read.i, i)
		}
	}
}
コード例 #5
0
func testMarshal(t *testing.T, s *stream.Stream, in *marshalTestData) {
	var dummy = &datatype{}
	var n int
	var err error

	// println("*** encoding ***")
	s.SetSize(0)
	w := binutil.NewEncoder2(s, in.order, in.intNs)
	hint := w.String()
	n, err = w.Write(in.data)
	if err != nil {
		t.Errorf("encode(%s) error: %v\n", hint, err)
	}
	if n != in.outsize {
		t.Errorf("encode(%s) size must %v, but got %v\n", hint, in.outsize, n)
	}
	n = len(in.out)
	if n != in.outsize {
		t.Errorf("encode(%s) len(test) must %v, but got %v\n", hint, in.outsize, n)
	}
	b := s.Buf()
	n = len(b)
	if n != in.outsize {
		t.Errorf("encode(%s) len(dump) must %v, but got %v\n", hint, in.outsize, n)
	}
	for i, v := range in.out {
		if v != b[i] {
			t.Fatalf("marshal(%s) out[%v] must %2X, but got %2X\n", hint, i, v, b[i])
		}
	}
	//*
	// println("*** decoding ***")
	s.Seek(0, 0)
	r := binutil.NewDecoder2(s, in.order, in.intNs)
	n, err = r.Read(dummy)
	if err != nil {
		t.Errorf("decode(%s) error: %v\n", hint, err)
	}
	if n != in.outsize {
		t.Errorf("decode(%s) size must %v, but got %v\n", hint, in.outsize, n)
	}
	if !DeepEqual(in.data, dummy) {
		t.Fatalf("decode(%s) DeepEqual false\n", hint)
	}
	//*/
}
コード例 #6
0
func testSeekAndReadByte(t *testing.T, s *stream.Stream, off int64, whence int, want_err error, want rune) {
	var (
		err error
		msg string
		b   byte
		c   rune
	)
	msg = fmt.Sprintf("Seek(%d, %d),", off, whence)
	_, err = s.Seek(off, whence)
	if err != want_err {
		t.Errorf("%s want error `%v`, but got `%v`\n", msg, want_err, err)
		return
	}
	b, _ = s.ReadByte()
	c = rune(b)
	if c != want {
		t.Errorf("%s ReadByte() is `%c`, want `%c`\n", msg, c, want)
	}
}
コード例 #7
0
func decode_pos(t *testing.T, rd *stream.Stream, last int, pos *pbPos) {
	rd.Seek(0, 0)
	d := binutil.NewProtobufDecoder(rd)
	for rd.Position() < last {
		_, tag, wire, _ := d.Tag()
		switch tag {
		case 0:
			t.Fatalf("test protobuf decode: got tag 0 when parse pos\n")
		case 1:
			_, pos.X, _ = d.Int32()
		case 2:
			_, pos.Y, _ = d.Int32()
		default:
			d.Skip(wire)
		}
	}
	if rd.Position() != last {
		t.Fatalf("test protobuf decode: parse pos, error tail position\n")
	}
}