[bestpath_selection] fix bugs when handling withdraw routes

1 files changed, 1015 insertions, 221 deletions

diff --git a/table/table_manager_test.go b/table/table_manager_test.go
index 8b1d7e2c..20d056b7 100644
--- a/table/table_manager_test.go
+++ b/table/table_manager_test.go
@@ -20,18 +20,17 @@ import (
 	log "github.com/Sirupsen/logrus"
 	"github.com/osrg/gobgp/packet"
 	"github.com/stretchr/testify/assert"
-	"net"
 	"os"
 	"reflect"
 	"testing"
 )
 
-func getLogger() *log.Logger {
+func getLogger(lv log.Level) *log.Logger {
 	var l *log.Logger = &log.Logger{
 		Out:       os.Stderr,
 		Formatter: new(log.JSONFormatter),
 		Hooks:     make(map[log.Level][]log.Hook),
-		Level:     log.InfoLevel,
+		Level:     lv,
 	}
 	return l
 }
@@ -74,47 +73,46 @@ func peerR3() *Peer {
 func TestProcessBGPUpdate_0_select_onlypath_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	setLogger(getLogger())
 
 	bgpMessage := update_fromR1()
 	peer := peerR1()
 	pList, wList, err := tm.ProcessUpdate(peer, bgpMessage)
-	assert.Equal(t, len(pList), 1, "pList length should be 1")
-	assert.Equal(t, len(wList), 0, "wList length should be 0")
-	assert.NoError(t, err, "err should be nil")
+	assert.Equal(t, len(pList), 1)
+	assert.Equal(t, len(wList), 0)
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
 	expectedType := "*table.IPv4Path"
-	assert.Equal(t, reflect.TypeOf(path).String(), expectedType, "best path should be *table.IPv4Path")
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
 
 	// check PathAttribute
 	pathAttributes := bgpMessage.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin, "PathAttributeOrigin should be ", expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath, "PathAttributeAsPath should be ", expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr, "PathAttributeNextHop should be ", expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
-	assert.Equal(t, expectedMed, pathMed, "PathAttributeMed should be ", expectedMed)
+	assert.Equal(t, expectedMed, pathMed)
 
 	// check PathAttribute length
-	assert.Equal(t, 4, path.getPathAttributeMap().Len(), "PathAttribute length should be ", 4)
+	assert.Equal(t, 4, path.getPathAttributeMap().Len())
 
 	// check destination
 	expectedPrefix := "10.10.10.0"
-	assert.Equal(t, expectedPrefix, path.getPrefix().String(), "prefix should be ", expectedPrefix)
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
 	// check nexthop
 	expectedNexthop := "192.168.50.1"
-	assert.Equal(t, expectedNexthop, path.getNexthop().String(), "nexthop should be ", expectedNexthop)
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
 
 }
 
@@ -122,7 +120,6 @@ func TestProcessBGPUpdate_0_select_onlypath_ipv4(t *testing.T) {
 func TestProcessBGPUpdate_0_select_onlypath_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	setLogger(getLogger())
 
 	bgpMessage := update_fromR1_ipv6()
 	peer := peerR1()
@@ -134,36 +131,36 @@ func TestProcessBGPUpdate_0_select_onlypath_ipv6(t *testing.T) {
 	// check type
 	path := pList[0]
 	expectedType := "*table.IPv6Path"
-	assert.Equal(t, expectedType, reflect.TypeOf(path).String(), "best path should be *table.IPv6Path")
+	assert.Equal(t, expectedType, reflect.TypeOf(path).String())
 
 	// check PathAttribute
 	pathAttributes := bgpMessage.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr, "PathAttributeNextHop should be ", expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin, "PathAttributeOrigin should be ", expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath, "PathAttributeAsPath should be ", expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
-	assert.Equal(t, expectedMed, pathMed, "PathAttributeMed should be ", expectedMed)
+	assert.Equal(t, expectedMed, pathMed)
 
 	// check PathAttribute length
-	assert.Equal(t, 4, path.getPathAttributeMap().Len(), "PathAttribute length should be ", 4)
+	assert.Equal(t, 4, path.getPathAttributeMap().Len())
 
 	// check destination
 	expectedPrefix := "2001:123:123:1::"
-	assert.Equal(t, expectedPrefix, path.getPrefix().String(), "prefix should be ", expectedPrefix)
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
 	// check nexthop
 	expectedNexthop := "2001::192:168:50:1"
-	assert.Equal(t, expectedNexthop, path.getNexthop().String(), "nexthop should be ", expectedNexthop)
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
 
 }
 
@@ -171,7 +168,8 @@ func TestProcessBGPUpdate_0_select_onlypath_ipv6(t *testing.T) {
 func TestProcessBGPUpdate_1_select_high_localpref_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low localpref message
@@ -204,60 +202,62 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv4(t *testing.T) {
 
 	peer1 := peerR1()
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
-	assert.Equal(t, 1, len(pList), "pList length should be 1")
-	assert.Equal(t, 0, len(wList), "wList length should be 0")
-	assert.NoError(t, err, "err should be nil")
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
 
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
-	assert.Equal(t, 1, len(pList), "pList length should be 1")
-	assert.Equal(t, 0, len(wList), "wList length should be 0")
-	assert.NoError(t, err, "err should be nil")
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
 	expectedType := "*table.IPv4Path"
-	assert.Equal(t, reflect.TypeOf(path).String(), expectedType, "best path should be *table.IPv4Path")
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
 
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin, "PathAttributeOrigin should be ", expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath, "PathAttributeAsPath should be ", expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr, "PathAttributeNextHop should be ", expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
-	assert.Equal(t, expectedMed, pathMed, "PathAttributeMed should be ", expectedMed)
+	assert.Equal(t, expectedMed, pathMed)
 
 	// check PathAttribute length
-	assert.Equal(t, len(pathAttributes2), path.getPathAttributeMap().Len(), "PathAttribute length should be ", 4)
+	assert.Equal(t, len(pathAttributes2), path.getPathAttributeMap().Len())
 
 	// check destination
 	expectedPrefix := "10.10.10.0"
-	assert.Equal(t, expectedPrefix, path.getPrefix().String(), "prefix should be ", expectedPrefix)
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
 	// check nexthop
 	expectedNexthop := "192.168.50.1"
-	assert.Equal(t, expectedNexthop, path.getNexthop().String(), "nexthop should be ", expectedNexthop)
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
 
 }
 
 func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(0)
 	aspath1 := createAsPathAttribute([]uint16{65000})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -271,7 +271,8 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{65100, 65000})
-	mp_reach2 := createMpReach("2001::192:168:100:1", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref2 := bgp.NewPathAttributeLocalPref(200)
 
@@ -287,13 +288,13 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -305,15 +306,15 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -335,7 +336,8 @@ func TestProcessBGPUpdate_1_select_high_localpref_ipv6(t *testing.T) {
 func TestProcessBGPUpdate_2_select_local_origin_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low localpref message
@@ -387,15 +389,15 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv4(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -416,12 +418,14 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv4(t *testing.T) {
 func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(0)
 	aspath1 := createAsPathAttribute([]uint16{65000})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -435,7 +439,8 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{})
-	mp_reach2 := createMpReach("::", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("::",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref2 := bgp.NewPathAttributeLocalPref(100)
 
@@ -451,13 +456,13 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	var peer2 *Peer = nil
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -469,15 +474,15 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -499,61 +504,63 @@ func TestProcessBGPUpdate_2_select_local_origin_ipv6(t *testing.T) {
 func TestProcessBGPUpdate_3_select_aspath_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	bgpMessage1 := update_fromR2viaR1()
 	peer1 := peerR1()
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
-	assert.Equal(t, 1, len(pList), "pList length should be 1")
-	assert.Equal(t, 0, len(wList), "wList length should be 0")
-	assert.NoError(t, err, "err should be nil")
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
 	bgpMessage2 := update_fromR2()
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
-	assert.Equal(t, 1, len(pList), "pList length should be 1")
-	assert.Equal(t, 0, len(wList), "wList length should be 0")
-	assert.NoError(t, err, "err should be nil")
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
 	expectedType := "*table.IPv4Path"
-	assert.Equal(t, reflect.TypeOf(path).String(), expectedType, "best path should be *table.IPv4Path")
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
 
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin, "PathAttributeOrigin should be ", expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath, "PathAttributeAsPath should be ", expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr, "PathAttributeNextHop should be ", expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
-	assert.Equal(t, expectedMed, pathMed, "PathAttributeMed should be ", expectedMed)
+	assert.Equal(t, expectedMed, pathMed)
 
 	// check PathAttribute length
-	assert.Equal(t, 4, path.getPathAttributeMap().Len(), "PathAttribute length should be ", 4)
+	assert.Equal(t, 4, path.getPathAttributeMap().Len())
 
 	// check destination
 	expectedPrefix := "20.20.20.0"
-	assert.Equal(t, expectedPrefix, path.getPrefix().String(), "prefix should be ", expectedPrefix)
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
 	// check nexthop
 	expectedNexthop := "192.168.100.1"
-	assert.Equal(t, expectedNexthop, path.getNexthop().String(), "nexthop should be ", expectedNexthop)
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
 
 }
 
 func TestProcessBGPUpdate_3_select_aspath_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	bgpMessage1 := update_fromR2viaR1_ipv6()
@@ -561,47 +568,47 @@ func TestProcessBGPUpdate_3_select_aspath_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 	bgpMessage2 := update_fromR2_ipv6()
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
 	expectedType := "*table.IPv6Path"
-	assert.Equal(t, reflect.TypeOf(path).String(), expectedType, "best path should be *table.IPv6Path")
+	assert.Equal(t, expectedType, reflect.TypeOf(path).String())
 
 	// check PathAttribute
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr, "PathAttributeNextHop should be ", expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin, "PathAttributeOrigin should be ", expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath, "PathAttributeAsPath should be ", expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
-	assert.Equal(t, expectedMed, pathMed, "PathAttributeMed should be ", expectedMed)
+	assert.Equal(t, expectedMed, pathMed)
 
 	// check PathAttribute length
-	assert.Equal(t, 4, path.getPathAttributeMap().Len(), "PathAttribute length should be ", 4)
+	assert.Equal(t, 4, path.getPathAttributeMap().Len())
 
 	// check destination
 	expectedPrefix := "2002:223:123:1::"
-	assert.Equal(t, expectedPrefix, path.getPrefix().String(), "prefix should be ", expectedPrefix)
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
 	// check nexthop
 	expectedNexthop := "2001::192:168:100:1"
-	assert.Equal(t, expectedNexthop, path.getNexthop().String(), "nexthop should be ", expectedNexthop)
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
 
 }
 
@@ -609,7 +616,8 @@ func TestProcessBGPUpdate_3_select_aspath_ipv6(t *testing.T) {
 func TestProcessBGPUpdate_4_select_low_origin_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low origin message
@@ -661,15 +669,15 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv4(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -690,12 +698,14 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv4(t *testing.T) {
 func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(1)
 	aspath1 := createAsPathAttribute([]uint16{65200, 65000})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -709,7 +719,8 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{65100, 65000})
-	mp_reach2 := createMpReach("2001::192:168:100:1", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(100)
 	localpref2 := bgp.NewPathAttributeLocalPref(200)
 
@@ -725,13 +736,13 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -743,15 +754,15 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -773,7 +784,8 @@ func TestProcessBGPUpdate_4_select_low_origin_ipv6(t *testing.T) {
 func TestProcessBGPUpdate_5_select_low_med_ipv4(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low origin message
@@ -825,15 +837,15 @@ func TestProcessBGPUpdate_5_select_low_med_ipv4(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -854,12 +866,14 @@ func TestProcessBGPUpdate_5_select_low_med_ipv4(t *testing.T) {
 func TestProcessBGPUpdate_5_select_low_med_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(0)
 	aspath1 := createAsPathAttribute([]uint16{65200, 65000})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(500)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -873,7 +887,8 @@ func TestProcessBGPUpdate_5_select_low_med_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{65100, 65000})
-	mp_reach2 := createMpReach("2001::192:168:100:1", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(200)
 	localpref2 := bgp.NewPathAttributeLocalPref(100)
 
@@ -889,13 +904,13 @@ func TestProcessBGPUpdate_5_select_low_med_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -907,15 +922,15 @@ func TestProcessBGPUpdate_5_select_low_med_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -939,7 +954,8 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv4(t *testing.T) {
 	tm := NewTableManager()
 	tm.localAsn = uint32(65000)
 
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low origin message
@@ -991,15 +1007,15 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv4(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -1021,12 +1037,14 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
 	tm.localAsn = uint32(65000)
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(0)
 	aspath1 := createAsPathAttribute([]uint16{65000, 65200})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(200)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -1040,7 +1058,8 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{65100, 65200})
-	mp_reach2 := createMpReach("2001::192:168:100:1", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(200)
 	localpref2 := bgp.NewPathAttributeLocalPref(100)
 
@@ -1056,13 +1075,13 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	peer2 := peerR2()
 	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -1074,15 +1093,15 @@ func TestProcessBGPUpdate_6_select_ebgp_path_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -1108,7 +1127,8 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv4(t *testing.T) {
 	tm := NewTableManager()
 	tm.localAsn = uint32(65000)
 
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	// low origin message
@@ -1160,15 +1180,15 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv4(t *testing.T) {
 	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
 	expectedOrigin := pathAttributes[0]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[1]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedNexthopAttr := pathAttributes[2]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -1190,12 +1210,14 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 
 	tm := NewTableManager()
 	tm.localAsn = uint32(65000)
-	var pList, wList []Path
+	var pList []Path
+	var wList []Destination
 	var err error
 
 	origin1 := bgp.NewPathAttributeOrigin(0)
 	aspath1 := createAsPathAttribute([]uint16{65000, 65200})
-	mp_reach1 := createMpReach("2001::192:168:50:1", "2001:123:123:1::", 64)
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med1 := bgp.NewPathAttributeMultiExitDisc(200)
 	localpref1 := bgp.NewPathAttributeLocalPref(100)
 
@@ -1209,7 +1231,8 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 
 	origin2 := bgp.NewPathAttributeOrigin(0)
 	aspath2 := createAsPathAttribute([]uint16{65100, 65200})
-	mp_reach2 := createMpReach("2001::192:168:100:1", "2001:123:123:1::", 64)
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
 	med2 := bgp.NewPathAttributeMultiExitDisc(200)
 	localpref2 := bgp.NewPathAttributeLocalPref(100)
 
@@ -1225,13 +1248,13 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	peer3 := peerR3()
 	pList, wList, err = tm.ProcessUpdate(peer3, bgpMessage2)
 	assert.Equal(t, 1, len(pList))
 	assert.Equal(t, 0, len(wList))
-	assert.NoError(t, err, "err should be nil")
+	assert.NoError(t, err)
 
 	// check type
 	path := pList[0]
@@ -1243,15 +1266,15 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 
 	expectedNexthopAttr := pathAttributes[0]
 	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
-	assert.Equal(t, pathNexthop, expectedNexthopAttr)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
 
 	expectedOrigin := pathAttributes[1]
 	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
-	assert.Equal(t, pathOrigin, expectedOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
 
 	expectedAsPath := pathAttributes[2]
 	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
-	assert.Equal(t, pathAspath, expectedAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
 
 	expectedMed := pathAttributes[3]
 	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
@@ -1269,6 +1292,853 @@ func TestProcessBGPUpdate_7_select_low_routerid_path_ipv6(t *testing.T) {
 
 }
 
+// test: withdraw and mpunreach path
+func TestProcessBGPUpdate_8_withdraw_path_ipv4(t *testing.T) {
+
+	tm := NewTableManager()
+	//setLogger(getLogger(log.DebugLevel))
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	// path1
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000})
+	nexthop1 := bgp.NewPathAttributeNextHop("192.168.50.1")
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		origin1, aspath1, nexthop1, med1, localpref1,
+	}
+	nlri1 := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.10.0")}
+	withdrawnRoutes1 := []bgp.WithdrawnRoute{}
+	bgpMessage1 := bgp.NewBGPUpdateMessage(withdrawnRoutes1, pathAttributes1, nlri1)
+
+	// path 2
+	origin2 := bgp.NewPathAttributeOrigin(0)
+	aspath2 := createAsPathAttribute([]uint16{65100, 65000})
+	nexthop2 := bgp.NewPathAttributeNextHop("192.168.100.1")
+	med2 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref2 := bgp.NewPathAttributeLocalPref(200)
+
+	pathAttributes2 := []bgp.PathAttributeInterface{
+		origin2, aspath2, nexthop2, med2, localpref2,
+	}
+	nlri2 := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.10.0")}
+	withdrawnRoutes2 := []bgp.WithdrawnRoute{}
+	bgpMessage2 := bgp.NewBGPUpdateMessage(withdrawnRoutes2, pathAttributes2, nlri2)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	peer2 := peerR2()
+	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check type
+	path := pList[0]
+	expectedType := "*table.IPv4Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+		expectedOrigin := pathAttributes[0]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[1]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedNexthopAttr := pathAttributes[2]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+	checkPattr(bgpMessage2, path)
+	// check destination
+	expectedPrefix := "10.10.10.0"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "192.168.100.1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+	//withdraw path
+	w1 := bgp.WithdrawnRoute{*bgp.NewIPAddrPrefix(24, "10.10.10.0")}
+	w := []bgp.WithdrawnRoute{w1}
+	bgpMessage3 := bgp.NewBGPUpdateMessage(w, []bgp.PathAttributeInterface{}, []bgp.NLRInfo{})
+
+	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage3)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	path = pList[0]
+	expectedType = "*table.IPv4Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	checkPattr(bgpMessage1, path)
+	// check destination
+	expectedPrefix = "10.10.10.0"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop = "192.168.50.1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+}
+
+// TODO MP_UNREACH
+func TestProcessBGPUpdate_8_mpunreach_path_ipv6(t *testing.T) {
+
+	tm := NewTableManager()
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000})
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		mp_reach1, origin1, aspath1, med1, localpref1,
+	}
+
+	nlri1 := []bgp.NLRInfo{}
+	withdrawnRoutes1 := []bgp.WithdrawnRoute{}
+	bgpMessage1 := bgp.NewBGPUpdateMessage(withdrawnRoutes1, pathAttributes1, nlri1)
+
+	origin2 := bgp.NewPathAttributeOrigin(0)
+	aspath2 := createAsPathAttribute([]uint16{65100, 65000})
+	mp_reach2 := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
+	med2 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref2 := bgp.NewPathAttributeLocalPref(200)
+
+	pathAttributes2 := []bgp.PathAttributeInterface{
+		mp_reach2, origin2, aspath2, med2, localpref2,
+	}
+
+	nlri2 := []bgp.NLRInfo{}
+	withdrawnRoutes2 := []bgp.WithdrawnRoute{}
+	bgpMessage2 := bgp.NewBGPUpdateMessage(withdrawnRoutes2, pathAttributes2, nlri2)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	peer2 := peerR2()
+	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage2)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check type
+	path := pList[0]
+	expectedType := "*table.IPv6Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
+
+	expectedNexthopAttr := pathAttributes[0]
+	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+	expectedOrigin := pathAttributes[1]
+	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
+
+	expectedAsPath := pathAttributes[2]
+	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
+
+	expectedMed := pathAttributes[3]
+	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+	assert.Equal(t, expectedMed, pathMed)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+
+		expectedNexthopAttr := pathAttributes[0]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedOrigin := pathAttributes[1]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[2]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+
+	checkPattr(bgpMessage2, path)
+
+	// check destination
+	expectedPrefix := "2001:123:123:1::"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "2001::192:168:100:1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+	//mpunreach path
+	mp_unreach := createMpUNReach("2001:123:123:1::", 64)
+	bgpMessage3 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{},
+		[]bgp.PathAttributeInterface{mp_unreach}, []bgp.NLRInfo{})
+
+	pList, wList, err = tm.ProcessUpdate(peer2, bgpMessage3)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	path = pList[0]
+	expectedType = "*table.IPv6Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	checkPattr(bgpMessage1, path)
+	// check destination
+	expectedPrefix = "2001:123:123:1::"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop = "2001::192:168:50:1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+}
+
+// handle bestpath lost
+func TestProcessBGPUpdate_bestpath_lost_ipv4(t *testing.T) {
+
+	tm := NewTableManager()
+	//setLogger(getLogger(log.DebugLevel))
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	// path1
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000})
+	nexthop1 := bgp.NewPathAttributeNextHop("192.168.50.1")
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		origin1, aspath1, nexthop1, med1, localpref1,
+	}
+	nlri1 := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.10.0")}
+	bgpMessage1 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes1, nlri1)
+
+	// path 1 withdraw
+	w1 := bgp.WithdrawnRoute{*bgp.NewIPAddrPrefix(24, "10.10.10.0")}
+	w := []bgp.WithdrawnRoute{w1}
+	bgpMessage1_w := bgp.NewBGPUpdateMessage(w, []bgp.PathAttributeInterface{}, []bgp.NLRInfo{})
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1_w)
+	assert.Equal(t, 0, len(pList))
+	assert.Equal(t, 1, len(wList))
+	assert.NoError(t, err)
+
+	// check old best path
+	path := wList[0].getOldBestPath()
+	expectedType := "*table.IPv4Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+		expectedOrigin := pathAttributes[0]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[1]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedNexthopAttr := pathAttributes[2]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+
+	checkPattr(bgpMessage1, path)
+	// check destination
+	expectedPrefix := "10.10.10.0"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "192.168.50.1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+}
+
+func TestProcessBGPUpdate_bestpath_lost_ipv6(t *testing.T) {
+
+	tm := NewTableManager()
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000})
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		mp_reach1, origin1, aspath1, med1, localpref1,
+	}
+
+	nlri1 := []bgp.NLRInfo{}
+	withdrawnRoutes1 := []bgp.WithdrawnRoute{}
+	bgpMessage1 := bgp.NewBGPUpdateMessage(withdrawnRoutes1, pathAttributes1, nlri1)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// path1 mpunreach
+	mp_unreach := createMpUNReach("2001:123:123:1::", 64)
+	bgpMessage1_w := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{},
+		[]bgp.PathAttributeInterface{mp_unreach}, []bgp.NLRInfo{})
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1_w)
+	assert.Equal(t, 0, len(pList))
+	assert.Equal(t, 1, len(wList))
+	assert.NoError(t, err)
+
+	// check old best path
+	path := wList[0].getOldBestPath()
+	expectedType := "*table.IPv6Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+
+		expectedNexthopAttr := pathAttributes[0]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedOrigin := pathAttributes[1]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[2]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+
+	checkPattr(bgpMessage1, path)
+
+	// check destination
+	expectedPrefix := "2001:123:123:1::"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "2001::192:168:50:1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+}
+
+// test: implicit withdrawal case
+func TestProcessBGPUpdate_implicit_withdrwal_ipv4(t *testing.T) {
+
+	tm := NewTableManager()
+	//setLogger(getLogger(log.DebugLevel))
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	// path1
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000, 65100, 65200})
+	nexthop1 := bgp.NewPathAttributeNextHop("192.168.50.1")
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		origin1, aspath1, nexthop1, med1, localpref1,
+	}
+	nlri1 := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.10.0")}
+	withdrawnRoutes1 := []bgp.WithdrawnRoute{}
+	bgpMessage1 := bgp.NewBGPUpdateMessage(withdrawnRoutes1, pathAttributes1, nlri1)
+
+	// path 1 from same peer but short AS_PATH
+	origin2 := bgp.NewPathAttributeOrigin(0)
+	aspath2 := createAsPathAttribute([]uint16{65000, 65100})
+	nexthop2 := bgp.NewPathAttributeNextHop("192.168.50.1")
+	med2 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref2 := bgp.NewPathAttributeLocalPref(100)
+
+	pathAttributes2 := []bgp.PathAttributeInterface{
+		origin2, aspath2, nexthop2, med2, localpref2,
+	}
+	nlri2 := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "10.10.10.0")}
+	withdrawnRoutes2 := []bgp.WithdrawnRoute{}
+	bgpMessage2 := bgp.NewBGPUpdateMessage(withdrawnRoutes2, pathAttributes2, nlri2)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage2)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check type
+	path := pList[0]
+	expectedType := "*table.IPv4Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+		expectedOrigin := pathAttributes[0]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[1]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedNexthopAttr := pathAttributes[2]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+	checkPattr(bgpMessage2, path)
+	// check destination
+	expectedPrefix := "10.10.10.0"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "192.168.50.1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+}
+
+func TestProcessBGPUpdate_implicit_withdrwal_ipv6(t *testing.T) {
+
+	tm := NewTableManager()
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	origin1 := bgp.NewPathAttributeOrigin(0)
+	aspath1 := createAsPathAttribute([]uint16{65000, 65100, 65200})
+	mp_reach1 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
+	med1 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref1 := bgp.NewPathAttributeLocalPref(200)
+
+	pathAttributes1 := []bgp.PathAttributeInterface{
+		mp_reach1, origin1, aspath1, med1, localpref1,
+	}
+
+	nlri1 := []bgp.NLRInfo{}
+	withdrawnRoutes1 := []bgp.WithdrawnRoute{}
+	bgpMessage1 := bgp.NewBGPUpdateMessage(withdrawnRoutes1, pathAttributes1, nlri1)
+
+	origin2 := bgp.NewPathAttributeOrigin(0)
+	aspath2 := createAsPathAttribute([]uint16{65000, 65100})
+	mp_reach2 := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2001:123:123:1::")})
+	med2 := bgp.NewPathAttributeMultiExitDisc(200)
+	localpref2 := bgp.NewPathAttributeLocalPref(200)
+
+	pathAttributes2 := []bgp.PathAttributeInterface{
+		mp_reach2, origin2, aspath2, med2, localpref2,
+	}
+
+	nlri2 := []bgp.NLRInfo{}
+	withdrawnRoutes2 := []bgp.WithdrawnRoute{}
+	bgpMessage2 := bgp.NewBGPUpdateMessage(withdrawnRoutes2, pathAttributes2, nlri2)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage2)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check type
+	path := pList[0]
+	expectedType := "*table.IPv6Path"
+	assert.Equal(t, reflect.TypeOf(path).String(), expectedType)
+
+	// check PathAttribute
+	pathAttributes := bgpMessage2.Body.(*bgp.BGPUpdate).PathAttributes
+
+	expectedNexthopAttr := pathAttributes[0]
+	pathNexthop := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+	assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+	expectedOrigin := pathAttributes[1]
+	pathOrigin := path.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+	assert.Equal(t, expectedOrigin, pathOrigin)
+
+	expectedAsPath := pathAttributes[2]
+	pathAspath := path.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+	assert.Equal(t, expectedAsPath, pathAspath)
+
+	expectedMed := pathAttributes[3]
+	pathMed := path.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+	assert.Equal(t, expectedMed, pathMed)
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+
+		expectedNexthopAttr := pathAttributes[0]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedOrigin := pathAttributes[1]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[2]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), path.getPathAttributeMap().Len())
+	}
+
+	checkPattr(bgpMessage2, path)
+
+	// check destination
+	expectedPrefix := "2001:123:123:1::"
+	assert.Equal(t, expectedPrefix, path.getPrefix().String())
+	// check nexthop
+	expectedNexthop := "2001::192:168:50:1"
+	assert.Equal(t, expectedNexthop, path.getNexthop().String())
+
+}
+
+// check multiple paths
+func TestProcessBGPUpdate_multiple_nlri_ipv4(t *testing.T) {
+
+	tm := NewTableManager()
+	//setLogger(getLogger(log.DebugLevel))
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	createPathAttr := func(aspaths []uint16, nh string) []bgp.PathAttributeInterface {
+		origin := bgp.NewPathAttributeOrigin(0)
+		aspath := createAsPathAttribute(aspaths)
+		nexthop := bgp.NewPathAttributeNextHop(nh)
+		med := bgp.NewPathAttributeMultiExitDisc(200)
+		localpref := bgp.NewPathAttributeLocalPref(100)
+		pathAttr := []bgp.PathAttributeInterface{
+			origin, aspath, nexthop, med, localpref,
+		}
+		return pathAttr
+	}
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+		expectedOrigin := pathAttributes[0]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[1]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedNexthopAttr := pathAttributes[2]
+		pathNexthop := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_NEXT_HOP).(*bgp.PathAttributeNextHop)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedMed := pathAttributes[3]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), actual.getPathAttributeMap().Len())
+	}
+
+	checkBestPathResult := func(pType, prefix, nexthop string, p Path, m *bgp.BGPMessage) {
+		expectedType := pType
+		assert.Equal(t, reflect.TypeOf(p).String(), expectedType)
+		checkPattr(m, p)
+		// check destination
+		assert.Equal(t, prefix, p.getPrefix().String())
+		// check nexthop
+		assert.Equal(t, nexthop, p.getNexthop().String())
+	}
+
+	// path1
+	pathAttributes1 := createPathAttr([]uint16{65000, 65100, 65200}, "192.168.50.1")
+	nlri1 := []bgp.NLRInfo{
+		*bgp.NewNLRInfo(24, "10.10.10.0"),
+		*bgp.NewNLRInfo(24, "20.20.20.0"),
+		*bgp.NewNLRInfo(24, "30.30.30.0"),
+		*bgp.NewNLRInfo(24, "40.40.40.0"),
+		*bgp.NewNLRInfo(24, "50.50.50.0")}
+	bgpMessage1 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes1, nlri1)
+
+	// path2
+	pathAttributes2 := createPathAttr([]uint16{65000, 65100, 65300}, "192.168.50.1")
+	nlri2 := []bgp.NLRInfo{
+		*bgp.NewNLRInfo(24, "11.11.11.0"),
+		*bgp.NewNLRInfo(24, "22.22.22.0"),
+		*bgp.NewNLRInfo(24, "33.33.33.0"),
+		*bgp.NewNLRInfo(24, "44.44.44.0"),
+		*bgp.NewNLRInfo(24, "55.55.55.0")}
+	bgpMessage2 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes2, nlri2)
+
+	// path3
+	pathAttributes3 := createPathAttr([]uint16{65000, 65100, 65400}, "192.168.50.1")
+	nlri3 := []bgp.NLRInfo{
+		*bgp.NewNLRInfo(24, "77.77.77.0"),
+		*bgp.NewNLRInfo(24, "88.88.88.0"),
+	}
+	bgpMessage3 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes3, nlri3)
+
+	// path4
+	pathAttributes4 := createPathAttr([]uint16{65000, 65100, 65500}, "192.168.50.1")
+	nlri4 := []bgp.NLRInfo{
+		*bgp.NewNLRInfo(24, "99.99.99.0"),
+	}
+	bgpMessage4 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes4, nlri4)
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 5, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	checkBestPathResult("*table.IPv4Path", "10.10.10.0", "192.168.50.1", pList[0], bgpMessage1)
+	checkBestPathResult("*table.IPv4Path", "20.20.20.0", "192.168.50.1", pList[1], bgpMessage1)
+	checkBestPathResult("*table.IPv4Path", "30.30.30.0", "192.168.50.1", pList[2], bgpMessage1)
+	checkBestPathResult("*table.IPv4Path", "40.40.40.0", "192.168.50.1", pList[3], bgpMessage1)
+	checkBestPathResult("*table.IPv4Path", "50.50.50.0", "192.168.50.1", pList[4], bgpMessage1)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage2)
+	assert.Equal(t, 5, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	checkBestPathResult("*table.IPv4Path", "11.11.11.0", "192.168.50.1", pList[0], bgpMessage2)
+	checkBestPathResult("*table.IPv4Path", "22.22.22.0", "192.168.50.1", pList[1], bgpMessage2)
+	checkBestPathResult("*table.IPv4Path", "33.33.33.0", "192.168.50.1", pList[2], bgpMessage2)
+	checkBestPathResult("*table.IPv4Path", "44.44.44.0", "192.168.50.1", pList[3], bgpMessage2)
+	checkBestPathResult("*table.IPv4Path", "55.55.55.0", "192.168.50.1", pList[4], bgpMessage2)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage3)
+	assert.Equal(t, 2, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage4)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check table
+	table := tm.Tables[RF_IPv4_UC]
+	assert.Equal(t, 13, len(table.getDestinations()))
+
+}
+
+// check multiple paths
+func TestProcessBGPUpdate_multiple_nlri_ipv6(t *testing.T) {
+
+	tm := NewTableManager()
+	//setLogger(getLogger(log.DebugLevel))
+	var pList []Path
+	var wList []Destination
+	var err error
+
+	createPathAttr := func(aspaths []uint16) []bgp.PathAttributeInterface {
+		origin := bgp.NewPathAttributeOrigin(0)
+		aspath := createAsPathAttribute(aspaths)
+		med := bgp.NewPathAttributeMultiExitDisc(100)
+		localpref := bgp.NewPathAttributeLocalPref(100)
+		pathAttr := []bgp.PathAttributeInterface{
+			origin, aspath, med, localpref,
+		}
+		return pathAttr
+	}
+
+	// check PathAttribute
+	checkPattr := func(expected *bgp.BGPMessage, actual Path) {
+		pathAttributes := expected.Body.(*bgp.BGPUpdate).PathAttributes
+		pathNexthop := pathAttributes[4]
+		expectedNexthopAttr := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MP_REACH_NLRI).(*bgp.PathAttributeMpReachNLRI)
+		assert.Equal(t, expectedNexthopAttr, pathNexthop)
+
+		expectedOrigin := pathAttributes[0]
+		pathOrigin := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_ORIGIN).(*bgp.PathAttributeOrigin)
+		assert.Equal(t, expectedOrigin, pathOrigin)
+
+		expectedAsPath := pathAttributes[1]
+		pathAspath := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_AS_PATH).(*bgp.PathAttributeAsPath)
+		assert.Equal(t, expectedAsPath, pathAspath)
+
+		expectedMed := pathAttributes[2]
+		pathMed := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_MULTI_EXIT_DISC).(*bgp.PathAttributeMultiExitDisc)
+		assert.Equal(t, expectedMed, pathMed)
+
+		expectedLocalpref := pathAttributes[3]
+		localpref := actual.getPathAttribute(bgp.BGP_ATTR_TYPE_LOCAL_PREF).(*bgp.PathAttributeLocalPref)
+		assert.Equal(t, expectedLocalpref, localpref)
+
+		// check PathAttribute length
+		assert.Equal(t, len(pathAttributes), actual.getPathAttributeMap().Len())
+
+	}
+
+	checkBestPathResult := func(pType, prefix, nexthop string, p Path, m *bgp.BGPMessage) {
+		expectedType := pType
+		assert.Equal(t, reflect.TypeOf(p).String(), expectedType)
+		checkPattr(m, p)
+		// check destination
+		assert.Equal(t, prefix, p.getPrefix().String())
+		// check nexthop
+		assert.Equal(t, nexthop, p.getNexthop().String())
+	}
+
+	// path1
+	pathAttributes1 := createPathAttr([]uint16{65000, 65100, 65200})
+	mpreach1 := createMpReach("2001::192:168:50:1", []bgp.AddrPrefixInterface{
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1210:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1220:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1230:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1240:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1250:11::"),
+	})
+	pathAttributes1 = append(pathAttributes1, mpreach1)
+	bgpMessage1 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes1, []bgp.NLRInfo{})
+
+	// path2
+	pathAttributes2 := createPathAttr([]uint16{65000, 65100, 65300})
+	mpreach2 := createMpReach("2001::192:168:50:1", []bgp.AddrPrefixInterface{
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1211:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1222:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1233:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1244:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1255:11::"),
+	})
+	pathAttributes2 = append(pathAttributes2, mpreach2)
+	bgpMessage2 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes2, []bgp.NLRInfo{})
+
+	// path3
+	pathAttributes3 := createPathAttr([]uint16{65000, 65100, 65400})
+	mpreach3 := createMpReach("2001::192:168:50:1", []bgp.AddrPrefixInterface{
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1277:11::"),
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1288:11::"),
+	})
+	pathAttributes3 = append(pathAttributes3, mpreach3)
+	bgpMessage3 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes3, []bgp.NLRInfo{})
+
+	// path4
+	pathAttributes4 := createPathAttr([]uint16{65000, 65100, 65500})
+	mpreach4 := createMpReach("2001::192:168:50:1", []bgp.AddrPrefixInterface{
+		bgp.NewIPv6AddrPrefix(64, "2001:123:1299:11::"),
+	})
+	pathAttributes4 = append(pathAttributes4, mpreach4)
+	bgpMessage4 := bgp.NewBGPUpdateMessage([]bgp.WithdrawnRoute{}, pathAttributes4, []bgp.NLRInfo{})
+
+	peer1 := peerR1()
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage1)
+	assert.Equal(t, 5, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	checkBestPathResult("*table.IPv6Path", "2001:123:1210:11::", "2001::192:168:50:1", pList[0], bgpMessage1)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1220:11::", "2001::192:168:50:1", pList[1], bgpMessage1)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1230:11::", "2001::192:168:50:1", pList[2], bgpMessage1)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1240:11::", "2001::192:168:50:1", pList[3], bgpMessage1)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1250:11::", "2001::192:168:50:1", pList[4], bgpMessage1)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage2)
+	assert.Equal(t, 5, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	checkBestPathResult("*table.IPv6Path", "2001:123:1211:11::", "2001::192:168:50:1", pList[0], bgpMessage2)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1222:11::", "2001::192:168:50:1", pList[1], bgpMessage2)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1233:11::", "2001::192:168:50:1", pList[2], bgpMessage2)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1244:11::", "2001::192:168:50:1", pList[3], bgpMessage2)
+	checkBestPathResult("*table.IPv6Path", "2001:123:1255:11::", "2001::192:168:50:1", pList[4], bgpMessage2)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage3)
+	assert.Equal(t, 2, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	pList, wList, err = tm.ProcessUpdate(peer1, bgpMessage4)
+	assert.Equal(t, 1, len(pList))
+	assert.Equal(t, 0, len(wList))
+	assert.NoError(t, err)
+
+	// check table
+	table := tm.Tables[RF_IPv6_UC]
+	assert.Equal(t, 13, len(table.getDestinations()))
+
+}
+
 func update_fromR1() *bgp.BGPMessage {
 
 	origin := bgp.NewPathAttributeOrigin(0)
@@ -1335,7 +2205,8 @@ func update_fromR2_ipv6() *bgp.BGPMessage {
 
 	origin := bgp.NewPathAttributeOrigin(0)
 	aspath := createAsPathAttribute([]uint16{65100})
-	mp_reach := createMpReach("2001::192:168:100:1", "2002:223:123:1::", 64)
+	mp_reach := createMpReach("2001::192:168:100:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2002:223:123:1::")})
 	med := bgp.NewPathAttributeMultiExitDisc(100)
 
 	pathAttributes := []bgp.PathAttributeInterface{
@@ -1355,12 +2226,17 @@ func createAsPathAttribute(ases []uint16) *bgp.PathAttributeAsPath {
 	return aspath
 }
 
-func createMpReach(nexthop, nlri string, len uint8) *bgp.PathAttributeMpReachNLRI {
-	mp_nlri := []bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(len, nlri)}
-	mp_reach := bgp.NewPathAttributeMpReachNLRI(nexthop, mp_nlri)
+func createMpReach(nexthop string, prefix []bgp.AddrPrefixInterface) *bgp.PathAttributeMpReachNLRI {
+	mp_reach := bgp.NewPathAttributeMpReachNLRI(nexthop, prefix)
 	return mp_reach
 }
 
+func createMpUNReach(nlri string, len uint8) *bgp.PathAttributeMpUnreachNLRI {
+	mp_nlri := []bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(len, nlri)}
+	mp_unreach := bgp.NewPathAttributeMpUnreachNLRI(mp_nlri)
+	return mp_unreach
+}
+
 func update_fromR2viaR1() *bgp.BGPMessage {
 
 	origin := bgp.NewPathAttributeOrigin(0)
@@ -1383,7 +2259,8 @@ func update_fromR2viaR1_ipv6() *bgp.BGPMessage {
 
 	origin := bgp.NewPathAttributeOrigin(0)
 	aspath := createAsPathAttribute([]uint16{65000, 65100})
-	mp_reach := createMpReach("2001::192:168:50:1", "2002:223:123:1::", 64)
+	mp_reach := createMpReach("2001::192:168:50:1",
+		[]bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(64, "2002:223:123:1::")})
 	med := bgp.NewPathAttributeMultiExitDisc(100)
 
 	pathAttributes := []bgp.PathAttributeInterface{
@@ -1397,86 +2274,3 @@ func update_fromR2viaR1_ipv6() *bgp.BGPMessage {
 	return bgp.NewBGPUpdateMessage(withdrawnRoutes, pathAttributes, nlri)
 
 }
-
-func update() *bgp.BGPMessage {
-	w1 := bgp.WithdrawnRoute{*bgp.NewIPAddrPrefix(23, "121.1.3.2")}
-	w2 := bgp.WithdrawnRoute{*bgp.NewIPAddrPrefix(17, "100.33.3.0")}
-	w := []bgp.WithdrawnRoute{w1, w2}
-	//w := []WithdrawnRoute{}
-
-	aspath1 := []bgp.AsPathParamInterface{
-		bgp.NewAsPathParam(2, []uint16{1000}),
-		bgp.NewAsPathParam(1, []uint16{1001, 1002}),
-		bgp.NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	aspath2 := []bgp.AsPathParamInterface{
-		bgp.NewAs4PathParam(2, []uint32{1000000}),
-		bgp.NewAs4PathParam(1, []uint32{1000001, 1002}),
-		bgp.NewAs4PathParam(2, []uint32{1003, 100004}),
-	}
-
-	aspath3 := []*bgp.As4PathParam{
-		bgp.NewAs4PathParam(2, []uint32{1000000}),
-		bgp.NewAs4PathParam(1, []uint32{1000001, 1002}),
-		bgp.NewAs4PathParam(2, []uint32{1003, 100004}),
-	}
-
-	ecommunities := []bgp.ExtendedCommunityInterface{
-		&bgp.TwoOctetAsSpecificExtended{SubType: 1, AS: 10003, LocalAdmin: 3 << 20},
-		&bgp.FourOctetAsSpecificExtended{SubType: 2, AS: 1 << 20, LocalAdmin: 300},
-		&bgp.IPv4AddressSpecificExtended{SubType: 3, IPv4: net.ParseIP("192.2.1.2").To4(), LocalAdmin: 3000},
-		&bgp.OpaqueExtended{Value: []byte{0, 1, 2, 3, 4, 5, 6, 7}},
-		&bgp.UnknownExtended{Type: 99, Value: []byte{0, 1, 2, 3, 4, 5, 6, 7}},
-	}
-
-	mp_nlri := []bgp.AddrPrefixInterface{
-		bgp.NewLabelledVPNIPAddrPrefix(20, "192.0.9.0", *bgp.NewLabel(1, 2, 3),
-			bgp.NewRouteDistinguisherTwoOctetAS(256, 10000)),
-		bgp.NewLabelledVPNIPAddrPrefix(26, "192.10.8.192", *bgp.NewLabel(5, 6, 7, 8),
-			bgp.NewRouteDistinguisherIPAddressAS("10.0.1.1", 10001)),
-	}
-
-	mp_nlri2 := []bgp.AddrPrefixInterface{bgp.NewIPv6AddrPrefix(100,
-		"fe80:1234:1234:5667:8967:af12:8912:1023")}
-
-	mp_nlri3 := []bgp.AddrPrefixInterface{bgp.NewLabelledVPNIPv6AddrPrefix(100,
-		"fe80:1234:1234:5667:8967:af12:1203:33a1", *bgp.NewLabel(5, 6),
-		bgp.NewRouteDistinguisherFourOctetAS(5, 6))}
-
-	mp_nlri4 := []bgp.AddrPrefixInterface{bgp.NewLabelledIPAddrPrefix(25, "192.168.0.0",
-		*bgp.NewLabel(5, 6, 7))}
-
-	p := []bgp.PathAttributeInterface{
-		bgp.NewPathAttributeOrigin(3),
-		bgp.NewPathAttributeAsPath(aspath1),
-		bgp.NewPathAttributeAsPath(aspath2),
-		bgp.NewPathAttributeNextHop("129.1.1.2"),
-		bgp.NewPathAttributeMultiExitDisc(1 << 20),
-		bgp.NewPathAttributeLocalPref(1 << 22),
-		bgp.NewPathAttributeAtomicAggregate(),
-		bgp.NewPathAttributeAggregator(uint16(30002), "129.0.2.99"),
-		bgp.NewPathAttributeAggregator(uint32(30002), "129.0.2.99"),
-		bgp.NewPathAttributeAggregator(uint32(300020), "129.0.2.99"),
-		bgp.NewPathAttributeCommunities([]uint32{1, 3}),
-		bgp.NewPathAttributeOriginatorId("10.10.0.1"),
-		bgp.NewPathAttributeClusterList([]string{"10.10.0.2", "10.10.0.3"}),
-		bgp.NewPathAttributeExtendedCommunities(ecommunities),
-		bgp.NewPathAttributeAs4Path(aspath3),
-		bgp.NewPathAttributeAs4Aggregator(10000, "112.22.2.1"),
-		bgp.NewPathAttributeMpReachNLRI("112.22.2.0", mp_nlri),
-		bgp.NewPathAttributeMpReachNLRI("1023::", mp_nlri2),
-		bgp.NewPathAttributeMpReachNLRI("fe80::", mp_nlri3),
-		bgp.NewPathAttributeMpReachNLRI("129.1.1.1", mp_nlri4),
-		bgp.NewPathAttributeMpUnreachNLRI(mp_nlri),
-		&bgp.PathAttributeUnknown{
-			PathAttribute: bgp.PathAttribute{
-				Flags: 1,
-				Type:  100,
-				Value: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-			},
-		},
-	}
-	n := []bgp.NLRInfo{*bgp.NewNLRInfo(24, "13.2.3.1")}
-	return bgp.NewBGPUpdateMessage(w, p, n)
-}