// 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" "time" . "github.com/onsi/gomega" "git.fd.io/govpp.git/binapi/ethernet_types" "git.fd.io/govpp.git/binapi/ip_types" "git.fd.io/govpp.git/binapi/vpe_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()) } func TestGeneratedParseTimestamp(t *testing.T) { RegisterTestingT(t) var data = []struct { input time.Time result vpe_types.Timestamp }{ {time.Unix(0, 0), vpe_types.Timestamp(0)}, {time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), vpe_types.Timestamp(9.466848e+08)}, } for _, entry := range data { t.Run(entry.input.String(), func(t *testing.T) { ts := vpe_types.NewTimestamp(entry.input) Expect(ts).To(Equal(entry.result)) Expect(entry.input.Equal(ts.ToTime())).To(BeTrue()) originTime := ts.String() Expect(originTime).To(Equal(entry.input.Local().String())) }) } }