You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by xu...@apache.org on 2026/08/09 12:20:23 UTC

(dubbo-go) branch develop updated: test(protocol/triple): add unit tests for hessian2Codec and msgpackCodec (#3627)

This is an automated email from the ASF dual-hosted git repository.

Alanxtl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git


The following commit(s) were added to refs/heads/develop by this push:
     new 2edb07e42 test(protocol/triple): add unit tests for hessian2Codec and msgpackCodec (#3627)
2edb07e42 is described below

commit 2edb07e4292b377d0456922d0890ab9857beb163
Author: Yash Israni <11...@users.noreply.github.com>
AuthorDate: Sun Aug 9 17:50:18 2026 +0530

    test(protocol/triple): add unit tests for hessian2Codec and msgpackCodec (#3627)
    
    Signed-off-by: Yash Israni <11...@users.noreply.github.com>
---
 protocol/triple/triple_protocol/codec_test.go | 234 ++++++++++++++++++++++++--
 1 file changed, 222 insertions(+), 12 deletions(-)

diff --git a/protocol/triple/triple_protocol/codec_test.go b/protocol/triple/triple_protocol/codec_test.go
index d8d4ff0bf..b9b1dc025 100644
--- a/protocol/triple/triple_protocol/codec_test.go
+++ b/protocol/triple/triple_protocol/codec_test.go
@@ -123,16 +123,226 @@ func TestJSONCodec(t *testing.T) {
 func TestMsgpackCodec(t *testing.T) {
 	t.Parallel()
 
-	want := &pingv1.PingRequest{
-		Number: 1234,
-		Text:   "5678",
-	}
-	codec := &msgpackCodec{}
-	binary, err := codec.Marshal(want)
-	assert.Nil(t, err)
-	var got pingv1.PingRequest
-	err = codec.Unmarshal(binary, &got)
-	assert.Nil(t, err)
-	assert.Equal(t, got.Number, want.Number)
-	assert.Equal(t, got.Text, want.Text)
+	t.Run("roundtrip proto message", func(t *testing.T) {
+		t.Parallel()
+		want := &pingv1.PingRequest{
+			Number: 1234,
+			Text:   "5678",
+		}
+		codec := &msgpackCodec{}
+		binary, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got pingv1.PingRequest
+		err = codec.Unmarshal(binary, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, got.Number, want.Number)
+		assert.Equal(t, got.Text, want.Text)
+	})
+
+	t.Run("name returns msgpack", func(t *testing.T) {
+		t.Parallel()
+		codec := &msgpackCodec{}
+		assert.Equal(t, codecNameMsgPack, codec.Name())
+	})
+
+	t.Run("marshal nil returns empty bytes", func(t *testing.T) {
+		t.Parallel()
+		codec := &msgpackCodec{}
+		data, err := codec.Marshal(nil)
+		assert.Nil(t, err)
+		assert.Equal(t, []byte{0xc0}, data)
+	})
+
+	t.Run("unmarshal into nil returns error", func(t *testing.T) {
+		t.Parallel()
+		codec := &msgpackCodec{}
+		err := codec.Unmarshal([]byte{0xc0}, nil)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("unmarshal invalid data returns error", func(t *testing.T) {
+		t.Parallel()
+		codec := &msgpackCodec{}
+		var got pingv1.PingRequest
+		err := codec.Unmarshal([]byte{0xff, 0xff, 0xff}, &got)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("roundtrip with empty string", func(t *testing.T) {
+		t.Parallel()
+		want := &pingv1.PingRequest{Text: "", Number: 0}
+		codec := &msgpackCodec{}
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got pingv1.PingRequest
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.True(t, proto.Equal(&got, want))
+	})
+}
+
+func TestHessian2Codec(t *testing.T) {
+	t.Parallel()
+
+	t.Run("name returns hessian2", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		assert.Equal(t, codecNameHessian2, codec.Name())
+	})
+
+	t.Run("roundtrip string", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := "hello dubbo-go"
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got string
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip int32", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := int32(42)
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got int32
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip int64", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := int64(9223372036854775807)
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got int64
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip bool true", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := true
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got bool
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.True(t, got)
+	})
+
+	t.Run("roundtrip bool false", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := false
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got bool
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.False(t, got)
+	})
+
+	t.Run("roundtrip byte slice", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := []byte{0x01, 0x02, 0x03, 0x04}
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got []byte
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip map", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := map[any]any{"key1": "value1", "key2": int64(42)}
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		got := make(map[any]any)
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip string slice", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := []string{"a", "b", "c"}
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got []string
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("marshal nil returns nil bytes", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		data, err := codec.Marshal(nil)
+		assert.Nil(t, err)
+		assert.Equal(t, []byte{'N'}, data)
+	})
+
+	t.Run("unmarshal into non-pointer returns error", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		var got string
+		err := codec.Unmarshal([]byte{'N'}, got)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("unmarshal nil pointer returns error", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		var got *string
+		err := codec.Unmarshal([]byte{'N'}, got)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("unmarshal into nil returns error", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		err := codec.Unmarshal([]byte{'N'}, nil)
+		assert.NotNil(t, err)
+	})
+
+	t.Run("roundtrip empty string", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := ""
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		var got string
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, want, got)
+	})
+
+	t.Run("roundtrip empty map", func(t *testing.T) {
+		t.Parallel()
+		codec := &hessian2Codec{}
+		want := map[string]string{}
+		data, err := codec.Marshal(want)
+		assert.Nil(t, err)
+		got := make(map[string]string)
+		err = codec.Unmarshal(data, &got)
+		assert.Nil(t, err)
+		assert.Equal(t, len(want), len(got))
+	})
+
+	t.Run("implements Codec interface", func(t *testing.T) {
+		t.Parallel()
+		var _ Codec = (*hessian2Codec)(nil)
+	})
 }