Binary API generator improvements

[govpp.git] / core / connection_test.go

diff --git a/core/connection_test.go b/core/connection_test.go
index cea7d2d..453bbce 100644 (file)
--- a/core/connection_test.go
+++ b/core/connection_test.go
@@ -15,16 +15,17 @@
 package core_test
 
 import (
+       "git.fd.io/govpp.git/examples/binapi/interface_types"
        "testing"
 
+       . "github.com/onsi/gomega"
+
        "git.fd.io/govpp.git/adapter/mock"
        "git.fd.io/govpp.git/api"
        "git.fd.io/govpp.git/codec"
        "git.fd.io/govpp.git/core"
-       "git.fd.io/govpp.git/examples/bin_api/interfaces"
-       "git.fd.io/govpp.git/examples/binapi/stats"
+       "git.fd.io/govpp.git/examples/binapi/interfaces"
        "git.fd.io/govpp.git/examples/binapi/vpe"
-       . "github.com/onsi/gomega"
 )
 
 type testCtx struct {
@@ -74,22 +75,12 @@ func TestNilConnection(t *testing.T) {
        Expect(err.Error()).To(ContainSubstring("nil"))
 }
 
-func TestDoubleConnection(t *testing.T) {
-       ctx := setupTest(t, false)
-       defer ctx.teardownTest()
-
-       conn, err := core.Connect(ctx.mockVpp)
-       Expect(err).Should(HaveOccurred())
-       Expect(err.Error()).To(ContainSubstring("only one connection per process"))
-       Expect(conn).Should(BeNil())
-}
-
 func TestAsyncConnection(t *testing.T) {
        ctx := setupTest(t, false)
        defer ctx.teardownTest()
 
        ctx.conn.Disconnect()
-       conn, statusChan, err := core.AsyncConnect(ctx.mockVpp)
+       conn, statusChan, err := core.AsyncConnect(ctx.mockVpp, core.DefaultMaxReconnectAttempts, core.DefaultReconnectInterval)
        ctx.conn = conn
 
        Expect(err).ShouldNot(HaveOccurred())
@@ -102,17 +93,17 @@ func TestAsyncConnection(t *testing.T) {
 func TestCodec(t *testing.T) {
        RegisterTestingT(t)
 
-       msgCodec := &codec.MsgCodec{}
+       var msgCodec = codec.DefaultCodec
 
        // request
-       data, err := msgCodec.EncodeMsg(&interfaces.CreateLoopback{MacAddress: []byte{1, 2, 3, 4, 5, 6}}, 11)
+       data, err := msgCodec.EncodeMsg(&interfaces.CreateLoopback{MacAddress: interfaces.MacAddress{1, 2, 3, 4, 5, 6}}, 11)
        Expect(err).ShouldNot(HaveOccurred())
        Expect(data).ShouldNot(BeEmpty())
 
        msg1 := &interfaces.CreateLoopback{}
        err = msgCodec.DecodeMsg(data, msg1)
        Expect(err).ShouldNot(HaveOccurred())
-       Expect(msg1.MacAddress).To(BeEquivalentTo([]byte{1, 2, 3, 4, 5, 6}))
+       Expect(msg1.MacAddress).To(BeEquivalentTo(interfaces.MacAddress{1, 2, 3, 4, 5, 6}))
 
        // reply
        data, err = msgCodec.EncodeMsg(&vpe.ControlPingReply{Retval: 55}, 22)
@@ -123,22 +114,12 @@ func TestCodec(t *testing.T) {
        err = msgCodec.DecodeMsg(data, msg2)
        Expect(err).ShouldNot(HaveOccurred())
        Expect(msg2.Retval).To(BeEquivalentTo(55))
-
-       // other
-       data, err = msgCodec.EncodeMsg(&stats.VnetIP4FibCounters{VrfID: 77}, 33)
-       Expect(err).ShouldNot(HaveOccurred())
-       Expect(data).ShouldNot(BeEmpty())
-
-       msg3 := &stats.VnetIP4FibCounters{}
-       err = msgCodec.DecodeMsg(data, msg3)
-       Expect(err).ShouldNot(HaveOccurred())
-       Expect(msg3.VrfID).To(BeEquivalentTo(77))
 }
 
 func TestCodecNegative(t *testing.T) {
        RegisterTestingT(t)
 
-       msgCodec := &codec.MsgCodec{}
+       var msgCodec = codec.DefaultCodec
 
        // nil message for encoding
        data, err := msgCodec.EncodeMsg(nil, 15)
@@ -154,7 +135,7 @@ func TestCodecNegative(t *testing.T) {
        // nil data for decoding
        err = msgCodec.DecodeMsg(nil, &vpe.ControlPingReply{})
        Expect(err).Should(HaveOccurred())
-       Expect(err.Error()).To(ContainSubstring("EOF"))
+       Expect(err.Error()).To(ContainSubstring("panic"))
 }
 
 func TestSimpleRequestsWithSequenceNumbers(t *testing.T) {
@@ -181,7 +162,7 @@ func TestMultiRequestsWithSequenceNumbers(t *testing.T) {
 
        var msgs []api.Message
        for i := 0; i < 10; i++ {
-               msgs = append(msgs, &interfaces.SwInterfaceDetails{SwIfIndex: uint32(i)})
+               msgs = append(msgs, &interfaces.SwInterfaceDetails{SwIfIndex: interface_types.InterfaceIndex(i)})
        }
        ctx.mockVpp.MockReply(msgs...)
        ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
@@ -300,7 +281,7 @@ func TestMultiRequestsWithErrors(t *testing.T) {
        }
        for i := 0; i < 10; i++ {
                msgs = append(msgs, mock.MsgWithContext{
-                       Msg:       &interfaces.SwInterfaceDetails{SwIfIndex: uint32(i)},
+                       Msg:       &interfaces.SwInterfaceDetails{SwIfIndex: interface_types.InterfaceIndex(i)},
                        SeqNum:    1,
                        Multipart: true,
                })