test(core/types): use methodless Body as gold-standard + add test for empty, non-nil optional slice

Author: ARR4N

core/types/rlp_backwards_compat.libevm_test.go

@@ -17,9 +17,11 @@
 package types_test
 
 import (
+	"bytes"
 	"encoding/hex"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -133,40 +135,71 @@ func TestBodyRLPBackwardsCompatibility(t *testing.T) {
 	tests := []struct {
 		name        string
 		withdrawals []*Withdrawal
-		// WARNING: changing these hex values might break backwards
-		// compatibility of RLP encoding!
-		wantHex string
 	}{
 		{
-			name:    "without_Withdrawals",
-			wantHex: `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`,
+			name: "with_nil_Withdrawals",
+		},
+		{
+			name: "with_empty_Withdrawals",
+			// As the struct field has an `rlp:"optional"` tag, we need to
+			// differentiate between nil (nothing added to RLP) and an empty
+			// slice (empty list added to RLP).
+			withdrawals: []*Withdrawal{},
 		},
 		{
 			name:        "with_Withdrawals",
 			withdrawals: withdrawals,
-			wantHex:     `f90418d2d1884d98b91b8d3568708080808080808080f903e0f901eda093449fc540c83e70fa443a4b915449e55e28b904f20f13961ab2ce35f5de9f7da00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000808080808080a00000000000000000000000000000000000000000000000000000000000000000880000000000000000f901eda0a019122ed4ee6f666f32c82157681f98da4dab6e0d7180ad29a037b080c402e2a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000808080808080a00000000000000000000000000000000000000000000000000000000000000000880000000000000000e1e0880756befb39c6b8aa8094000000000000000000000000000000000000000080`,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			body.Withdrawals = tt.withdrawals
 
-			wantRLP, err := hex.DecodeString(tt.wantHex)
-			require.NoError(t, err, "hex.DecodeString()")
+			// The originaly [Body] doesn't implement [rlp.Encoder] nor
+			// [rlp.Decoder] so we can use a methodless equivalent as gold
+			// standard.
+			type withoutMethods Body
+			wantRLP, err := rlp.EncodeToBytes((*withoutMethods)(body))
+			require.NoErrorf(t, err, "rlp.EncodeToBytes([%T with methods stripped])", body)
 
 			t.Run("Encode", func(t *testing.T) {
 				got, err := rlp.EncodeToBytes(body)
 				require.NoErrorf(t, err, "rlp.EncodeToBytes(%T)", body)
-				t.Logf("got RLP: %#x", got)
 				assert.Equalf(t, wantRLP, got, "rlp.EncodeToBytes(%T)", body)
 			})
 
 			t.Run("Decode", func(t *testing.T) {
 				got := new(Body)
 				err := rlp.DecodeBytes(wantRLP, got)
 				require.NoErrorf(t, err, "rlp.DecodeBytes(..., %T)", got)
+
+				opts := cmp.Options{
+					cmp.Comparer(func(a, b *Header) bool {
+						return a.Hash() == b.Hash()
+					}),
+					cmp.Comparer(txComparer(t)),
+				}
+				if diff := cmp.Diff(body, got, opts); diff != "" {
+					t.Errorf("rlp.DecodeBytes(rlp.EncodeToBytes(%T)) diff (-want +got):\n%s", body, diff)
+				}
 			})
 		})
 	}
 }
+
+func txComparer(tb testing.TB) func(_, _ *Transaction) bool {
+	return func(a, b *Transaction) bool {
+		if a == nil && b == nil {
+			return true
+		}
+		if a == nil || b == nil {
+			return false
+		}
+		aBuf, err := a.MarshalBinary()
+		require.NoErrorf(tb, err, "%T.MarshalBinary()", a)
+		bBuf, err := b.MarshalBinary()
+		require.NoErrorf(tb, err, "%T.MarshalBinary()", b)
+		return bytes.Equal(aBuf, bBuf)
+	}
+}