github.com/gnolang/gno@v0.0.0-20240520182011-228e9d0192ce/tm2/pkg/amino/repr_test.go (about)

     1  package amino
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/gnolang/gno/tm2/pkg/amino/pkg"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  type FooList []*Foo
    13  
    14  type Foo struct {
    15  	a string
    16  	b int32
    17  	c []*Foo
    18  	D string // exposed
    19  }
    20  
    21  type pair struct {
    22  	Key   string
    23  	Value interface{}
    24  }
    25  
    26  func (pr pair) get(key string) (value interface{}) {
    27  	if pr.Key != key {
    28  		panic(fmt.Sprintf("wanted %v but is %v", key, pr.Key))
    29  	}
    30  	return pr.Value
    31  }
    32  
    33  func (f Foo) MarshalAmino() ([]pair, error) { //nolint: golint
    34  	return []pair{
    35  		{"a", f.a},
    36  		{"b", f.b},
    37  		{"c", FooList(f.c)},
    38  		{"D", f.D},
    39  	}, nil
    40  }
    41  
    42  func (f *Foo) UnmarshalAmino(repr []pair) error {
    43  	f.a = repr[0].get("a").(string)
    44  	f.b = repr[1].get("b").(int32)
    45  	f.c = repr[2].get("c").(FooList)
    46  	f.D = repr[3].get("D").(string)
    47  	return nil
    48  }
    49  
    50  var (
    51  	gopkg       = reflect.TypeOf(Foo{}).PkgPath()
    52  	testPackage = pkg.NewPackage(gopkg, "tests", "").
    53  			WithDependencies().
    54  			WithTypes(FooList(nil))
    55  )
    56  
    57  func TestMarshalAminoBinary(t *testing.T) {
    58  	t.Parallel()
    59  
    60  	cdc := NewCodec()
    61  	cdc.RegisterPackage(testPackage)
    62  
    63  	f := Foo{
    64  		a: "K",
    65  		b: 2,
    66  		c: []*Foo{{}, {}, {}},
    67  		D: "J",
    68  	}
    69  	bz, err := cdc.MarshalSized(f)
    70  	assert.NoError(t, err)
    71  
    72  	t.Logf("bz %#v", bz)
    73  
    74  	var f2 Foo
    75  	err = cdc.UnmarshalSized(bz, &f2)
    76  	assert.NoError(t, err)
    77  
    78  	assert.Equal(t, f, f2)
    79  	assert.Equal(t, f.a, f2.a) // In case the above doesn't check private fields?
    80  }
    81  
    82  func TestMarshalAminoJSON(t *testing.T) {
    83  	t.Parallel()
    84  
    85  	cdc := NewCodec()
    86  	cdc.RegisterPackage(testPackage)
    87  
    88  	f := Foo{
    89  		a: "K",
    90  		b: 2,
    91  		c: []*Foo{nil, nil, nil},
    92  		D: "J",
    93  	}
    94  	bz, err := cdc.MarshalJSON(f)
    95  	assert.Nil(t, err)
    96  
    97  	t.Logf("bz %X", bz)
    98  
    99  	var f2 Foo
   100  	err = cdc.UnmarshalJSON(bz, &f2)
   101  	assert.Nil(t, err)
   102  
   103  	assert.Equal(t, f, f2)
   104  	assert.Equal(t, f.a, f2.a) // In case the above doesn't check private fields?
   105  }