vendor/github.com/tendermint/go-wire/data/binary_test.go

   1 package data_test
   2
   3 import (
   4         "testing"
   5
   6         "github.com/stretchr/testify/assert"
   7         "github.com/stretchr/testify/require"
   8         wire "github.com/tendermint/go-wire"
   9 )
  10
  11 func TestSimpleBinary(t *testing.T) {
  12         assert, require := assert.New(t), require.New(t)
  13
  14         cases := []struct {
  15                 foo Fooer
  16         }{
  17                 {foo: Bar{Name: "Fly"}},
  18                 {foo: Baz{Name: "For Bar"}},
  19         }
  20
  21         for _, tc := range cases {
  22                 assert.NotEmpty(tc.foo.Foo())
  23                 wrap := FooerS{tc.foo}
  24                 parsed := FooerS{}
  25                 d := wire.BinaryBytes(wrap)
  26                 require.NotEmpty(d)
  27                 err := wire.ReadBinaryBytes(d, &parsed)
  28                 require.Nil(err, "%+v", err)
  29                 assert.Equal(tc.foo.Foo(), parsed.Foo())
  30         }
  31 }
  32
  33 func TestNestedBinary(t *testing.T) {
  34         assert, require := assert.New(t), require.New(t)
  35
  36         cases := []struct {
  37                 expected string
  38                 foo      Fooer
  39         }{
  40                 {"Bar Fly", Bar{Name: "Fly"}},
  41                 {"Foz Baz", Baz{Name: "For Bar"}},
  42                 {"My: Bar None", Nested{"My", FooerS{Bar{"None"}}}},
  43         }
  44
  45         for _, tc := range cases {
  46                 assert.Equal(tc.expected, tc.foo.Foo())
  47                 wrap := FooerS{tc.foo}
  48                 parsed := FooerS{}
  49                 d := wire.BinaryBytes(wrap)
  50                 require.NotEmpty(d)
  51                 err := wire.ReadBinaryBytes(d, &parsed)
  52                 require.Nil(err, "%+v", err)
  53                 assert.Equal(tc.expected, parsed.Foo())
  54         }
  55 }