Improve binapi generator

[govpp.git] / binapigen / gen_helpers_test.go

diff --git a/binapigen/gen_helpers_test.go b/binapigen/gen_helpers_test.go
new file mode 100644 (file)
index 0000000..371fd6c
--- /dev/null
+++ b/binapigen/gen_helpers_test.go
@@ -0,0 +1,156 @@
+//  Copyright (c) 2020 Cisco and/or its affiliates.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at:
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+package binapigen
+
+import (
+       "strings"
+       "testing"
+
+       . "github.com/onsi/gomega"
+
+       "git.fd.io/govpp.git/binapi/ethernet_types"
+       "git.fd.io/govpp.git/binapi/ip_types"
+)
+
+func TestGeneratedParseAddress(t *testing.T) {
+       RegisterTestingT(t)
+
+       var data = []struct {
+               input  string
+               result ip_types.Address
+       }{
+               {"192.168.0.1", ip_types.Address{
+                       Af: ip_types.ADDRESS_IP4,
+                       Un: ip_types.AddressUnionIP4(ip_types.IP4Address{192, 168, 0, 1}),
+               }},
+               {"aac1:0:ab45::", ip_types.Address{
+                       Af: ip_types.ADDRESS_IP6,
+                       Un: ip_types.AddressUnionIP6(ip_types.IP6Address{170, 193, 0, 0, 171, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+               }},
+       }
+
+       for _, entry := range data {
+               t.Run(entry.input, func(t *testing.T) {
+                       parsedAddress, err := ip_types.ParseAddress(entry.input)
+                       Expect(err).ShouldNot(HaveOccurred())
+                       Expect(parsedAddress).To(Equal(entry.result))
+
+                       originAddress := parsedAddress.String()
+                       Expect(originAddress).To(Equal(entry.input))
+               })
+       }
+}
+
+func TestGeneratedParseAddressError(t *testing.T) {
+       RegisterTestingT(t)
+
+       _, err := ip_types.ParseAddress("malformed_ip")
+       Expect(err).Should(HaveOccurred())
+}
+
+func TestGeneratedParsePrefix(t *testing.T) {
+       RegisterTestingT(t)
+
+       var data = []struct {
+               input  string
+               result ip_types.Prefix
+       }{
+               {"192.168.0.1/24", ip_types.Prefix{
+                       Address: ip_types.Address{
+                               Af: ip_types.ADDRESS_IP4,
+                               Un: ip_types.AddressUnionIP4(ip_types.IP4Address{192, 168, 0, 1}),
+                       },
+                       Len: 24,
+               }},
+               {"192.168.0.1", ip_types.Prefix{
+                       Address: ip_types.Address{
+                               Af: ip_types.ADDRESS_IP4,
+                               Un: ip_types.AddressUnionIP4(ip_types.IP4Address{192, 168, 0, 1}),
+                       },
+                       Len: 32,
+               }},
+               {"aac1:0:ab45::/96", ip_types.Prefix{
+                       Address: ip_types.Address{
+                               Af: ip_types.ADDRESS_IP6,
+                               Un: ip_types.AddressUnionIP6(ip_types.IP6Address{170, 193, 0, 0, 171, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+                       },
+                       Len: 96,
+               }},
+               {"aac1:0:ab45::", ip_types.Prefix{
+                       Address: ip_types.Address{
+                               Af: ip_types.ADDRESS_IP6,
+                               Un: ip_types.AddressUnionIP6(ip_types.IP6Address{170, 193, 0, 0, 171, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+                       },
+                       Len: 128,
+               }},
+       }
+
+       for _, entry := range data {
+               t.Run(entry.input, func(t *testing.T) {
+                       parsedAddress, err := ip_types.ParsePrefix(entry.input)
+                       Expect(err).ShouldNot(HaveOccurred())
+                       Expect(parsedAddress).To(Equal(entry.result))
+
+                       // Parsed IP without prefix receives a default one
+                       // so the input data must be adjusted
+                       if entry.result.Address.Af == ip_types.ADDRESS_IP4 && !strings.Contains(entry.input, "/") {
+                               entry.input = entry.input + "/32"
+                       }
+                       if entry.result.Address.Af == ip_types.ADDRESS_IP6 && !strings.Contains(entry.input, "/") {
+                               entry.input = entry.input + "/128"
+                       }
+                       originAddress := parsedAddress.String()
+                       Expect(originAddress).To(Equal(entry.input))
+               })
+       }
+}
+
+func TestGeneratedParsePrefixError(t *testing.T) {
+       RegisterTestingT(t)
+
+       _, err := ip_types.ParsePrefix("malformed_ip")
+       Expect(err).Should(HaveOccurred())
+}
+
+func TestGeneratedParseMAC(t *testing.T) {
+       RegisterTestingT(t)
+
+       var data = []struct {
+               input  string
+               result ethernet_types.MacAddress
+       }{
+               {"b7:b9:bb:a1:5c:af", ethernet_types.MacAddress{183, 185, 187, 161, 92, 175}},
+               {"47:4b:c7:3e:06:c8", ethernet_types.MacAddress{71, 75, 199, 62, 6, 200}},
+               {"a7:cc:9f:10:18:e3", ethernet_types.MacAddress{167, 204, 159, 16, 24, 227}},
+       }
+
+       for _, entry := range data {
+               t.Run(entry.input, func(t *testing.T) {
+                       parsedMac, err := ethernet_types.ParseMacAddress(entry.input)
+                       Expect(err).ShouldNot(HaveOccurred())
+                       Expect(parsedMac).To(Equal(entry.result))
+
+                       originAddress := parsedMac.String()
+                       Expect(originAddress).To(Equal(entry.input))
+               })
+       }
+}
+
+func TestGeneratedParseMACError(t *testing.T) {
+       RegisterTestingT(t)
+
+       _, err := ethernet_types.ParseMacAddress("malformed_mac")
+       Expect(err).Should(HaveOccurred())
+}