Merge branch 'master' into vms-avm-service-test

snow/engine/avalanche/transitive_test.go

@@ -24,6 +24,22 @@ var (
 	errMissing       = errors.New("missing")
 )
 
+func TestEngineShutdown(t *testing.T) {
+	config := DefaultConfig()
+	vmShutdownCalled := false
+	vm := &VMTest{}
+	vm.ShutdownF = func() { vmShutdownCalled = true }
+	config.VM = vm
+
+	transitive := &Transitive{}
+
+	transitive.Initialize(config)
+	transitive.finishBootstrapping()
+	transitive.Shutdown()
+	if !vmShutdownCalled {
+		t.Fatal("Shutting down the Transitive did not shutdown the VM")
+	}
+}
 func TestEngineAdd(t *testing.T) {
 	config := DefaultConfig()
 

snow/engine/snowman/transitive_test.go

@@ -64,6 +64,17 @@ func setup(t *testing.T) (validators.Validator, validators.Set, *common.SenderTe
 	return vdr, vals, sender, vm, te, gBlk
 }
 
+func TestEngineShutdown(t *testing.T) {
+	_, _, _, vm, transitive, _ := setup(t)
+	vmShutdownCalled := false
+	vm.ShutdownF = func() { vmShutdownCalled = true }
+	vm.CantShutdown = false
+	transitive.Shutdown()
+	if !vmShutdownCalled {
+		t.Fatal("Shutting down the Transitive did not shutdown the VM")
+	}
+}
+
 func TestEngineAdd(t *testing.T) {
 	vdr, _, sender, vm, te, _ := setup(t)
 

snow/networking/sender/sender_test.go

@@ -4,6 +4,7 @@
 package sender
 
 import (
+	"reflect"
 	"sync"
 	"testing"
 	"time"
@@ -17,6 +18,20 @@ import (
 	"github.com/ava-labs/gecko/utils/logging"
 )
 
+func TestSenderContext(t *testing.T) {
+	context := snow.DefaultContextTest()
+	sender := Sender{}
+	sender.Initialize(
+		context,
+		&ExternalSenderTest{},
+		&router.ChainRouter{},
+		&timeout.Manager{},
+	)
+	if res := sender.Context(); !reflect.DeepEqual(res, context) {
+		t.Fatalf("Got %#v, expected %#v", res, context)
+	}
+}
+
 func TestTimeout(t *testing.T) {
 	tm := timeout.Manager{}
 	tm.Initialize(time.Millisecond)

vms/components/codec/codec_test.go

@@ -46,6 +46,7 @@ type myStruct struct {
 	InnerStruct  MyInnerStruct      `serialize:"true"`
 	InnerStruct2 *MyInnerStruct     `serialize:"true"`
 	Member1      int64              `serialize:"true"`
+	Member2      uint16             `serialize:"true"`
 	MyArray2     [5]string          `serialize:"true"`
 	MyArray3     [3]MyInnerStruct   `serialize:"true"`
 	MyArray4     [2]*MyInnerStruct2 `serialize:"true"`
@@ -67,6 +68,7 @@ func TestStruct(t *testing.T) {
 		InnerStruct:  MyInnerStruct{"hello"},
 		InnerStruct2: &MyInnerStruct{"yello"},
 		Member1:      1,
+		Member2:      2,
 		MySlice:      []byte{1, 2, 3, 4},
 		MySlice2:     []string{"one", "two", "three"},
 		MySlice3:     []MyInnerStruct{MyInnerStruct{"a"}, MyInnerStruct{"b"}, MyInnerStruct{"c"}},
@@ -410,6 +412,33 @@ func TestSerializeUnexportedField(t *testing.T) {
 	}
 }
 
+func TestSerializeOfNoSerializeField(t *testing.T) {
+	type s struct {
+		SerializedField   string `serialize:"true"`
+		UnserializedField string `serialize:"false"`
+		UnmarkedField     string
+	}
+	myS := s{
+		SerializedField:   "Serialize me",
+		UnserializedField: "Do not serialize me",
+		UnmarkedField:     "No declared serialize",
+	}
+	codec := NewDefault()
+	marshalled, err := codec.Marshal(myS)
+	if err != nil {
+		t.Fatalf("Unexpected error %q", err)
+	}
+	unmarshalled := s{}
+	err = codec.Unmarshal(marshalled, &unmarshalled)
+	if err != nil {
+		t.Fatalf("Unexpected error %q", err)
+	}
+	expectedUnmarshalled := s{SerializedField: "Serialize me"}
+	if !reflect.DeepEqual(unmarshalled, expectedUnmarshalled) {
+		t.Fatalf("Got %#v, expected %#v", unmarshalled, expectedUnmarshalled)
+	}
+}
+
 type simpleSliceStruct struct {
 	Arr []uint32 `serialize:"true"`
 }