decoder

Author: fanweixiao

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 fanweixiao
+Copyright (c) 2021 CELLA
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

pkg/spec/decode.go

@@ -45,14 +45,6 @@ func FromBytes(buf []byte) (p *Packet, err error) {
 	return p, nil
 }
 
-// GetValueAsUInt32 decode value as uint32
-func (p *Packet) GetValueAsUInt32() (uint32, error) {
-	var val uint32
-	codec := encoding.VarCodec{}
-	err := codec.DecodePVarUInt32(p.valbuf, &val)
-	return val, err
-}
-
 func readTag(buffer []byte, position int, val *uint64) (cursor int, err error) {
 	cursor, err = readPVarUInt64(buffer, position, val)
 	return cursor, err
@@ -83,3 +75,70 @@ func readPVarUInt64(buffer []byte, position int, val *uint64) (cursor int, err e
 	err = codec.DecodePVarUInt64(bytes, val)
 	return cursor + position, err
 }
+
+// GetValueAsUInt32 decode value as uint32
+func (p *Packet) GetValueAsUInt32() (uint32, error) {
+	var val uint32
+	codec := encoding.VarCodec{}
+	err := codec.DecodePVarUInt32(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsInt32 decode value as int32
+func (p *Packet) GetValueAsInt32() (int32, error) {
+	var val int32
+	codec := encoding.VarCodec{}
+	err := codec.DecodePVarInt32(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsUInt64 decode value as uint64
+func (p *Packet) GetValueAsUInt64() (uint64, error) {
+	var val uint64
+	codec := encoding.VarCodec{}
+	err := codec.DecodePVarUInt64(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsInt64 decode value as int64
+func (p *Packet) GetValueAsInt64() (int64, error) {
+	var val int64
+	codec := encoding.VarCodec{}
+	err := codec.DecodePVarInt64(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsFloat32 decode value as uint32
+func (p *Packet) GetValueAsFloat32() (float32, error) {
+	var val float32
+	codec := encoding.VarCodec{Size: p.Length}
+	err := codec.DecodeVarFloat32(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsBool decode value as bool
+func (p *Packet) GetValueAsBool() (bool, error) {
+	res, err := p.GetValueAsUInt64()
+	if res == 1 {
+		return true, err
+	}
+	return false, err
+}
+
+// GetValueAsFloat64 decode value as float64
+func (p *Packet) GetValueAsFloat64() (float64, error) {
+	var val float64
+	codec := encoding.VarCodec{Size: p.Length}
+	err := codec.DecodeVarFloat64(p.valbuf, &val)
+	return val, err
+}
+
+// GetValueAsUTF8String decode value as float32
+func (p *Packet) GetValueAsUTF8String() string {
+	return string(p.valbuf)
+}
+
+// GetValueAsRawBytes decode value as float32
+func (p *Packet) GetValueAsRawBytes() []byte {
+	return p.valbuf
+}

pkg/spec/encode_test.go

@@ -4,6 +4,37 @@ import (
 	"testing"
 )
 
+func TestV2Tag(t *testing.T) {
+	testV2Tags(t, 0x05, []byte{0x05})
+	testV2Tags(t, 0x3F, []byte{0x3F})
+	testV2Tags(t, 0x7F, []byte{0x80, 0x7F})
+	testV2Tags(t, 0xFF, []byte{0x81, 0x7F})
+	testV2Tags(t, 0xFFFF, []byte{0x83, 0xFF, 0x7F})
+	testV2Tags(t, 0xFFFFFF, []byte{0x87, 0xFF, 0xFF, 0x7F})
+}
+
+func TestV2AddNode(t *testing.T) {
+	parent, _ := NewPacket(0x01)
+
+	child1, _ := NewPacket(0x02)
+	child1.SetUInt32(3)
+
+	parent.AddNode(child1)
+	compareBytes(t, parent, []byte{0x01, 0x03, 0x02, 0x01, 0x03})
+
+	child2, _ := NewPacket(0x03)
+	child2.SetFloat64(0.01171875)
+
+	parent.AddNode(child2)
+	compareBytes(t, parent, []byte{0x01, 0x07, 0x02, 0x01, 0x03, 0x03, 0x02, 0x3F, 0x88})
+
+	child3, _ := NewPacket(0x04)
+	child3.SetFloat32(68.123)
+
+	parent.AddNode(child3)
+	compareBytes(t, parent, []byte{0x01, 0x0D, 0x02, 0x01, 0x03, 0x03, 0x02, 0x3F, 0x88, 0x04, 0x04, 0x42, 0x88, 0x3E, 0xFA})
+}
+
 func TestFromBytes(t *testing.T) {
 	testFromBytes(t, []byte{0x03, 0x01, 0x02}, &Packet{Tag: 3, Length: 1, valbuf: []byte{0x02}})
 	testFromBytes(t, []byte{0x81, 0x03, 0x01, 0x06}, &Packet{Tag: 131, Length: 1, valbuf: []byte{0x06}})
@@ -14,25 +45,6 @@ func TestFromBytes(t *testing.T) {
 	testFromBytes(t, buf, &Packet{Tag: 131, Length: 129, valbuf: foo})
 }
 
-func testFromBytes(t *testing.T, buffer []byte, expected *Packet) {
-	res, err := FromBytes(buffer)
-	if err != nil {
-		t.Error(err)
-	} else {
-		if res.Tag != expected.Tag {
-			t.Errorf("Tag expected=[% X], actual=[% X]", expected.Tag, res.Tag)
-		}
-		if res.Length != expected.Length {
-			t.Errorf("Length expected=[% X], actual=[% X]", expected.Length, res.Length)
-		}
-		for i := range res.valbuf {
-			if res.valbuf[i] != expected.valbuf[i] {
-				t.Errorf("valbuf on [%d] expected=[% X], actual=[% X]", i, expected.valbuf[i], res.valbuf[i])
-			}
-		}
-	}
-}
-
 func TestReadTag(t *testing.T) {
 	testReadTag(t, []byte{0x03, 0x01, 0x02}, 0, 3, 1)
 	testReadTag(t, []byte{0xFF, 0x04, 0x01, 0x02}, 1, 4, 2)
@@ -74,11 +86,45 @@ func testReadLength(t *testing.T, buffer []byte, position int, expectValue uint6
 	}
 }
 
-func TestGetValueAsUInt32(t *testing.T) {
-	buf := []byte{0x03, 0x01, 0x02}
-	p, _ := FromBytes(buf)
-	actual, _ := p.GetValueAsUInt32()
-	if actual != 2 {
-		t.Errorf("expect=%d, actual=%d", 2, actual)
+func testFromBytes(t *testing.T, buffer []byte, expected *Packet) {
+	res, err := FromBytes(buffer)
+	if err != nil {
+		t.Error(err)
+	} else {
+		if res.Tag != expected.Tag {
+			t.Errorf("Tag expected=[% X], actual=[% X]", expected.Tag, res.Tag)
+		}
+		if res.Length != expected.Length {
+			t.Errorf("Length expected=[% X], actual=[% X]", expected.Length, res.Length)
+		}
+		for i := range res.valbuf {
+			if res.valbuf[i] != expected.valbuf[i] {
+				t.Errorf("valbuf on [%d] expected=[% X], actual=[% X]", i, expected.valbuf[i], res.valbuf[i])
+			}
+		}
+	}
+}
+
+func testV2Tags(t *testing.T, id uint64, expected []byte) {
+	p, err := NewPacket(id)
+	if err != nil {
+		t.Errorf("TestV2Tag err=%v", err)
+	}
+	p.SetInt32(0)
+	expected = append(expected, []byte{0x01, 0x00}...)
+	compareBytes(t, p, expected)
+}
+
+func compareBytes(t *testing.T, p *Packet, expected []byte) []byte {
+	result, err := p.Encode()
+	if err != nil {
+		t.Errorf("compareBytes error=%v", err)
+	}
+	for i, p := range result {
+		if p != expected[i] {
+			t.Errorf("\nexpected:[% X]\n  actual:[% X]\n", expected, result)
+			break
+		}
 	}
+	return result
 }