remove package dependency except for grpc in api/

Nothing except for protobuf IDL files and files generated by protobuf in api/.

Try to make the APIs portable to any languages.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>

5 files changed, 0 insertions, 3359 deletions

diff --git a/api/attribute.go b/api/attribute.go
deleted file mode 100644
index c4ac1375..00000000
--- a/api/attribute.go
+++ /dev/null
@@ -1,1333 +0,0 @@
-// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation.
-//
-// 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 gobgpapi
-
-import (
-	"fmt"
-	"net"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/ptypes"
-	"github.com/golang/protobuf/ptypes/any"
-	"github.com/osrg/gobgp/pkg/packet/bgp"
-	log "github.com/sirupsen/logrus"
-)
-
-func NewOriginAttributeFromNative(a *bgp.PathAttributeOrigin) *OriginAttribute {
-	return &OriginAttribute{
-		Origin: uint32(a.Value),
-	}
-}
-
-func (a *OriginAttribute) ToNative() (*bgp.PathAttributeOrigin, error) {
-	return bgp.NewPathAttributeOrigin(uint8(a.Origin)), nil
-}
-
-func NewAsPathAttributeFromNative(a *bgp.PathAttributeAsPath) *AsPathAttribute {
-	segments := make([]*AsSegment, 0, len(a.Value))
-	for _, param := range a.Value {
-		segments = append(segments, &AsSegment{
-			Type:    uint32(param.GetType()),
-			Numbers: param.GetAS(),
-		})
-	}
-	return &AsPathAttribute{
-		Segments: segments,
-	}
-}
-
-func (a *AsPathAttribute) ToNative() (*bgp.PathAttributeAsPath, error) {
-	params := make([]bgp.AsPathParamInterface, 0, len(a.Segments))
-	for _, segment := range a.Segments {
-		params = append(params, bgp.NewAs4PathParam(uint8(segment.Type), segment.Numbers))
-	}
-	return bgp.NewPathAttributeAsPath(params), nil
-}
-
-func NewNextHopAttributeFromNative(a *bgp.PathAttributeNextHop) *NextHopAttribute {
-	return &NextHopAttribute{
-		NextHop: a.Value.String(),
-	}
-}
-
-func (a *NextHopAttribute) ToNative() (*bgp.PathAttributeNextHop, error) {
-	nexthop := net.ParseIP(a.NextHop).To4()
-	if nexthop == nil {
-		return nil, fmt.Errorf("invalid nexthop address: %s", a.NextHop)
-	}
-	return bgp.NewPathAttributeNextHop(a.NextHop), nil
-}
-
-func NewMultiExitDiscAttributeFromNative(a *bgp.PathAttributeMultiExitDisc) *MultiExitDiscAttribute {
-	return &MultiExitDiscAttribute{
-		Med: a.Value,
-	}
-}
-
-func (a *MultiExitDiscAttribute) ToNative() (*bgp.PathAttributeMultiExitDisc, error) {
-	return bgp.NewPathAttributeMultiExitDisc(a.Med), nil
-}
-
-func NewLocalPrefAttributeFromNative(a *bgp.PathAttributeLocalPref) *LocalPrefAttribute {
-	return &LocalPrefAttribute{
-		LocalPref: a.Value,
-	}
-}
-
-func (a *LocalPrefAttribute) ToNative() (*bgp.PathAttributeLocalPref, error) {
-	return bgp.NewPathAttributeLocalPref(a.LocalPref), nil
-}
-
-func NewAtomicAggregateAttributeFromNative(a *bgp.PathAttributeAtomicAggregate) *AtomicAggregateAttribute {
-	return &AtomicAggregateAttribute{}
-}
-
-func (a *AtomicAggregateAttribute) ToNative() (*bgp.PathAttributeAtomicAggregate, error) {
-	return bgp.NewPathAttributeAtomicAggregate(), nil
-}
-
-func NewAggregatorAttributeFromNative(a *bgp.PathAttributeAggregator) *AggregatorAttribute {
-	return &AggregatorAttribute{
-		As:      a.Value.AS,
-		Address: a.Value.Address.String(),
-	}
-}
-
-func (a *AggregatorAttribute) ToNative() (*bgp.PathAttributeAggregator, error) {
-	if net.ParseIP(a.Address).To4() == nil {
-		return nil, fmt.Errorf("invalid aggregator address: %s", a.Address)
-	}
-	return bgp.NewPathAttributeAggregator(a.As, a.Address), nil
-}
-
-func NewCommunitiesAttributeFromNative(a *bgp.PathAttributeCommunities) *CommunitiesAttribute {
-	return &CommunitiesAttribute{
-		Communities: a.Value,
-	}
-}
-
-func (a *CommunitiesAttribute) ToNative() (*bgp.PathAttributeCommunities, error) {
-	return bgp.NewPathAttributeCommunities(a.Communities), nil
-}
-
-func NewOriginatorIdAttributeFromNative(a *bgp.PathAttributeOriginatorId) *OriginatorIdAttribute {
-	return &OriginatorIdAttribute{
-		Id: a.Value.String(),
-	}
-}
-
-func (a *OriginatorIdAttribute) ToNative() (*bgp.PathAttributeOriginatorId, error) {
-	if net.ParseIP(a.Id).To4() == nil {
-		return nil, fmt.Errorf("invalid originator id: %s", a.Id)
-	}
-	return bgp.NewPathAttributeOriginatorId(a.Id), nil
-}
-
-func NewClusterListAttributeFromNative(a *bgp.PathAttributeClusterList) *ClusterListAttribute {
-	ids := make([]string, 0, len(a.Value))
-	for _, id := range a.Value {
-		ids = append(ids, id.String())
-	}
-	return &ClusterListAttribute{
-		Ids: ids,
-	}
-}
-
-func (a *ClusterListAttribute) ToNative() (*bgp.PathAttributeClusterList, error) {
-	for _, id := range a.Ids {
-		if net.ParseIP(id).To4() == nil {
-			return nil, fmt.Errorf("invalid cluster list: %s", a.Ids)
-		}
-	}
-	return bgp.NewPathAttributeClusterList(a.Ids), nil
-}
-
-func MarshalRD(rd bgp.RouteDistinguisherInterface) *any.Any {
-	var r proto.Message
-	switch v := rd.(type) {
-	case *bgp.RouteDistinguisherTwoOctetAS:
-		r = &RouteDistinguisherTwoOctetAS{
-			Admin:    uint32(v.Admin),
-			Assigned: v.Assigned,
-		}
-	case *bgp.RouteDistinguisherIPAddressAS:
-		r = &RouteDistinguisherIPAddress{
-			Admin:    v.Admin.String(),
-			Assigned: uint32(v.Assigned),
-		}
-	case *bgp.RouteDistinguisherFourOctetAS:
-		r = &RouteDistinguisherFourOctetAS{
-			Admin:    v.Admin,
-			Assigned: uint32(v.Assigned),
-		}
-	default:
-		log.WithFields(log.Fields{
-			"Topic": "protobuf",
-			"RD":    rd,
-		}).Warn("invalid rd type to marshal")
-		return nil
-	}
-	a, _ := ptypes.MarshalAny(r)
-	return a
-}
-
-func UnmarshalRD(a *any.Any) (bgp.RouteDistinguisherInterface, error) {
-	var value ptypes.DynamicAny
-	if err := ptypes.UnmarshalAny(a, &value); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal route distinguisher: %s", err)
-	}
-	switch v := value.Message.(type) {
-	case *RouteDistinguisherTwoOctetAS:
-		return bgp.NewRouteDistinguisherTwoOctetAS(uint16(v.Admin), v.Assigned), nil
-	case *RouteDistinguisherIPAddress:
-		rd := bgp.NewRouteDistinguisherIPAddressAS(v.Admin, uint16(v.Assigned))
-		if rd == nil {
-			return nil, fmt.Errorf("invalid address for route distinguisher: %s", v.Admin)
-		}
-		return rd, nil
-	case *RouteDistinguisherFourOctetAS:
-		return bgp.NewRouteDistinguisherFourOctetAS(v.Admin, uint16(v.Assigned)), nil
-	}
-	return nil, fmt.Errorf("invalid route distinguisher type: %s", a.TypeUrl)
-}
-
-func NewEthernetSegmentIdentifierFromNative(a *bgp.EthernetSegmentIdentifier) *EthernetSegmentIdentifier {
-	return &EthernetSegmentIdentifier{
-		Type:  uint32(a.Type),
-		Value: a.Value,
-	}
-}
-
-func (a *EthernetSegmentIdentifier) ToNative() (*bgp.EthernetSegmentIdentifier, error) {
-	return &bgp.EthernetSegmentIdentifier{
-		Type:  bgp.ESIType(a.Type),
-		Value: a.Value,
-	}, nil
-}
-
-func MarshalFlowSpecRules(values []bgp.FlowSpecComponentInterface) []*any.Any {
-	rules := make([]*any.Any, 0, len(values))
-	for _, value := range values {
-		var rule proto.Message
-		switch v := value.(type) {
-		case *bgp.FlowSpecDestinationPrefix:
-			rule = &FlowSpecIPPrefix{
-				Type:      uint32(bgp.FLOW_SPEC_TYPE_DST_PREFIX),
-				PrefixLen: uint32(v.Prefix.(*bgp.IPAddrPrefix).Length),
-				Prefix:    v.Prefix.(*bgp.IPAddrPrefix).Prefix.String(),
-			}
-		case *bgp.FlowSpecSourcePrefix:
-			rule = &FlowSpecIPPrefix{
-				Type:      uint32(bgp.FLOW_SPEC_TYPE_SRC_PREFIX),
-				PrefixLen: uint32(v.Prefix.(*bgp.IPAddrPrefix).Length),
-				Prefix:    v.Prefix.(*bgp.IPAddrPrefix).Prefix.String(),
-			}
-		case *bgp.FlowSpecDestinationPrefix6:
-			rule = &FlowSpecIPPrefix{
-				Type:      uint32(bgp.FLOW_SPEC_TYPE_DST_PREFIX),
-				PrefixLen: uint32(v.Prefix.(*bgp.IPv6AddrPrefix).Length),
-				Prefix:    v.Prefix.(*bgp.IPv6AddrPrefix).Prefix.String(),
-				Offset:    uint32(v.Offset),
-			}
-		case *bgp.FlowSpecSourcePrefix6:
-			rule = &FlowSpecIPPrefix{
-				Type:      uint32(bgp.FLOW_SPEC_TYPE_SRC_PREFIX),
-				PrefixLen: uint32(v.Prefix.(*bgp.IPv6AddrPrefix).Length),
-				Prefix:    v.Prefix.(*bgp.IPv6AddrPrefix).Prefix.String(),
-				Offset:    uint32(v.Offset),
-			}
-		case *bgp.FlowSpecSourceMac:
-			rule = &FlowSpecMAC{
-				Type:    uint32(bgp.FLOW_SPEC_TYPE_SRC_MAC),
-				Address: v.Mac.String(),
-			}
-		case *bgp.FlowSpecDestinationMac:
-			rule = &FlowSpecMAC{
-				Type:    uint32(bgp.FLOW_SPEC_TYPE_DST_MAC),
-				Address: v.Mac.String(),
-			}
-		case *bgp.FlowSpecComponent:
-			items := make([]*FlowSpecComponentItem, 0, len(v.Items))
-			for _, i := range v.Items {
-				items = append(items, &FlowSpecComponentItem{
-					Op:    uint32(i.Op),
-					Value: i.Value,
-				})
-			}
-			rule = &FlowSpecComponent{
-				Type:  uint32(v.Type()),
-				Items: items,
-			}
-		}
-		a, _ := ptypes.MarshalAny(rule)
-		rules = append(rules, a)
-	}
-	return rules
-}
-
-func UnmarshalFlowSpecRules(values []*any.Any) ([]bgp.FlowSpecComponentInterface, error) {
-	rules := make([]bgp.FlowSpecComponentInterface, 0, len(values))
-	for _, an := range values {
-		var rule bgp.FlowSpecComponentInterface
-		var value ptypes.DynamicAny
-		if err := ptypes.UnmarshalAny(an, &value); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal flow spec component: %s", err)
-		}
-		switch v := value.Message.(type) {
-		case *FlowSpecIPPrefix:
-			typ := bgp.BGPFlowSpecType(v.Type)
-			isIPv4 := net.ParseIP(v.Prefix).To4() != nil
-			switch {
-			case typ == bgp.FLOW_SPEC_TYPE_DST_PREFIX && isIPv4:
-				rule = bgp.NewFlowSpecDestinationPrefix(bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix))
-			case typ == bgp.FLOW_SPEC_TYPE_SRC_PREFIX && isIPv4:
-				rule = bgp.NewFlowSpecSourcePrefix(bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix))
-			case typ == bgp.FLOW_SPEC_TYPE_DST_PREFIX && !isIPv4:
-				rule = bgp.NewFlowSpecDestinationPrefix6(bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix), uint8(v.Offset))
-			case typ == bgp.FLOW_SPEC_TYPE_SRC_PREFIX && !isIPv4:
-				rule = bgp.NewFlowSpecSourcePrefix6(bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix), uint8(v.Offset))
-			}
-		case *FlowSpecMAC:
-			typ := bgp.BGPFlowSpecType(v.Type)
-			mac, err := net.ParseMAC(v.Address)
-			if err != nil {
-				return nil, fmt.Errorf("invalid mac address for %s flow spec component: %s", typ.String(), v.Address)
-			}
-			switch typ {
-			case bgp.FLOW_SPEC_TYPE_SRC_MAC:
-				rule = bgp.NewFlowSpecSourceMac(mac)
-			case bgp.FLOW_SPEC_TYPE_DST_MAC:
-				rule = bgp.NewFlowSpecDestinationMac(mac)
-			}
-		case *FlowSpecComponent:
-			items := make([]*bgp.FlowSpecComponentItem, 0, len(v.Items))
-			for _, item := range v.Items {
-				items = append(items, bgp.NewFlowSpecComponentItem(uint8(item.Op), item.Value))
-			}
-			rule = bgp.NewFlowSpecComponent(bgp.BGPFlowSpecType(v.Type), items)
-		}
-		if rule == nil {
-			return nil, fmt.Errorf("invalid flow spec component: %v", value.Message)
-		}
-		rules = append(rules, rule)
-	}
-	return rules, nil
-}
-
-func MarshalNLRI(value bgp.AddrPrefixInterface) *any.Any {
-	var nlri proto.Message
-
-	switch v := value.(type) {
-	case *bgp.IPAddrPrefix:
-		nlri = &IPAddressPrefix{
-			PrefixLen: uint32(v.Length),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.IPv6AddrPrefix:
-		nlri = &IPAddressPrefix{
-			PrefixLen: uint32(v.Length),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.LabeledIPAddrPrefix:
-		nlri = &LabeledIPAddressPrefix{
-			Labels:    v.Labels.Labels,
-			PrefixLen: uint32(v.IPPrefixLen()),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.LabeledIPv6AddrPrefix:
-		nlri = &LabeledIPAddressPrefix{
-			Labels:    v.Labels.Labels,
-			PrefixLen: uint32(v.IPPrefixLen()),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.EncapNLRI:
-		nlri = &EncapsulationNLRI{
-			Address: v.String(),
-		}
-	case *bgp.Encapv6NLRI:
-		nlri = &EncapsulationNLRI{
-			Address: v.String(),
-		}
-	case *bgp.EVPNNLRI:
-		switch r := v.RouteTypeData.(type) {
-		case *bgp.EVPNEthernetAutoDiscoveryRoute:
-			nlri = &EVPNEthernetAutoDiscoveryRoute{
-				Rd:          MarshalRD(r.RD),
-				Esi:         NewEthernetSegmentIdentifierFromNative(&r.ESI),
-				EthernetTag: r.ETag,
-				Label:       r.Label,
-			}
-		case *bgp.EVPNMacIPAdvertisementRoute:
-			nlri = &EVPNMACIPAdvertisementRoute{
-				Rd:          MarshalRD(r.RD),
-				Esi:         NewEthernetSegmentIdentifierFromNative(&r.ESI),
-				EthernetTag: r.ETag,
-				MacAddress:  r.MacAddress.String(),
-				IpAddress:   r.IPAddress.String(),
-				Labels:      r.Labels,
-			}
-		case *bgp.EVPNMulticastEthernetTagRoute:
-			nlri = &EVPNInclusiveMulticastEthernetTagRoute{
-				Rd:          MarshalRD(r.RD),
-				EthernetTag: r.ETag,
-				IpAddress:   r.IPAddress.String(),
-			}
-		case *bgp.EVPNEthernetSegmentRoute:
-			nlri = &EVPNEthernetSegmentRoute{
-				Rd:        MarshalRD(r.RD),
-				Esi:       NewEthernetSegmentIdentifierFromNative(&r.ESI),
-				IpAddress: r.IPAddress.String(),
-			}
-		case *bgp.EVPNIPPrefixRoute:
-			nlri = &EVPNIPPrefixRoute{
-				Rd:          MarshalRD(r.RD),
-				Esi:         NewEthernetSegmentIdentifierFromNative(&r.ESI),
-				EthernetTag: r.ETag,
-				IpPrefix:    r.IPPrefix.String(),
-				IpPrefixLen: uint32(r.IPPrefixLength),
-				Label:       r.Label,
-			}
-		}
-	case *bgp.LabeledVPNIPAddrPrefix:
-		nlri = &LabeledVPNIPAddressPrefix{
-			Labels:    v.Labels.Labels,
-			Rd:        MarshalRD(v.RD),
-			PrefixLen: uint32(v.IPPrefixLen()),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.LabeledVPNIPv6AddrPrefix:
-		nlri = &LabeledVPNIPAddressPrefix{
-			Labels:    v.Labels.Labels,
-			Rd:        MarshalRD(v.RD),
-			PrefixLen: uint32(v.IPPrefixLen()),
-			Prefix:    v.Prefix.String(),
-		}
-	case *bgp.RouteTargetMembershipNLRI:
-		nlri = &RouteTargetMembershipNLRI{
-			As: v.AS,
-			Rt: MarshalRT(v.RouteTarget),
-		}
-	case *bgp.FlowSpecIPv4Unicast:
-		nlri = &FlowSpecNLRI{
-			Rules: MarshalFlowSpecRules(v.Value),
-		}
-	case *bgp.FlowSpecIPv6Unicast:
-		nlri = &FlowSpecNLRI{
-			Rules: MarshalFlowSpecRules(v.Value),
-		}
-	case *bgp.FlowSpecIPv4VPN:
-		nlri = &VPNFlowSpecNLRI{
-			Rd:    MarshalRD(v.RD()),
-			Rules: MarshalFlowSpecRules(v.Value),
-		}
-	case *bgp.FlowSpecIPv6VPN:
-		nlri = &VPNFlowSpecNLRI{
-			Rd:    MarshalRD(v.RD()),
-			Rules: MarshalFlowSpecRules(v.Value),
-		}
-	case *bgp.FlowSpecL2VPN:
-		nlri = &VPNFlowSpecNLRI{
-			Rd:    MarshalRD(v.RD()),
-			Rules: MarshalFlowSpecRules(v.Value),
-		}
-	}
-
-	an, _ := ptypes.MarshalAny(nlri)
-	return an
-}
-
-func MarshalNLRIs(values []bgp.AddrPrefixInterface) []*any.Any {
-	nlris := make([]*any.Any, 0, len(values))
-	for _, value := range values {
-		nlris = append(nlris, MarshalNLRI(value))
-	}
-	return nlris
-}
-
-func UnmarshalNLRI(rf bgp.RouteFamily, an *any.Any) (bgp.AddrPrefixInterface, error) {
-	var nlri bgp.AddrPrefixInterface
-
-	var value ptypes.DynamicAny
-	if err := ptypes.UnmarshalAny(an, &value); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal nlri: %s", err)
-	}
-
-	switch v := value.Message.(type) {
-	case *IPAddressPrefix:
-		switch rf {
-		case bgp.RF_IPv4_UC:
-			nlri = bgp.NewIPAddrPrefix(uint8(v.PrefixLen), v.Prefix)
-		case bgp.RF_IPv6_UC:
-			nlri = bgp.NewIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix)
-		}
-	case *LabeledIPAddressPrefix:
-		switch rf {
-		case bgp.RF_IPv4_MPLS:
-			nlri = bgp.NewLabeledIPAddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...))
-		case bgp.RF_IPv6_MPLS:
-			nlri = bgp.NewLabeledIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...))
-		}
-	case *EncapsulationNLRI:
-		switch rf {
-		case bgp.RF_IPv4_ENCAP:
-			nlri = bgp.NewEncapNLRI(v.Address)
-		case bgp.RF_IPv6_ENCAP:
-			nlri = bgp.NewEncapv6NLRI(v.Address)
-		}
-	case *EVPNEthernetAutoDiscoveryRoute:
-		if rf == bgp.RF_EVPN {
-			rd, err := UnmarshalRD(v.Rd)
-			if err != nil {
-				return nil, err
-			}
-			esi, err := v.Esi.ToNative()
-			if err != nil {
-				return nil, err
-			}
-			nlri = bgp.NewEVPNEthernetAutoDiscoveryRoute(rd, *esi, v.EthernetTag, v.Label)
-		}
-	case *EVPNMACIPAdvertisementRoute:
-		if rf == bgp.RF_EVPN {
-			rd, err := UnmarshalRD(v.Rd)
-			if err != nil {
-				return nil, err
-			}
-			esi, err := v.Esi.ToNative()
-			if err != nil {
-				return nil, err
-			}
-			nlri = bgp.NewEVPNMacIPAdvertisementRoute(rd, *esi, v.EthernetTag, v.MacAddress, v.IpAddress, v.Labels)
-		}
-	case *EVPNInclusiveMulticastEthernetTagRoute:
-		if rf == bgp.RF_EVPN {
-			rd, err := UnmarshalRD(v.Rd)
-			if err != nil {
-				return nil, err
-			}
-			nlri = bgp.NewEVPNMulticastEthernetTagRoute(rd, v.EthernetTag, v.IpAddress)
-		}
-	case *EVPNEthernetSegmentRoute:
-		if rf == bgp.RF_EVPN {
-			rd, err := UnmarshalRD(v.Rd)
-			if err != nil {
-				return nil, err
-			}
-			esi, err := v.Esi.ToNative()
-			if err != nil {
-				return nil, err
-			}
-			nlri = bgp.NewEVPNEthernetSegmentRoute(rd, *esi, v.IpAddress)
-		}
-	case *EVPNIPPrefixRoute:
-		if rf == bgp.RF_EVPN {
-			rd, err := UnmarshalRD(v.Rd)
-			if err != nil {
-				return nil, err
-			}
-			esi, err := v.Esi.ToNative()
-			if err != nil {
-				return nil, err
-			}
-			nlri = bgp.NewEVPNIPPrefixRoute(rd, *esi, v.EthernetTag, uint8(v.IpPrefixLen), v.IpPrefix, v.GwAddress, v.Label)
-		}
-	case *LabeledVPNIPAddressPrefix:
-		rd, err := UnmarshalRD(v.Rd)
-		if err != nil {
-			return nil, err
-		}
-		switch rf {
-		case bgp.RF_IPv4_VPN:
-			nlri = bgp.NewLabeledVPNIPAddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...), rd)
-		case bgp.RF_IPv6_VPN:
-			nlri = bgp.NewLabeledVPNIPv6AddrPrefix(uint8(v.PrefixLen), v.Prefix, *bgp.NewMPLSLabelStack(v.Labels...), rd)
-		}
-	case *RouteTargetMembershipNLRI:
-		rt, err := UnmarshalRT(v.Rt)
-		if err != nil {
-			return nil, err
-		}
-		nlri = bgp.NewRouteTargetMembershipNLRI(v.As, rt)
-	case *FlowSpecNLRI:
-		rules, err := UnmarshalFlowSpecRules(v.Rules)
-		if err != nil {
-			return nil, err
-		}
-		switch rf {
-		case bgp.RF_FS_IPv4_UC:
-			nlri = bgp.NewFlowSpecIPv4Unicast(rules)
-		case bgp.RF_FS_IPv6_UC:
-			nlri = bgp.NewFlowSpecIPv6Unicast(rules)
-		}
-	case *VPNFlowSpecNLRI:
-		rd, err := UnmarshalRD(v.Rd)
-		if err != nil {
-			return nil, err
-		}
-		rules, err := UnmarshalFlowSpecRules(v.Rules)
-		if err != nil {
-			return nil, err
-		}
-		switch rf {
-		case bgp.RF_FS_IPv4_VPN:
-			nlri = bgp.NewFlowSpecIPv4VPN(rd, rules)
-		case bgp.RF_FS_IPv6_VPN:
-			nlri = bgp.NewFlowSpecIPv6VPN(rd, rules)
-		case bgp.RF_FS_L2_VPN:
-			nlri = bgp.NewFlowSpecL2VPN(rd, rules)
-		}
-	}
-
-	if nlri == nil {
-		return nil, fmt.Errorf("invalid nlri for %s family: %s", rf.String(), value.Message)
-	}
-
-	return nlri, nil
-}
-
-func UnmarshalNLRIs(rf bgp.RouteFamily, values []*any.Any) ([]bgp.AddrPrefixInterface, error) {
-	nlris := make([]bgp.AddrPrefixInterface, 0, len(values))
-	for _, an := range values {
-		nlri, err := UnmarshalNLRI(rf, an)
-		if err != nil {
-			return nil, err
-		}
-		nlris = append(nlris, nlri)
-	}
-	return nlris, nil
-}
-
-func NewMpReachNLRIAttributeFromNative(a *bgp.PathAttributeMpReachNLRI) *MpReachNLRIAttribute {
-	var nexthops []string
-	if a.SAFI == bgp.SAFI_FLOW_SPEC_UNICAST || a.SAFI == bgp.SAFI_FLOW_SPEC_VPN {
-		nexthops = nil
-	} else {
-		nexthops = []string{a.Nexthop.String()}
-		if a.LinkLocalNexthop != nil {
-			nexthops = append(nexthops, a.LinkLocalNexthop.String())
-		}
-	}
-	return &MpReachNLRIAttribute{
-		Family:   uint32(bgp.AfiSafiToRouteFamily(a.AFI, a.SAFI)),
-		NextHops: nexthops,
-		Nlris:    MarshalNLRIs(a.Value),
-	}
-}
-
-func (a *MpReachNLRIAttribute) ToNative() (*bgp.PathAttributeMpReachNLRI, error) {
-	rf := bgp.RouteFamily(a.Family)
-	nlris, err := UnmarshalNLRIs(rf, a.Nlris)
-	if err != nil {
-		return nil, err
-	}
-	afi, safi := bgp.RouteFamilyToAfiSafi(rf)
-	nexthop := "0.0.0.0"
-	var linkLocalNexthop net.IP
-	if afi == bgp.AFI_IP6 {
-		nexthop = "::"
-		if len(a.NextHops) > 1 {
-			linkLocalNexthop = net.ParseIP(a.NextHops[1]).To16()
-			if linkLocalNexthop == nil {
-				return nil, fmt.Errorf("invalid nexthop: %s", a.NextHops[1])
-			}
-		}
-	}
-	if safi == bgp.SAFI_FLOW_SPEC_UNICAST || safi == bgp.SAFI_FLOW_SPEC_VPN {
-		nexthop = ""
-	} else if len(a.NextHops) > 0 {
-		nexthop = a.NextHops[0]
-		if net.ParseIP(nexthop) == nil {
-			return nil, fmt.Errorf("invalid nexthop: %s", nexthop)
-		}
-	}
-	attr := bgp.NewPathAttributeMpReachNLRI(nexthop, nlris)
-	attr.LinkLocalNexthop = linkLocalNexthop
-	return attr, nil
-}
-
-func NewMpUnreachNLRIAttributeFromNative(a *bgp.PathAttributeMpUnreachNLRI) *MpUnreachNLRIAttribute {
-	return &MpUnreachNLRIAttribute{
-		Family: uint32(bgp.AfiSafiToRouteFamily(a.AFI, a.SAFI)),
-		Nlris:  MarshalNLRIs(a.Value),
-	}
-}
-
-func (a *MpUnreachNLRIAttribute) ToNative() (*bgp.PathAttributeMpUnreachNLRI, error) {
-	rf := bgp.RouteFamily(a.Family)
-	nlris, err := UnmarshalNLRIs(rf, a.Nlris)
-	if err != nil {
-		return nil, err
-	}
-	return bgp.NewPathAttributeMpUnreachNLRI(nlris), nil
-}
-
-func MarshalRT(rt bgp.ExtendedCommunityInterface) *any.Any {
-	var r proto.Message
-	switch v := rt.(type) {
-	case *bgp.TwoOctetAsSpecificExtended:
-		r = &TwoOctetAsSpecificExtended{
-			IsTransitive: true,
-			SubType:      uint32(bgp.EC_SUBTYPE_ROUTE_TARGET),
-			As:           uint32(v.AS),
-			LocalAdmin:   uint32(v.LocalAdmin),
-		}
-	case *bgp.IPv4AddressSpecificExtended:
-		r = &IPv4AddressSpecificExtended{
-			IsTransitive: true,
-			SubType:      uint32(bgp.EC_SUBTYPE_ROUTE_TARGET),
-			Address:      v.IPv4.String(),
-			LocalAdmin:   uint32(v.LocalAdmin),
-		}
-	case *bgp.FourOctetAsSpecificExtended:
-		r = &FourOctetAsSpecificExtended{
-			IsTransitive: true,
-			SubType:      uint32(bgp.EC_SUBTYPE_ROUTE_TARGET),
-			As:           uint32(v.AS),
-			LocalAdmin:   uint32(v.LocalAdmin),
-		}
-	default:
-		log.WithFields(log.Fields{
-			"Topic": "protobuf",
-			"RT":    rt,
-		}).Warn("invalid rt type to marshal")
-		return nil
-	}
-	a, _ := ptypes.MarshalAny(r)
-	return a
-}
-
-func MarshalRTs(values []bgp.ExtendedCommunityInterface) []*any.Any {
-	rts := make([]*any.Any, 0, len(values))
-	for _, rt := range values {
-		rts = append(rts, MarshalRT(rt))
-	}
-	return rts
-}
-
-func UnmarshalRT(a *any.Any) (bgp.ExtendedCommunityInterface, error) {
-	var value ptypes.DynamicAny
-	if err := ptypes.UnmarshalAny(a, &value); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal route target: %s", err)
-	}
-	switch v := value.Message.(type) {
-	case *TwoOctetAsSpecificExtended:
-		return bgp.NewTwoOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), uint16(v.As), v.LocalAdmin, v.IsTransitive), nil
-	case *IPv4AddressSpecificExtended:
-		rt := bgp.NewIPv4AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive)
-		if rt == nil {
-			return nil, fmt.Errorf("invalid address for ipv4 address specific route target: %s", v.Address)
-		}
-		return rt, nil
-	case *FourOctetAsSpecificExtended:
-		return bgp.NewFourOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.As, uint16(v.LocalAdmin), v.IsTransitive), nil
-	}
-	return nil, fmt.Errorf("invalid route target type: %s", a.TypeUrl)
-}
-
-func UnmarshalRTs(values []*any.Any) ([]bgp.ExtendedCommunityInterface, error) {
-	rts := make([]bgp.ExtendedCommunityInterface, 0, len(values))
-	for _, an := range values {
-		rt, err := UnmarshalRT(an)
-		if err != nil {
-			return nil, err
-		}
-		rts = append(rts, rt)
-	}
-	return rts, nil
-}
-
-func NewExtendedCommunitiesAttributeFromNative(a *bgp.PathAttributeExtendedCommunities) *ExtendedCommunitiesAttribute {
-	communities := make([]*any.Any, 0, len(a.Value))
-	for _, value := range a.Value {
-		var community proto.Message
-		switch v := value.(type) {
-		case *bgp.TwoOctetAsSpecificExtended:
-			community = &TwoOctetAsSpecificExtended{
-				IsTransitive: v.IsTransitive,
-				SubType:      uint32(v.SubType),
-				As:           uint32(v.AS),
-				LocalAdmin:   uint32(v.LocalAdmin),
-			}
-		case *bgp.IPv4AddressSpecificExtended:
-			community = &IPv4AddressSpecificExtended{
-				IsTransitive: v.IsTransitive,
-				SubType:      uint32(v.SubType),
-				Address:      v.IPv4.String(),
-				LocalAdmin:   uint32(v.LocalAdmin),
-			}
-		case *bgp.FourOctetAsSpecificExtended:
-			community = &FourOctetAsSpecificExtended{
-				IsTransitive: v.IsTransitive,
-				SubType:      uint32(v.SubType),
-				As:           uint32(v.AS),
-				LocalAdmin:   uint32(v.LocalAdmin),
-			}
-		case *bgp.ValidationExtended:
-			community = &ValidationExtended{
-				State: uint32(v.State),
-			}
-		case *bgp.ColorExtended:
-			community = &ColorExtended{
-				Color: v.Color,
-			}
-		case *bgp.EncapExtended:
-			community = &EncapExtended{
-				TunnelType: uint32(v.TunnelType),
-			}
-		case *bgp.DefaultGatewayExtended:
-			community = &DefaultGatewayExtended{}
-		case *bgp.OpaqueExtended:
-			community = &OpaqueExtended{
-				IsTransitive: v.IsTransitive,
-				Value:        v.Value,
-			}
-		case *bgp.ESILabelExtended:
-			community = &ESILabelExtended{
-				IsSingleActive: v.IsSingleActive,
-				Label:          v.Label,
-			}
-		case *bgp.ESImportRouteTarget:
-			community = &ESImportRouteTarget{
-				EsImport: v.ESImport.String(),
-			}
-		case *bgp.MacMobilityExtended:
-			community = &MacMobilityExtended{
-				IsSticky:    v.IsSticky,
-				SequenceNum: v.Sequence,
-			}
-		case *bgp.RouterMacExtended:
-			community = &RouterMacExtended{
-				Mac: v.Mac.String(),
-			}
-		case *bgp.TrafficRateExtended:
-			community = &TrafficRateExtended{
-				As:   uint32(v.AS),
-				Rate: v.Rate,
-			}
-		case *bgp.TrafficActionExtended:
-			community = &TrafficActionExtended{
-				Terminal: v.Terminal,
-				Sample:   v.Sample,
-			}
-		case *bgp.RedirectTwoOctetAsSpecificExtended:
-			community = &RedirectTwoOctetAsSpecificExtended{
-				As:         uint32(v.AS),
-				LocalAdmin: v.LocalAdmin,
-			}
-		case *bgp.RedirectIPv4AddressSpecificExtended:
-			community = &RedirectIPv4AddressSpecificExtended{
-				Address:    v.IPv4.String(),
-				LocalAdmin: uint32(v.LocalAdmin),
-			}
-		case *bgp.RedirectFourOctetAsSpecificExtended:
-			community = &RedirectFourOctetAsSpecificExtended{
-				As:         v.AS,
-				LocalAdmin: uint32(v.LocalAdmin),
-			}
-		case *bgp.TrafficRemarkExtended:
-			community = &TrafficRemarkExtended{
-				Dscp: uint32(v.DSCP),
-			}
-		case *bgp.UnknownExtended:
-			community = &UnknownExtended{
-				Type:  uint32(v.Type),
-				Value: v.Value,
-			}
-		default:
-			log.WithFields(log.Fields{
-				"Topic":     "protobuf",
-				"Community": value,
-			}).Warn("unsupported extended community")
-			return nil
-		}
-		an, _ := ptypes.MarshalAny(community)
-		communities = append(communities, an)
-	}
-	return &ExtendedCommunitiesAttribute{
-		Communities: communities,
-	}
-}
-
-func (a *ExtendedCommunitiesAttribute) ToNative() (*bgp.PathAttributeExtendedCommunities, error) {
-	communities := make([]bgp.ExtendedCommunityInterface, 0, len(a.Communities))
-	for _, an := range a.Communities {
-		var community bgp.ExtendedCommunityInterface
-		var value ptypes.DynamicAny
-		if err := ptypes.UnmarshalAny(an, &value); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal extended community: %s", err)
-		}
-		switch v := value.Message.(type) {
-		case *TwoOctetAsSpecificExtended:
-			community = bgp.NewTwoOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), uint16(v.As), v.LocalAdmin, v.IsTransitive)
-		case *IPv4AddressSpecificExtended:
-			community = bgp.NewIPv4AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive)
-		case *FourOctetAsSpecificExtended:
-			community = bgp.NewFourOctetAsSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.As, uint16(v.LocalAdmin), v.IsTransitive)
-		case *ValidationExtended:
-			community = bgp.NewValidationExtended(bgp.ValidationState(v.State))
-		case *ColorExtended:
-			community = bgp.NewColorExtended(v.Color)
-		case *EncapExtended:
-			community = bgp.NewEncapExtended(bgp.TunnelType(v.TunnelType))
-		case *DefaultGatewayExtended:
-			community = bgp.NewDefaultGatewayExtended()
-		case *OpaqueExtended:
-			community = bgp.NewOpaqueExtended(v.IsTransitive, v.Value)
-		case *ESILabelExtended:
-			community = bgp.NewESILabelExtended(v.Label, v.IsSingleActive)
-		case *ESImportRouteTarget:
-			community = bgp.NewESImportRouteTarget(v.EsImport)
-		case *MacMobilityExtended:
-			community = bgp.NewMacMobilityExtended(v.SequenceNum, v.IsSticky)
-		case *RouterMacExtended:
-			community = bgp.NewRoutersMacExtended(v.Mac)
-		case *TrafficRateExtended:
-			community = bgp.NewTrafficRateExtended(uint16(v.As), v.Rate)
-		case *TrafficActionExtended:
-			community = bgp.NewTrafficActionExtended(v.Terminal, v.Sample)
-		case *RedirectTwoOctetAsSpecificExtended:
-			community = bgp.NewRedirectTwoOctetAsSpecificExtended(uint16(v.As), v.LocalAdmin)
-		case *RedirectIPv4AddressSpecificExtended:
-			community = bgp.NewRedirectIPv4AddressSpecificExtended(v.Address, uint16(v.LocalAdmin))
-		case *RedirectFourOctetAsSpecificExtended:
-			community = bgp.NewRedirectFourOctetAsSpecificExtended(v.As, uint16(v.LocalAdmin))
-		case *TrafficRemarkExtended:
-			community = bgp.NewTrafficRemarkExtended(uint8(v.Dscp))
-		case *UnknownExtended:
-			community = bgp.NewUnknownExtended(bgp.ExtendedCommunityAttrType(v.Type), v.Value)
-		}
-		if community == nil {
-			return nil, fmt.Errorf("invalid extended community: %v", value.Message)
-		}
-		communities = append(communities, community)
-	}
-	return bgp.NewPathAttributeExtendedCommunities(communities), nil
-}
-
-func NewAs4PathAttributeFromNative(a *bgp.PathAttributeAs4Path) *As4PathAttribute {
-	segments := make([]*AsSegment, 0, len(a.Value))
-	for _, param := range a.Value {
-		segments = append(segments, &AsSegment{
-			Type:    uint32(param.Type),
-			Numbers: param.AS,
-		})
-	}
-	return &As4PathAttribute{
-		Segments: segments,
-	}
-}
-
-func (a *As4PathAttribute) ToNative() (*bgp.PathAttributeAs4Path, error) {
-	params := make([]*bgp.As4PathParam, 0, len(a.Segments))
-	for _, segment := range a.Segments {
-		params = append(params, bgp.NewAs4PathParam(uint8(segment.Type), segment.Numbers))
-	}
-	return bgp.NewPathAttributeAs4Path(params), nil
-}
-
-func NewAs4AggregatorAttributeFromNative(a *bgp.PathAttributeAs4Aggregator) *As4AggregatorAttribute {
-	return &As4AggregatorAttribute{
-		As:      a.Value.AS,
-		Address: a.Value.Address.String(),
-	}
-}
-
-func (a *As4AggregatorAttribute) ToNative() (*bgp.PathAttributeAs4Aggregator, error) {
-	if net.ParseIP(a.Address).To4() == nil {
-		return nil, fmt.Errorf("invalid as4 aggregator address: %s", a.Address)
-	}
-	return bgp.NewPathAttributeAs4Aggregator(a.As, a.Address), nil
-}
-
-func NewPmsiTunnelAttributeFromNative(a *bgp.PathAttributePmsiTunnel) *PmsiTunnelAttribute {
-	var flags uint32
-	if a.IsLeafInfoRequired {
-		flags |= 0x01
-	}
-	id, _ := a.TunnelID.Serialize()
-	return &PmsiTunnelAttribute{
-		Flags: flags,
-		Type:  uint32(a.TunnelType),
-		Label: a.Label,
-		Id:    id,
-	}
-}
-
-func (a *PmsiTunnelAttribute) ToNative() (*bgp.PathAttributePmsiTunnel, error) {
-	typ := bgp.PmsiTunnelType(a.Type)
-	var isLeafInfoRequired bool
-	if a.Flags&0x01 > 0 {
-		isLeafInfoRequired = true
-	}
-	var id bgp.PmsiTunnelIDInterface
-	switch typ {
-	case bgp.PMSI_TUNNEL_TYPE_INGRESS_REPL:
-		ip := net.IP(a.Id)
-		if ip.To4() == nil && ip.To16() == nil {
-			return nil, fmt.Errorf("invalid pmsi tunnel identifier: %s", a.Id)
-		}
-		id = bgp.NewIngressReplTunnelID(ip.String())
-	default:
-		id = bgp.NewDefaultPmsiTunnelID(a.Id)
-	}
-	return bgp.NewPathAttributePmsiTunnel(typ, isLeafInfoRequired, a.Label, id), nil
-}
-
-func NewTunnelEncapAttributeFromNative(a *bgp.PathAttributeTunnelEncap) *TunnelEncapAttribute {
-	tlvs := make([]*TunnelEncapTLV, 0, len(a.Value))
-	for _, v := range a.Value {
-		subTlvs := make([]*any.Any, 0, len(v.Value))
-		for _, s := range v.Value {
-			var subTlv proto.Message
-			switch sv := s.(type) {
-			case *bgp.TunnelEncapSubTLVEncapsulation:
-				subTlv = &TunnelEncapSubTLVEncapsulation{
-					Key:    sv.Key,
-					Cookie: sv.Cookie,
-				}
-			case *bgp.TunnelEncapSubTLVProtocol:
-				subTlv = &TunnelEncapSubTLVProtocol{
-					Protocol: uint32(sv.Protocol),
-				}
-			case *bgp.TunnelEncapSubTLVColor:
-				subTlv = &TunnelEncapSubTLVColor{
-					Color: sv.Color,
-				}
-			case *bgp.TunnelEncapSubTLVUnknown:
-				subTlv = &TunnelEncapSubTLVUnknown{
-					Type:  uint32(sv.Type),
-					Value: sv.Value,
-				}
-			}
-			an, _ := ptypes.MarshalAny(subTlv)
-			subTlvs = append(subTlvs, an)
-		}
-		tlvs = append(tlvs, &TunnelEncapTLV{
-			Type: uint32(v.Type),
-			Tlvs: subTlvs,
-		})
-	}
-	return &TunnelEncapAttribute{
-		Tlvs: tlvs,
-	}
-}
-
-func (a *TunnelEncapAttribute) ToNative() (*bgp.PathAttributeTunnelEncap, error) {
-	tlvs := make([]*bgp.TunnelEncapTLV, 0, len(a.Tlvs))
-	for _, tlv := range a.Tlvs {
-		subTlvs := make([]bgp.TunnelEncapSubTLVInterface, 0, len(tlv.Tlvs))
-		for _, an := range tlv.Tlvs {
-			var subTlv bgp.TunnelEncapSubTLVInterface
-			var subValue ptypes.DynamicAny
-			if err := ptypes.UnmarshalAny(an, &subValue); err != nil {
-				return nil, fmt.Errorf("failed to unmarshal tunnel encapsulation attribute sub tlv: %s", err)
-			}
-			switch sv := subValue.Message.(type) {
-			case *TunnelEncapSubTLVEncapsulation:
-				subTlv = bgp.NewTunnelEncapSubTLVEncapsulation(sv.Key, sv.Cookie)
-			case *TunnelEncapSubTLVProtocol:
-				subTlv = bgp.NewTunnelEncapSubTLVProtocol(uint16(sv.Protocol))
-			case *TunnelEncapSubTLVColor:
-				subTlv = bgp.NewTunnelEncapSubTLVColor(sv.Color)
-			case *TunnelEncapSubTLVUnknown:
-				subTlv = bgp.NewTunnelEncapSubTLVUnknown(bgp.EncapSubTLVType(sv.Type), sv.Value)
-			default:
-				return nil, fmt.Errorf("invalid tunnel encapsulation attribute sub tlv: %v", subValue.Message)
-			}
-			subTlvs = append(subTlvs, subTlv)
-		}
-		tlvs = append(tlvs, bgp.NewTunnelEncapTLV(bgp.TunnelType(tlv.Type), subTlvs))
-	}
-	return bgp.NewPathAttributeTunnelEncap(tlvs), nil
-}
-
-func NewIP6ExtendedCommunitiesAttributeFromNative(a *bgp.PathAttributeIP6ExtendedCommunities) *IP6ExtendedCommunitiesAttribute {
-	communities := make([]*any.Any, 0, len(a.Value))
-	for _, value := range a.Value {
-		var community proto.Message
-		switch v := value.(type) {
-		case *bgp.IPv6AddressSpecificExtended:
-			community = &IPv6AddressSpecificExtended{
-				IsTransitive: v.IsTransitive,
-				SubType:      uint32(v.SubType),
-				Address:      v.IPv6.String(),
-				LocalAdmin:   uint32(v.LocalAdmin),
-			}
-		case *bgp.RedirectIPv6AddressSpecificExtended:
-			community = &RedirectIPv6AddressSpecificExtended{
-				Address:    v.IPv6.String(),
-				LocalAdmin: uint32(v.LocalAdmin),
-			}
-		default:
-			log.WithFields(log.Fields{
-				"Topic":     "protobuf",
-				"Attribute": value,
-			}).Warn("invalid ipv6 extended community")
-			return nil
-		}
-		an, _ := ptypes.MarshalAny(community)
-		communities = append(communities, an)
-	}
-	return &IP6ExtendedCommunitiesAttribute{
-		Communities: communities,
-	}
-}
-
-func (a *IP6ExtendedCommunitiesAttribute) ToNative() (*bgp.PathAttributeIP6ExtendedCommunities, error) {
-	communities := make([]bgp.ExtendedCommunityInterface, 0, len(a.Communities))
-	for _, an := range a.Communities {
-		var community bgp.ExtendedCommunityInterface
-		var value ptypes.DynamicAny
-		if err := ptypes.UnmarshalAny(an, &value); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal ipv6 extended community: %s", err)
-		}
-		switch v := value.Message.(type) {
-		case *IPv6AddressSpecificExtended:
-			community = bgp.NewIPv6AddressSpecificExtended(bgp.ExtendedCommunityAttrSubType(v.SubType), v.Address, uint16(v.LocalAdmin), v.IsTransitive)
-		case *RedirectIPv6AddressSpecificExtended:
-			community = bgp.NewRedirectIPv6AddressSpecificExtended(v.Address, uint16(v.LocalAdmin))
-		}
-		if community == nil {
-			return nil, fmt.Errorf("invalid ipv6 extended community: %v", value.Message)
-		}
-		communities = append(communities, community)
-	}
-	return bgp.NewPathAttributeIP6ExtendedCommunities(communities), nil
-}
-
-func NewAigpAttributeFromNative(a *bgp.PathAttributeAigp) *AigpAttribute {
-	tlvs := make([]*any.Any, 0, len(a.Values))
-	for _, value := range a.Values {
-		var tlv proto.Message
-		switch v := value.(type) {
-		case *bgp.AigpTLVIgpMetric:
-			tlv = &AigpTLVIGPMetric{
-				Metric: v.Metric,
-			}
-		case *bgp.AigpTLVDefault:
-			tlv = &AigpTLVUnknown{
-				Type:  uint32(v.Type()),
-				Value: v.Value,
-			}
-		}
-		an, _ := ptypes.MarshalAny(tlv)
-		tlvs = append(tlvs, an)
-	}
-	return &AigpAttribute{
-		Tlvs: tlvs,
-	}
-}
-
-func (a *AigpAttribute) ToNative() (*bgp.PathAttributeAigp, error) {
-	tlvs := make([]bgp.AigpTLVInterface, 0, len(a.Tlvs))
-	for _, an := range a.Tlvs {
-		var tlv bgp.AigpTLVInterface
-		var value ptypes.DynamicAny
-		if err := ptypes.UnmarshalAny(an, &value); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal aigp attribute tlv: %s", err)
-		}
-		switch v := value.Message.(type) {
-		case *AigpTLVIGPMetric:
-			tlv = bgp.NewAigpTLVIgpMetric(v.Metric)
-		case *AigpTLVUnknown:
-			tlv = bgp.NewAigpTLVDefault(bgp.AigpTLVType(v.Type), v.Value)
-		}
-		if tlv == nil {
-			return nil, fmt.Errorf("invalid aigp attribute tlv: %v", value.Message)
-		}
-		tlvs = append(tlvs, tlv)
-	}
-	return bgp.NewPathAttributeAigp(tlvs), nil
-}
-
-func NewLargeCommunitiesAttributeFromNative(a *bgp.PathAttributeLargeCommunities) *LargeCommunitiesAttribute {
-	communities := make([]*LargeCommunity, 0, len(a.Values))
-	for _, v := range a.Values {
-		communities = append(communities, &LargeCommunity{
-			GlobalAdmin: v.ASN,
-			LocalData1:  v.LocalData1,
-			LocalData2:  v.LocalData2,
-		})
-	}
-	return &LargeCommunitiesAttribute{
-		Communities: communities,
-	}
-}
-
-func (a *LargeCommunitiesAttribute) ToNative() (*bgp.PathAttributeLargeCommunities, error) {
-	communities := make([]*bgp.LargeCommunity, 0, len(a.Communities))
-	for _, c := range a.Communities {
-		communities = append(communities, bgp.NewLargeCommunity(c.GlobalAdmin, c.LocalData1, c.LocalData2))
-	}
-	return bgp.NewPathAttributeLargeCommunities(communities), nil
-}
-
-func NewUnknownAttributeFromNative(a *bgp.PathAttributeUnknown) *UnknownAttribute {
-	return &UnknownAttribute{
-		Flags: uint32(a.Flags),
-		Type:  uint32(a.Type),
-		Value: a.Value,
-	}
-}
-
-func (a *UnknownAttribute) ToNative() (*bgp.PathAttributeUnknown, error) {
-	return bgp.NewPathAttributeUnknown(bgp.BGPAttrFlag(a.Flags), bgp.BGPAttrType(a.Type), a.Value), nil
-}
-
-func MarshalPathAttributes(attrList []bgp.PathAttributeInterface) []*any.Any {
-	anyList := make([]*any.Any, 0, len(attrList))
-	for _, attr := range attrList {
-		switch a := attr.(type) {
-		case *bgp.PathAttributeOrigin:
-			n, _ := ptypes.MarshalAny(NewOriginAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAsPath:
-			n, _ := ptypes.MarshalAny(NewAsPathAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeNextHop:
-			n, _ := ptypes.MarshalAny(NewNextHopAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeMultiExitDisc:
-			n, _ := ptypes.MarshalAny(NewMultiExitDiscAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeLocalPref:
-			n, _ := ptypes.MarshalAny(NewLocalPrefAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAtomicAggregate:
-			n, _ := ptypes.MarshalAny(NewAtomicAggregateAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAggregator:
-			n, _ := ptypes.MarshalAny(NewAggregatorAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeCommunities:
-			n, _ := ptypes.MarshalAny(NewCommunitiesAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeOriginatorId:
-			n, _ := ptypes.MarshalAny(NewOriginatorIdAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeClusterList:
-			n, _ := ptypes.MarshalAny(NewClusterListAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeMpReachNLRI:
-			n, _ := ptypes.MarshalAny(NewMpReachNLRIAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeMpUnreachNLRI:
-			n, _ := ptypes.MarshalAny(NewMpUnreachNLRIAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeExtendedCommunities:
-			n, _ := ptypes.MarshalAny(NewExtendedCommunitiesAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAs4Path:
-			n, _ := ptypes.MarshalAny(NewAs4PathAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAs4Aggregator:
-			n, _ := ptypes.MarshalAny(NewAs4AggregatorAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributePmsiTunnel:
-			n, _ := ptypes.MarshalAny(NewPmsiTunnelAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeTunnelEncap:
-			n, _ := ptypes.MarshalAny(NewTunnelEncapAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeIP6ExtendedCommunities:
-			n, _ := ptypes.MarshalAny(NewIP6ExtendedCommunitiesAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeAigp:
-			n, _ := ptypes.MarshalAny(NewAigpAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeLargeCommunities:
-			n, _ := ptypes.MarshalAny(NewLargeCommunitiesAttributeFromNative(a))
-			anyList = append(anyList, n)
-		case *bgp.PathAttributeUnknown:
-			n, _ := ptypes.MarshalAny(NewUnknownAttributeFromNative(a))
-			anyList = append(anyList, n)
-		}
-	}
-	return anyList
-}
-
-func UnmarshalPathAttributes(values []*any.Any) ([]bgp.PathAttributeInterface, error) {
-	attrList := make([]bgp.PathAttributeInterface, 0, len(values))
-	typeMap := make(map[bgp.BGPAttrType]struct{})
-	for _, an := range values {
-		var attr bgp.PathAttributeInterface
-		var value ptypes.DynamicAny
-		err := ptypes.UnmarshalAny(an, &value)
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmarshal path attribute: %s", err)
-		}
-		switch v := value.Message.(type) {
-		case *OriginAttribute:
-			attr, err = v.ToNative()
-		case *AsPathAttribute:
-			attr, err = v.ToNative()
-		case *NextHopAttribute:
-			attr, err = v.ToNative()
-		case *MultiExitDiscAttribute:
-			attr, err = v.ToNative()
-		case *LocalPrefAttribute:
-			attr, err = v.ToNative()
-		case *AtomicAggregateAttribute:
-			attr, err = v.ToNative()
-		case *AggregatorAttribute:
-			attr, err = v.ToNative()
-		case *CommunitiesAttribute:
-			attr, err = v.ToNative()
-		case *OriginatorIdAttribute:
-			attr, err = v.ToNative()
-		case *ClusterListAttribute:
-			attr, err = v.ToNative()
-		case *MpReachNLRIAttribute:
-			var nlri *bgp.PathAttributeMpReachNLRI
-			nlri, err = v.ToNative()
-			if len(nlri.Value) > 1 {
-				return nil, fmt.Errorf("multiple nlri in a single mp_reach_nlri are not supported")
-			}
-			attr = nlri
-		case *MpUnreachNLRIAttribute:
-			attr, err = v.ToNative()
-		case *ExtendedCommunitiesAttribute:
-			attr, err = v.ToNative()
-		case *As4PathAttribute:
-			attr, err = v.ToNative()
-		case *As4AggregatorAttribute:
-			attr, err = v.ToNative()
-		case *PmsiTunnelAttribute:
-			attr, err = v.ToNative()
-		case *TunnelEncapAttribute:
-			attr, err = v.ToNative()
-		case *IP6ExtendedCommunitiesAttribute:
-			attr, err = v.ToNative()
-		case *AigpAttribute:
-			attr, err = v.ToNative()
-		case *LargeCommunitiesAttribute:
-			attr, err = v.ToNative()
-		case *UnknownAttribute:
-			attr, err = v.ToNative()
-		}
-		if err != nil {
-			return nil, err
-		}
-		if attr == nil {
-			return nil, fmt.Errorf("invalid value type for path attribute: %s", value.Message)
-		}
-		if _, ok := typeMap[attr.GetType()]; ok {
-			return nil, fmt.Errorf("duplicated path attribute type: %d", attr.GetType())
-		}
-		typeMap[attr.GetType()] = struct{}{}
-		attrList = append(attrList, attr)
-	}
-	return attrList, nil
-}
diff --git a/api/attribute_test.go b/api/attribute_test.go
deleted file mode 100644
index 72b20bf1..00000000
--- a/api/attribute_test.go
+++ /dev/null
@@ -1,1415 +0,0 @@
-// Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
-//
-// 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 gobgpapi
-
-import (
-	"net"
-	"testing"
-
-	"github.com/golang/protobuf/ptypes"
-	"github.com/golang/protobuf/ptypes/any"
-	"github.com/osrg/gobgp/pkg/packet/bgp"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_OriginAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &OriginAttribute{
-		Origin: 0, // IGP
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewOriginAttributeFromNative(n)
-	assert.Equal(input.Origin, output.Origin)
-}
-
-func Test_AsPathAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &AsPathAttribute{
-		Segments: []*AsSegment{
-			{
-				Type:    1, // SET
-				Numbers: []uint32{100, 200},
-			},
-			{
-				Type:    2, // SEQ
-				Numbers: []uint32{300, 400},
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAsPathAttributeFromNative(n)
-	assert.Equal(2, len(output.Segments))
-	assert.Equal(input.Segments, output.Segments)
-}
-
-func Test_NextHopAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &NextHopAttribute{
-		NextHop: "192.168.0.1",
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewNextHopAttributeFromNative(n)
-	assert.Equal(input.NextHop, output.NextHop)
-}
-
-func Test_MultiExitDiscAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &MultiExitDiscAttribute{
-		Med: 100,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMultiExitDiscAttributeFromNative(n)
-	assert.Equal(input.Med, output.Med)
-}
-
-func Test_LocalPrefAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &LocalPrefAttribute{
-		LocalPref: 100,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewLocalPrefAttributeFromNative(n)
-	assert.Equal(input.LocalPref, output.LocalPref)
-}
-
-func Test_AtomicAggregateAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &AtomicAggregateAttribute{}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAtomicAggregateAttributeFromNative(n)
-	// AtomicAggregateAttribute has no value
-	assert.NotNil(output)
-}
-
-func Test_AggregatorAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &AggregatorAttribute{
-		As:      65000,
-		Address: "1.1.1.1",
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAggregatorAttributeFromNative(n)
-	assert.Equal(input.As, output.As)
-	assert.Equal(input.Address, output.Address)
-}
-
-func Test_CommunitiesAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &CommunitiesAttribute{
-		Communities: []uint32{100, 200},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewCommunitiesAttributeFromNative(n)
-	assert.Equal(input.Communities, output.Communities)
-}
-
-func Test_OriginatorIdAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &OriginatorIdAttribute{
-		Id: "1.1.1.1",
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewOriginatorIdAttributeFromNative(n)
-	assert.Equal(input.Id, output.Id)
-}
-
-func Test_ClusterListAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &ClusterListAttribute{
-		Ids: []string{"1.1.1.1", "2.2.2.2"},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewClusterListAttributeFromNative(n)
-	assert.Equal(input.Ids, output.Ids)
-}
-
-func Test_MpReachNLRIAttribute_IPv4_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 24,
-		Prefix:    "192.168.201.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv4_UC),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv6_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 64,
-		Prefix:    "2001:db8:1::",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 64,
-		Prefix:    "2001:db8:2::",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv6_UC),
-		NextHops: []string{"2001:db8::1", "2001:db8::2"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv4_MPLS(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&LabeledIPAddressPrefix{
-		Labels:    []uint32{100},
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&LabeledIPAddressPrefix{
-		Labels:    []uint32{200},
-		PrefixLen: 24,
-		Prefix:    "192.168.201.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv4_MPLS),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv6_MPLS(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&LabeledIPAddressPrefix{
-		Labels:    []uint32{100},
-		PrefixLen: 64,
-		Prefix:    "2001:db8:1::",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&LabeledIPAddressPrefix{
-		Labels:    []uint32{200},
-		PrefixLen: 64,
-		Prefix:    "2001:db8:2::",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv6_MPLS),
-		NextHops: []string{"2001:db8::1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv4_ENCAP(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&EncapsulationNLRI{
-		Address: "192.168.101.1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&EncapsulationNLRI{
-		Address: "192.168.201.1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv4_ENCAP),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv6_ENCAP(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&EncapsulationNLRI{
-		Address: "2001:db8:1::1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&EncapsulationNLRI{
-		Address: "2001:db8:2::1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv6_ENCAP),
-		NextHops: []string{"2001:db8::1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_EVPN_AD_Route(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherTwoOctetAS{
-		Admin:    65000,
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	esi := &EthernetSegmentIdentifier{
-		Type:  0,
-		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
-	}
-	a, err := ptypes.MarshalAny(&EVPNEthernetAutoDiscoveryRoute{
-		Rd:          rd,
-		Esi:         esi,
-		EthernetTag: 100,
-		Label:       200,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_EVPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_EVPN_MAC_IP_Route(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	esi := &EthernetSegmentIdentifier{
-		Type:  0,
-		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
-	}
-	a, err := ptypes.MarshalAny(&EVPNMACIPAdvertisementRoute{
-		Rd:          rd,
-		Esi:         esi,
-		EthernetTag: 100,
-		MacAddress:  "aa:bb:cc:dd:ee:ff",
-		IpAddress:   "192.168.101.1",
-		Labels:      []uint32{200},
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_EVPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_EVPN_MC_Route(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherFourOctetAS{
-		Admin:    65000,
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	a, err := ptypes.MarshalAny(&EVPNInclusiveMulticastEthernetTagRoute{
-		Rd:          rd,
-		EthernetTag: 100,
-		IpAddress:   "192.168.101.1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_EVPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_EVPN_ES_Route(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	esi := &EthernetSegmentIdentifier{
-		Type:  0,
-		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
-	}
-	a, err := ptypes.MarshalAny(&EVPNEthernetSegmentRoute{
-		Rd:        rd,
-		Esi:       esi,
-		IpAddress: "192.168.101.1",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_EVPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_EVPN_Prefix_Route(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	esi := &EthernetSegmentIdentifier{
-		Type:  0,
-		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
-	}
-	a, err := ptypes.MarshalAny(&EVPNIPPrefixRoute{
-		Rd:          rd,
-		Esi:         esi,
-		EthernetTag: 100,
-		IpPrefixLen: 24,
-		IpPrefix:    "192.168.101.0",
-		Label:       200,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_EVPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv4_VPN(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	a, err := ptypes.MarshalAny(&LabeledVPNIPAddressPrefix{
-		Labels:    []uint32{100, 200},
-		Rd:        rd,
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv4_VPN),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_IPv6_VPN(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-	a, err := ptypes.MarshalAny(&LabeledVPNIPAddressPrefix{
-		Labels:    []uint32{100, 200},
-		Rd:        rd,
-		PrefixLen: 64,
-		Prefix:    "2001:db8:1::",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_IPv6_VPN),
-		NextHops: []string{"2001:db8::1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_RTC_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 1)
-	rt, err := ptypes.MarshalAny(&IPv4AddressSpecificExtended{
-		IsTransitive: true,
-		SubType:      0x02, // Route Target
-		Address:      "1.1.1.1",
-		LocalAdmin:   100,
-	})
-	assert.Nil(err)
-	a, err := ptypes.MarshalAny(&RouteTargetMembershipNLRI{
-		As: 65000,
-		Rt: rt,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family:   uint32(bgp.RF_RTC_UC),
-		NextHops: []string{"192.168.1.1"},
-		Nlris:    nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_FS_IPv4_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	rules := make([]*any.Any, 0, 3)
-	rule, err := ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      1, // Destination Prefix
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      2, // Source Prefix
-		PrefixLen: 24,
-		Prefix:    "192.168.201.0",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecComponent{
-		Type: 3, // IP Protocol
-		Items: []*FlowSpecComponentItem{
-			{
-				Op:    0x80 | 0x01, // End, EQ
-				Value: 6,           // TCP
-			},
-		},
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-
-	nlris := make([]*any.Any, 0, 1)
-	a, err := ptypes.MarshalAny(&FlowSpecNLRI{
-		Rules: rules,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family: uint32(bgp.RF_FS_IPv4_UC),
-		// NextHops: // No nexthop required
-		Nlris: nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_FS_IPv4_VPN(t *testing.T) {
-	assert := assert.New(t)
-
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-
-	rules := make([]*any.Any, 0, 3)
-	rule, err := ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      1, // Destination Prefix
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      2, // Source Prefix
-		PrefixLen: 24,
-		Prefix:    "192.168.201.0",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecComponent{
-		Type: 3, // IP Protocol
-		Items: []*FlowSpecComponentItem{
-			{
-				Op:    0x80 | 0x01, // End, EQ
-				Value: 6,           // TCP
-			},
-		},
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-
-	nlris := make([]*any.Any, 0, 1)
-	a, err := ptypes.MarshalAny(&VPNFlowSpecNLRI{
-		Rd:    rd,
-		Rules: rules,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family: uint32(bgp.RF_FS_IPv4_VPN),
-		// NextHops: // No nexthop required
-		Nlris: nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_FS_IPv6_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	rules := make([]*any.Any, 0, 3)
-	rule, err := ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      1, // Destination Prefix
-		PrefixLen: 64,
-		Prefix:    "2001:db8:1::",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      2, // Source Prefix
-		PrefixLen: 64,
-		Prefix:    "2001:db8:2::",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecComponent{
-		Type: 3, // Next Header
-		Items: []*FlowSpecComponentItem{
-			{
-				Op:    0x80 | 0x01, // End, EQ
-				Value: 6,           // TCP
-			},
-		},
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-
-	nlris := make([]*any.Any, 0, 1)
-	a, err := ptypes.MarshalAny(&FlowSpecNLRI{
-		Rules: rules,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family: uint32(bgp.RF_FS_IPv6_UC),
-		// NextHops: // No nexthop required
-		Nlris: nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_FS_IPv6_VPN(t *testing.T) {
-	assert := assert.New(t)
-
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-
-	rules := make([]*any.Any, 0, 3)
-	rule, err := ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      1, // Destination Prefix
-		PrefixLen: 64,
-		Prefix:    "2001:db8:1::",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecIPPrefix{
-		Type:      2, // Source Prefix
-		PrefixLen: 64,
-		Prefix:    "2001:db8:2::",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecComponent{
-		Type: 3, // Next Header
-		Items: []*FlowSpecComponentItem{
-			{
-				Op:    0x80 | 0x01, // End, EQ
-				Value: 6,           // TCP
-			},
-		},
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-
-	nlris := make([]*any.Any, 0, 1)
-	a, err := ptypes.MarshalAny(&VPNFlowSpecNLRI{
-		Rd:    rd,
-		Rules: rules,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family: uint32(bgp.RF_FS_IPv6_VPN),
-		// NextHops: // No nexthop required
-		Nlris: nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpReachNLRIAttribute_FS_L2_VPN(t *testing.T) {
-	assert := assert.New(t)
-
-	rd, err := ptypes.MarshalAny(&RouteDistinguisherIPAddress{
-		Admin:    "1.1.1.1",
-		Assigned: 100,
-	})
-	assert.Nil(err)
-
-	rules := make([]*any.Any, 0, 3)
-	rule, err := ptypes.MarshalAny(&FlowSpecMAC{
-		Type:    15, // Source MAC
-		Address: "aa:bb:cc:11:22:33",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecMAC{
-		Type:    16, // Destination MAC
-		Address: "dd:ee:ff:11:22:33",
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-	rule, err = ptypes.MarshalAny(&FlowSpecComponent{
-		Type: 21, // VLAN ID
-		Items: []*FlowSpecComponentItem{
-			{
-				Op:    0x80 | 0x01, // End, EQ
-				Value: 100,
-			},
-		},
-	})
-	assert.Nil(err)
-	rules = append(rules, rule)
-
-	nlris := make([]*any.Any, 0, 1)
-	a, err := ptypes.MarshalAny(&VPNFlowSpecNLRI{
-		Rd:    rd,
-		Rules: rules,
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpReachNLRIAttribute{
-		Family: uint32(bgp.RF_FS_L2_VPN),
-		// NextHops: // No nexthop required
-		Nlris: nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpReachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(input.NextHops, output.NextHops)
-	assert.Equal(1, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_MpUnreachNLRIAttribute_IPv4_UC(t *testing.T) {
-	assert := assert.New(t)
-
-	nlris := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 24,
-		Prefix:    "192.168.101.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-	a, err = ptypes.MarshalAny(&IPAddressPrefix{
-		PrefixLen: 24,
-		Prefix:    "192.168.201.0",
-	})
-	assert.Nil(err)
-	nlris = append(nlris, a)
-
-	input := &MpUnreachNLRIAttribute{
-		Family: uint32(bgp.RF_IPv4_UC),
-		Nlris:  nlris,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewMpUnreachNLRIAttributeFromNative(n)
-	assert.Equal(input.Family, output.Family)
-	assert.Equal(2, len(output.Nlris))
-	for idx, inputNLRI := range input.Nlris {
-		outputNLRI := output.Nlris[idx]
-		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
-		assert.Equal(inputNLRI.Value, outputNLRI.Value)
-	}
-}
-
-func Test_ExtendedCommunitiesAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	communities := make([]*any.Any, 0, 19)
-	a, err := ptypes.MarshalAny(&TwoOctetAsSpecificExtended{
-		IsTransitive: true,
-		SubType:      0x02, // ROUTE_TARGET
-		As:           65001,
-		LocalAdmin:   100,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&IPv4AddressSpecificExtended{
-		IsTransitive: true,
-		SubType:      0x02, // ROUTE_TARGET
-		Address:      "2.2.2.2",
-		LocalAdmin:   200,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&FourOctetAsSpecificExtended{
-		IsTransitive: true,
-		SubType:      0x02, // ROUTE_TARGET
-		As:           65003,
-		LocalAdmin:   300,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&ValidationExtended{
-		State: 0, // VALID
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&ColorExtended{
-		Color: 400,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&EncapExtended{
-		TunnelType: 8, // VXLAN
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&DefaultGatewayExtended{
-		// No value
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&OpaqueExtended{
-		IsTransitive: true,
-		Value:        []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&ESILabelExtended{
-		IsSingleActive: true,
-		Label:          500,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&ESImportRouteTarget{
-		EsImport: "aa:bb:cc:dd:ee:ff",
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&MacMobilityExtended{
-		IsSticky:    true,
-		SequenceNum: 1,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&RouterMacExtended{
-		Mac: "ff:ee:dd:cc:bb:aa",
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&TrafficRateExtended{
-		As:   65004,
-		Rate: 100.0,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&TrafficActionExtended{
-		Terminal: true,
-		Sample:   false,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&RedirectTwoOctetAsSpecificExtended{
-		As:         65005,
-		LocalAdmin: 500,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&RedirectIPv4AddressSpecificExtended{
-		Address:    "6.6.6.6",
-		LocalAdmin: 600,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&RedirectFourOctetAsSpecificExtended{
-		As:         65007,
-		LocalAdmin: 700,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&TrafficRemarkExtended{
-		Dscp: 0x0a, // AF11
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&UnknownExtended{
-		Type:  0xff, // Max of uint8
-		Value: []byte{1, 2, 3, 4, 5, 6, 7},
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-
-	input := &ExtendedCommunitiesAttribute{
-		Communities: communities,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewExtendedCommunitiesAttributeFromNative(n)
-	assert.Equal(19, len(output.Communities))
-	for idx, inputCommunity := range input.Communities {
-		outputCommunity := output.Communities[idx]
-		assert.Equal(inputCommunity.TypeUrl, outputCommunity.TypeUrl)
-		assert.Equal(inputCommunity.Value, outputCommunity.Value)
-	}
-}
-
-func Test_As4PathAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &As4PathAttribute{
-		Segments: []*AsSegment{
-			{
-				Type:    1, // SET
-				Numbers: []uint32{100, 200},
-			},
-			{
-				Type:    2, // SEQ
-				Numbers: []uint32{300, 400},
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAs4PathAttributeFromNative(n)
-	assert.Equal(2, len(output.Segments))
-	assert.Equal(input.Segments, output.Segments)
-}
-
-func Test_As4AggregatorAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &As4AggregatorAttribute{
-		As:      65000,
-		Address: "1.1.1.1",
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAs4AggregatorAttributeFromNative(n)
-	assert.Equal(input.As, output.As)
-	assert.Equal(input.Address, output.Address)
-}
-
-func Test_PmsiTunnelAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &PmsiTunnelAttribute{
-		Flags: 0x01, // IsLeafInfoRequired = true
-		Type:  6,    // INGRESS_REPL
-		Label: 100,
-		Id:    net.ParseIP("1.1.1.1").To4(), // IngressReplTunnelID with IPv4
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewPmsiTunnelAttributeFromNative(n)
-	assert.Equal(input.Flags, output.Flags)
-	assert.Equal(input.Type, output.Type)
-	assert.Equal(input.Label, output.Label)
-	assert.Equal(input.Id, output.Id)
-}
-
-func Test_TunnelEncapAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	subTlvs := make([]*any.Any, 0, 4)
-	a, err := ptypes.MarshalAny(&TunnelEncapSubTLVEncapsulation{
-		Key:    100,
-		Cookie: []byte{0x11, 0x22, 0x33, 0x44},
-	})
-	assert.Nil(err)
-	subTlvs = append(subTlvs, a)
-	a, err = ptypes.MarshalAny(&TunnelEncapSubTLVProtocol{
-		Protocol: 200,
-	})
-	assert.Nil(err)
-	subTlvs = append(subTlvs, a)
-	a, err = ptypes.MarshalAny(&TunnelEncapSubTLVColor{
-		Color: 300,
-	})
-	assert.Nil(err)
-	subTlvs = append(subTlvs, a)
-	a, err = ptypes.MarshalAny(&TunnelEncapSubTLVUnknown{
-		Type:  0xff, // Max of uint8
-		Value: []byte{0x55, 0x66, 0x77, 0x88},
-	})
-	assert.Nil(err)
-	subTlvs = append(subTlvs, a)
-
-	input := &TunnelEncapAttribute{
-		Tlvs: []*TunnelEncapTLV{
-			{
-				Type: 8, // VXLAN
-				Tlvs: subTlvs,
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewTunnelEncapAttributeFromNative(n)
-	assert.Equal(1, len(output.Tlvs))
-	assert.Equal(input.Tlvs[0].Type, output.Tlvs[0].Type)
-	assert.Equal(len(output.Tlvs[0].Tlvs), len(output.Tlvs[0].Tlvs))
-	for idx, inputSubTlv := range input.Tlvs[0].Tlvs {
-		outputSubTlv := output.Tlvs[0].Tlvs[idx]
-		assert.Equal(inputSubTlv.TypeUrl, outputSubTlv.TypeUrl)
-		assert.Equal(inputSubTlv.Value, outputSubTlv.Value)
-	}
-}
-
-func Test_IP6ExtendedCommunitiesAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	communities := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&IPv6AddressSpecificExtended{
-		IsTransitive: true,
-		SubType:      0xff, // Max of uint8
-		Address:      "2001:db8:1::1",
-		LocalAdmin:   100,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-	a, err = ptypes.MarshalAny(&RedirectIPv6AddressSpecificExtended{
-		Address:    "2001:db8:2::1",
-		LocalAdmin: 200,
-	})
-	assert.Nil(err)
-	communities = append(communities, a)
-
-	input := &IP6ExtendedCommunitiesAttribute{
-		Communities: communities,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewIP6ExtendedCommunitiesAttributeFromNative(n)
-	assert.Equal(2, len(output.Communities))
-	for idx, inputCommunity := range input.Communities {
-		outputCommunity := output.Communities[idx]
-		assert.Equal(inputCommunity.TypeUrl, outputCommunity.TypeUrl)
-		assert.Equal(inputCommunity.Value, outputCommunity.Value)
-	}
-}
-
-func Test_AigpAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	tlvs := make([]*any.Any, 0, 2)
-	a, err := ptypes.MarshalAny(&AigpTLVIGPMetric{
-		Metric: 50,
-	})
-	assert.Nil(err)
-	tlvs = append(tlvs, a)
-	a, err = ptypes.MarshalAny(&AigpTLVUnknown{
-		Type:  0xff, // Max of uint8
-		Value: []byte{0x11, 0x22, 0x33, 0x44},
-	})
-	assert.Nil(err)
-	tlvs = append(tlvs, a)
-
-	input := &AigpAttribute{
-		Tlvs: tlvs,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewAigpAttributeFromNative(n)
-	assert.Equal(2, len(output.Tlvs))
-	for idx, inputTlv := range input.Tlvs {
-		outputTlv := output.Tlvs[idx]
-		assert.Equal(inputTlv.TypeUrl, outputTlv.TypeUrl)
-		assert.Equal(inputTlv.Value, outputTlv.Value)
-	}
-}
-
-func Test_LargeCommunitiesAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &LargeCommunitiesAttribute{
-		Communities: []*LargeCommunity{
-			{
-				GlobalAdmin: 65001,
-				LocalData1:  100,
-				LocalData2:  200,
-			},
-			{
-				GlobalAdmin: 65002,
-				LocalData1:  300,
-				LocalData2:  400,
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewLargeCommunitiesAttributeFromNative(n)
-	assert.Equal(2, len(output.Communities))
-	assert.Equal(input.Communities, output.Communities)
-}
-
-func Test_UnknownAttribute(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &UnknownAttribute{
-		Flags: (1 << 6) | (1 << 7), // OPTIONAL and TRANSITIVE
-		Type:  0xff,
-		Value: []byte{0x11, 0x22, 0x33, 0x44},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewUnknownAttributeFromNative(n)
-	assert.Equal(input.Flags, output.Flags)
-	assert.Equal(input.Type, output.Type)
-	assert.Equal(input.Value, output.Value)
-}
diff --git a/api/capability.go b/api/capability.go
deleted file mode 100644
index 15231bbb..00000000
--- a/api/capability.go
+++ /dev/null
@@ -1,287 +0,0 @@
-// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation.
-//
-// 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 gobgpapi
-
-import (
-	"fmt"
-
-	proto "github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/ptypes"
-	"github.com/golang/protobuf/ptypes/any"
-	"github.com/osrg/gobgp/pkg/packet/bgp"
-)
-
-func NewMultiProtocolCapability(a *bgp.CapMultiProtocol) *MultiProtocolCapability {
-	return &MultiProtocolCapability{
-		Family: Family(a.CapValue),
-	}
-}
-
-func (a *MultiProtocolCapability) ToNative() (*bgp.CapMultiProtocol, error) {
-	return bgp.NewCapMultiProtocol(bgp.RouteFamily(a.Family)), nil
-}
-
-func NewRouteRefreshCapability(a *bgp.CapRouteRefresh) *RouteRefreshCapability {
-	return &RouteRefreshCapability{}
-}
-
-func (a *RouteRefreshCapability) ToNative() (*bgp.CapRouteRefresh, error) {
-	return bgp.NewCapRouteRefresh(), nil
-}
-
-func NewCarryingLabelInfoCapability(a *bgp.CapCarryingLabelInfo) *CarryingLabelInfoCapability {
-	return &CarryingLabelInfoCapability{}
-}
-
-func (a *CarryingLabelInfoCapability) ToNative() (*bgp.CapCarryingLabelInfo, error) {
-	return bgp.NewCapCarryingLabelInfo(), nil
-}
-
-func NewExtendedNexthopCapability(a *bgp.CapExtendedNexthop) *ExtendedNexthopCapability {
-	tuples := make([]*ExtendedNexthopCapabilityTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		tuples = append(tuples, &ExtendedNexthopCapabilityTuple{
-			NlriFamily:    Family(bgp.AfiSafiToRouteFamily(t.NLRIAFI, uint8(t.NLRISAFI))),
-			NexthopFamily: Family(bgp.AfiSafiToRouteFamily(t.NexthopAFI, bgp.SAFI_UNICAST)),
-		})
-	}
-	return &ExtendedNexthopCapability{
-		Tuples: tuples,
-	}
-}
-
-func (a *ExtendedNexthopCapability) ToNative() (*bgp.CapExtendedNexthop, error) {
-	tuples := make([]*bgp.CapExtendedNexthopTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		var nhAfi uint16
-		switch t.NexthopFamily {
-		case Family_IPv4:
-			nhAfi = bgp.AFI_IP
-		case Family_IPv6:
-			nhAfi = bgp.AFI_IP6
-		default:
-			return nil, fmt.Errorf("invalid address family for nexthop afi in extended nexthop capability: %s", t.NexthopFamily)
-		}
-		tuples = append(tuples, bgp.NewCapExtendedNexthopTuple(bgp.RouteFamily(t.NlriFamily), nhAfi))
-	}
-	return bgp.NewCapExtendedNexthop(tuples), nil
-}
-
-func NewGracefulRestartCapability(a *bgp.CapGracefulRestart) *GracefulRestartCapability {
-	tuples := make([]*GracefulRestartCapabilityTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		tuples = append(tuples, &GracefulRestartCapabilityTuple{
-			Family: Family(bgp.AfiSafiToRouteFamily(t.AFI, uint8(t.SAFI))),
-			Flags:  uint32(t.Flags),
-		})
-	}
-	return &GracefulRestartCapability{
-		Flags:  uint32(a.Flags),
-		Time:   uint32(a.Time),
-		Tuples: tuples,
-	}
-}
-
-func (a *GracefulRestartCapability) ToNative() (*bgp.CapGracefulRestart, error) {
-	tuples := make([]*bgp.CapGracefulRestartTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		var forward bool
-		if t.Flags&0x80 > 0 {
-			forward = true
-		}
-		tuples = append(tuples, bgp.NewCapGracefulRestartTuple(bgp.RouteFamily(t.Family), forward))
-	}
-	var restarting bool
-	if a.Flags&0x08 > 0 {
-		restarting = true
-	}
-	var notification bool
-	if a.Flags&0x04 > 0 {
-		notification = true
-	}
-	return bgp.NewCapGracefulRestart(restarting, notification, uint16(a.Time), tuples), nil
-}
-
-func NewFourOctetASNumberCapability(a *bgp.CapFourOctetASNumber) *FourOctetASNumberCapability {
-	return &FourOctetASNumberCapability{
-		As: a.CapValue,
-	}
-}
-
-func (a *FourOctetASNumberCapability) ToNative() (*bgp.CapFourOctetASNumber, error) {
-	return bgp.NewCapFourOctetASNumber(a.As), nil
-}
-
-func NewAddPathCapability(a *bgp.CapAddPath) *AddPathCapability {
-	tuples := make([]*AddPathCapabilityTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		tuples = append(tuples, &AddPathCapabilityTuple{
-			Family: Family(t.RouteFamily),
-			Mode:   AddPathMode(t.Mode),
-		})
-	}
-	return &AddPathCapability{
-		Tuples: tuples,
-	}
-}
-
-func (a *AddPathCapability) ToNative() (*bgp.CapAddPath, error) {
-	tuples := make([]*bgp.CapAddPathTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		tuples = append(tuples, bgp.NewCapAddPathTuple(bgp.RouteFamily(t.Family), bgp.BGPAddPathMode(t.Mode)))
-	}
-	return bgp.NewCapAddPath(tuples), nil
-}
-
-func NewEnhancedRouteRefreshCapability(a *bgp.CapEnhancedRouteRefresh) *EnhancedRouteRefreshCapability {
-	return &EnhancedRouteRefreshCapability{}
-}
-
-func (a *EnhancedRouteRefreshCapability) ToNative() (*bgp.CapEnhancedRouteRefresh, error) {
-	return bgp.NewCapEnhancedRouteRefresh(), nil
-}
-
-func NewLongLivedGracefulRestartCapability(a *bgp.CapLongLivedGracefulRestart) *LongLivedGracefulRestartCapability {
-	tuples := make([]*LongLivedGracefulRestartCapabilityTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		tuples = append(tuples, &LongLivedGracefulRestartCapabilityTuple{
-			Family: Family(bgp.AfiSafiToRouteFamily(t.AFI, uint8(t.SAFI))),
-			Flags:  uint32(t.Flags),
-			Time:   t.RestartTime,
-		})
-	}
-	return &LongLivedGracefulRestartCapability{
-		Tuples: tuples,
-	}
-}
-
-func (a *LongLivedGracefulRestartCapability) ToNative() (*bgp.CapLongLivedGracefulRestart, error) {
-	tuples := make([]*bgp.CapLongLivedGracefulRestartTuple, 0, len(a.Tuples))
-	for _, t := range a.Tuples {
-		var forward bool
-		if t.Flags&0x80 > 0 {
-			forward = true
-		}
-		tuples = append(tuples, bgp.NewCapLongLivedGracefulRestartTuple(bgp.RouteFamily(t.Family), forward, t.Time))
-	}
-	return bgp.NewCapLongLivedGracefulRestart(tuples), nil
-}
-
-func NewRouteRefreshCiscoCapability(a *bgp.CapRouteRefreshCisco) *RouteRefreshCiscoCapability {
-	return &RouteRefreshCiscoCapability{}
-}
-
-func (a *RouteRefreshCiscoCapability) ToNative() (*bgp.CapRouteRefreshCisco, error) {
-	return bgp.NewCapRouteRefreshCisco(), nil
-}
-
-func NewUnknownCapability(a *bgp.CapUnknown) *UnknownCapability {
-	return &UnknownCapability{
-		Code:  uint32(a.CapCode),
-		Value: a.CapValue,
-	}
-}
-
-func (a *UnknownCapability) ToNative() (*bgp.CapUnknown, error) {
-	return bgp.NewCapUnknown(bgp.BGPCapabilityCode(a.Code), a.Value), nil
-}
-
-func MarshalCapability(value bgp.ParameterCapabilityInterface) (*any.Any, error) {
-	var m proto.Message
-	switch n := value.(type) {
-	case *bgp.CapMultiProtocol:
-		m = NewMultiProtocolCapability(n)
-	case *bgp.CapRouteRefresh:
-		m = NewRouteRefreshCapability(n)
-	case *bgp.CapCarryingLabelInfo:
-		m = NewCarryingLabelInfoCapability(n)
-	case *bgp.CapExtendedNexthop:
-		m = NewExtendedNexthopCapability(n)
-	case *bgp.CapGracefulRestart:
-		m = NewGracefulRestartCapability(n)
-	case *bgp.CapFourOctetASNumber:
-		m = NewFourOctetASNumberCapability(n)
-	case *bgp.CapAddPath:
-		m = NewAddPathCapability(n)
-	case *bgp.CapEnhancedRouteRefresh:
-		m = NewEnhancedRouteRefreshCapability(n)
-	case *bgp.CapLongLivedGracefulRestart:
-		m = NewLongLivedGracefulRestartCapability(n)
-	case *bgp.CapRouteRefreshCisco:
-		m = NewRouteRefreshCiscoCapability(n)
-	case *bgp.CapUnknown:
-		m = NewUnknownCapability(n)
-	default:
-		return nil, fmt.Errorf("invalid capability type to marshal: %+v", value)
-	}
-	return ptypes.MarshalAny(m)
-}
-
-func MarshalCapabilities(values []bgp.ParameterCapabilityInterface) ([]*any.Any, error) {
-	caps := make([]*any.Any, 0, len(values))
-	for _, value := range values {
-		a, err := MarshalCapability(value)
-		if err != nil {
-			return nil, err
-		}
-		caps = append(caps, a)
-	}
-	return caps, nil
-}
-
-func UnmarshalCapability(a *any.Any) (bgp.ParameterCapabilityInterface, error) {
-	var value ptypes.DynamicAny
-	if err := ptypes.UnmarshalAny(a, &value); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal capability: %s", err)
-	}
-	switch v := value.Message.(type) {
-	case *MultiProtocolCapability:
-		return v.ToNative()
-	case *RouteRefreshCapability:
-		return v.ToNative()
-	case *CarryingLabelInfoCapability:
-		return v.ToNative()
-	case *ExtendedNexthopCapability:
-		return v.ToNative()
-	case *GracefulRestartCapability:
-		return v.ToNative()
-	case *FourOctetASNumberCapability:
-		return v.ToNative()
-	case *AddPathCapability:
-		return v.ToNative()
-	case *EnhancedRouteRefreshCapability:
-		return v.ToNative()
-	case *LongLivedGracefulRestartCapability:
-		return v.ToNative()
-	case *RouteRefreshCiscoCapability:
-		return v.ToNative()
-	case *UnknownCapability:
-		return v.ToNative()
-	}
-	return nil, fmt.Errorf("invalid capability type to unmarshal: %s", a.TypeUrl)
-}
-
-func UnmarshalCapabilities(values []*any.Any) ([]bgp.ParameterCapabilityInterface, error) {
-	caps := make([]bgp.ParameterCapabilityInterface, 0, len(values))
-	for _, value := range values {
-		c, err := UnmarshalCapability(value)
-		if err != nil {
-			return nil, err
-		}
-		caps = append(caps, c)
-	}
-	return caps, nil
-}
diff --git a/api/capability_test.go b/api/capability_test.go
deleted file mode 100644
index a0c34db1..00000000
--- a/api/capability_test.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright (C) 2018 Nippon Telegraph and Telephone Corporation.
-//
-// 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 gobgpapi
-
-import (
-	"testing"
-
-	"github.com/osrg/gobgp/pkg/packet/bgp"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_MultiProtocolCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &MultiProtocolCapability{
-		Family: Family_IPv4,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(bgp.RF_IPv4_UC, n.CapValue)
-
-	output := NewMultiProtocolCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_RouteRefreshCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &RouteRefreshCapability{}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewRouteRefreshCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_CarryingLabelInfoCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &CarryingLabelInfoCapability{}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewCarryingLabelInfoCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_ExtendedNexthopCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &ExtendedNexthopCapability{
-		Tuples: []*ExtendedNexthopCapabilityTuple{
-			{
-				NlriFamily:    Family_IPv4,
-				NexthopFamily: Family_IPv6,
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(1, len(n.Tuples))
-	assert.Equal(uint16(bgp.AFI_IP), n.Tuples[0].NLRIAFI)
-	assert.Equal(uint16(bgp.SAFI_UNICAST), n.Tuples[0].NLRISAFI)
-	assert.Equal(uint16(bgp.AFI_IP6), n.Tuples[0].NexthopAFI)
-
-	output := NewExtendedNexthopCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_GracefulRestartCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &GracefulRestartCapability{
-		Flags: 0x08 | 0x04, // restarting|notification
-		Time:  90,
-		Tuples: []*GracefulRestartCapabilityTuple{
-			{
-				Family: Family_IPv4,
-				Flags:  0x80, // forward
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(1, len(n.Tuples))
-	assert.Equal(uint8(0x08|0x04), n.Flags)
-	assert.Equal(uint16(90), n.Time)
-	assert.Equal(uint16(bgp.AFI_IP), n.Tuples[0].AFI)
-	assert.Equal(uint8(bgp.SAFI_UNICAST), n.Tuples[0].SAFI)
-	assert.Equal(uint8(0x80), n.Tuples[0].Flags)
-
-	output := NewGracefulRestartCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_FourOctetASNumberCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &FourOctetASNumberCapability{
-		As: 100,
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(uint32(100), n.CapValue)
-
-	output := NewFourOctetASNumberCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_AddPathCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &AddPathCapability{
-		Tuples: []*AddPathCapabilityTuple{
-			{
-				Family: Family_IPv4,
-				Mode:   AddPathMode_MODE_BOTH,
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(1, len(n.Tuples))
-	assert.Equal(bgp.RF_IPv4_UC, n.Tuples[0].RouteFamily)
-	assert.Equal(bgp.BGP_ADD_PATH_BOTH, n.Tuples[0].Mode)
-
-	output := NewAddPathCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_EnhancedRouteRefreshCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &EnhancedRouteRefreshCapability{}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewEnhancedRouteRefreshCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_LongLivedGracefulRestartCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &LongLivedGracefulRestartCapability{
-		Tuples: []*LongLivedGracefulRestartCapabilityTuple{
-			{
-				Family: Family_IPv4,
-				Flags:  0x80, // forward
-				Time:   90,
-			},
-		},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(1, len(n.Tuples))
-	assert.Equal(uint16(bgp.AFI_IP), n.Tuples[0].AFI)
-	assert.Equal(uint8(bgp.SAFI_UNICAST), n.Tuples[0].SAFI)
-	assert.Equal(uint8(0x80), n.Tuples[0].Flags)
-	assert.Equal(uint32(90), n.Tuples[0].RestartTime)
-
-	output := NewLongLivedGracefulRestartCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_RouteRefreshCiscoCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &RouteRefreshCiscoCapability{}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-
-	output := NewRouteRefreshCiscoCapability(n)
-	assert.Equal(input, output)
-}
-
-func Test_UnknownCapability(t *testing.T) {
-	assert := assert.New(t)
-
-	input := &UnknownCapability{
-		Code:  0xff,
-		Value: []byte{0x11, 0x22, 0x33, 0x44},
-	}
-
-	n, err := input.ToNative()
-	assert.Nil(err)
-	assert.Equal(bgp.BGPCapabilityCode(0xff), n.CapCode)
-	assert.Equal([]byte{0x11, 0x22, 0x33, 0x44}, n.CapValue)
-
-	output := NewUnknownCapability(n)
-	assert.Equal(input, output)
-}
diff --git a/api/util.go b/api/util.go
deleted file mode 100644
index c06484c0..00000000
--- a/api/util.go
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
-//
-// 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 gobgpapi
-
-import (
-	"encoding/json"
-	"net"
-	"time"
-
-	"github.com/osrg/gobgp/pkg/packet/bgp"
-)
-
-func getNLRI(family bgp.RouteFamily, buf []byte) (bgp.AddrPrefixInterface, error) {
-	afi, safi := bgp.RouteFamilyToAfiSafi(family)
-	nlri, err := bgp.NewPrefixFromRouteFamily(afi, safi)
-	if err != nil {
-		return nil, err
-	}
-	if err := nlri.DecodeFromBytes(buf); err != nil {
-		return nil, err
-	}
-	return nlri, nil
-}
-
-func (d *Destination) MarshalJSON() ([]byte, error) {
-	return json.Marshal(d.Paths)
-}
-
-func NewPath(nlri bgp.AddrPrefixInterface, isWithdraw bool, attrs []bgp.PathAttributeInterface, age time.Time) *Path {
-	return &Path{
-		AnyNlri:    MarshalNLRI(nlri),
-		AnyPattrs:  MarshalPathAttributes(attrs),
-		Age:        age.Unix(),
-		IsWithdraw: isWithdraw,
-		Family:     uint32(bgp.AfiSafiToRouteFamily(nlri.AFI(), nlri.SAFI())),
-		Identifier: nlri.PathIdentifier(),
-	}
-}
-
-func (p *Path) MarshalJSON() ([]byte, error) {
-	nlri, err := p.GetNativeNlri()
-	if err != nil {
-		return nil, err
-	}
-	attrs, err := p.GetNativePathAttributes()
-	if err != nil {
-		return nil, err
-	}
-
-	return json.Marshal(struct {
-		Nlri       bgp.AddrPrefixInterface      `json:"nlri"`
-		Age        int64                        `json:"age"`
-		Best       bool                         `json:"best"`
-		Attrs      []bgp.PathAttributeInterface `json:"attrs"`
-		Stale      bool                         `json:"stale"`
-		Withdrawal bool                         `json:"withdrawal,omitempty"`
-		SourceID   net.IP                       `json:"source-id,omitempty"`
-		NeighborIP net.IP                       `json:"neighbor-ip,omitempty"`
-	}{
-		Nlri:       nlri,
-		Age:        p.Age,
-		Best:       p.Best,
-		Attrs:      attrs,
-		Stale:      p.Stale,
-		Withdrawal: p.IsWithdraw,
-		SourceID:   net.ParseIP(p.SourceId),
-		NeighborIP: net.ParseIP(p.NeighborIp),
-	})
-}
-
-func (p *Path) GetNativeNlri() (bgp.AddrPrefixInterface, error) {
-	if len(p.Nlri) > 0 {
-		return getNLRI(bgp.RouteFamily(p.Family), p.Nlri)
-	}
-	return UnmarshalNLRI(bgp.RouteFamily(p.Family), p.AnyNlri)
-}
-
-func (p *Path) GetNativePathAttributes() ([]bgp.PathAttributeInterface, error) {
-	pattrsLen := len(p.Pattrs)
-	if pattrsLen > 0 {
-		pattrs := make([]bgp.PathAttributeInterface, 0, pattrsLen)
-		for _, attr := range p.Pattrs {
-			a, err := bgp.GetPathAttribute(attr)
-			if err != nil {
-				return nil, err
-			}
-			err = a.DecodeFromBytes(attr)
-			if err != nil {
-				return nil, err
-			}
-			pattrs = append(pattrs, a)
-		}
-		return pattrs, nil
-	}
-	return UnmarshalPathAttributes(p.AnyPattrs)
-}