bgp4r 0.0.11 → 0.0.12

data/test/nlris/nlri_test.rb

@@ -20,133 +20,111 @@
 # along with BGP4R.  If not, see <http://www.gnu.org/licenses/>.
 #++
 
+require 'test/unit'  
 require 'bgp/nlris/nlris'
-# require 'bgp/nlris/vpn'
-# require 'bgp/nlris/inet'
-# require 'bgp/nlris/labeled'
 
-require 'test/unit'  
-class NLRI_Ip4_Test < Test::Unit::TestCase
+class Nlri_Test < Test::Unit::TestCase
   include BGP
-  def test_1
-    el = Nlri::Ip4.new('20.0.0.0/16')
-    el2 = Nlri::Ip4.new(el)
-    assert_equal(el2.to_shex, el.to_shex)
-    assert_equal(Nlri::Ip4, el2.class)
-    assert_equal('0f1400', Nlri::Ip4.new('20.0.0.0/15').to_shex)
-    assert_equal('101400', Nlri::Ip4.new('20.0.0.0/16').to_shex)
-    assert_equal('11140000', Nlri::Ip4.new('20.0.0.0/17').to_shex)
-    assert_equal('17140000', Nlri::Ip4.new('20.0.0.0/23').to_shex)
-    assert_equal('18140000', Nlri::Ip4.new('20.0.0.0/24').to_shex)
-    assert_equal('1914000000', Nlri::Ip4.new('20.0.0.0/25').to_shex)
-    assert_equal('20.0.0.0/25', Nlri::Ip4.new('20.0.0.0/25').to_s)
+  def test_ip4_element
+    el = Base_nlri::Ip4.new('10.0.0.8/9')
+    assert_equal('10.0.0.0/9', el.to_s)
+    assert_equal('070a', Base_nlri::Ip4.new('10.0.0.8/7').to_shex)
+    assert_equal('080a', Base_nlri::Ip4.new('10.0.0.8/8').to_shex)
+    assert_equal('090a00', Base_nlri::Ip4.new('10.0.0.8/9').to_shex)
+    assert_equal('0f0a00', Base_nlri::Ip4.new('10.0.0.8/15').to_shex)
+    assert_equal('100a00', Base_nlri::Ip4.new('10.0.0.8/16').to_shex)
+    assert_equal('110a0000', Base_nlri::Ip4.new('10.0.0.8/17').to_shex)
+    assert_equal('170a0000', Base_nlri::Ip4.new('10.0.0.8/23').to_shex)
+    assert_equal('180a0000', Base_nlri::Ip4.new('10.0.0.8/24').to_shex)
+    assert_equal('190a000000', Base_nlri::Ip4.new('10.0.0.8/25').to_shex)
+    assert_equal('200a000008', Base_nlri::Ip4.new('10.0.0.8/32').to_shex)
   end
-
-  def test_2
-    assert_equal('0f1400',Nlri::Ip4.new(['0f1400'].pack('H*')).to_shex)
-    assert_equal('101400',Nlri::Ip4.new(['101400'].pack('H*')).to_shex)
-    assert_equal('11140000',Nlri::Ip4.new(['11140000'].pack('H*')).to_shex)
-    assert_equal('18140000',Nlri::Ip4.new(['18140000'].pack('H*')).to_shex)
-    assert_equal('1914000000',Nlri::Ip4.new(['1914000000'].pack('H*')).to_shex)
-    s = ['0f140010140011140000'].pack('H*')
-    ip4 = Nlri::Ip4.new(s)
-    assert_equal('10140011140000', s.unpack('H*')[0])
-    ip4 = Nlri::Ip4.new(s)
-    assert_equal('11140000', s.unpack('H*')[0])
-    ip4 = Nlri::Ip4.new(s)
-    assert_equal('', s.unpack('H*')[0])
-
+  def test_ext_element
+    assert_equal('ID: 100, 10.0.0.0/7', Base_nlri::Ext_Nlri_element.new(100, '10.0.0.0/7').to_s)
+    assert_equal('00000064070a', Base_nlri::Ext_Nlri_element.new(100, '10.0.0.0/7').to_shex)
+    assert_equal('00000064190a000000', Base_nlri::Ext_Nlri_element.new(100, '10.0.0.0/25').to_shex)
+    sbin = Base_nlri::Ext_Nlri_element.new(100, '10.0.0.0/25').encode
+    assert_equal('00000064190a000000', Base_nlri::Ext_Nlri_element.new(sbin).to_shex)
+    sbin = ['000000650764000000660766000000670766000000680768000000690869'].pack('H*')
+    Base_nlri::Ext_Nlri_element.new(sbin)
+    assert_equal('000000660766000000670766000000680768000000690869', sbin.unpack('H*')[0])
+    Base_nlri::Ext_Nlri_element.new(sbin)
+    assert_equal('000000670766000000680768000000690869', sbin.unpack('H*')[0])
+    Base_nlri::Ext_Nlri_element.new(sbin)
+    assert_equal('000000680768000000690869', sbin.unpack('H*')[0])
+    Base_nlri::Ext_Nlri_element.new(sbin)
+    assert_equal('000000690869', sbin.unpack('H*')[0])
+    Base_nlri::Ext_Nlri_element.new(sbin)
+    assert_equal('', sbin.unpack('H*')[0])
+    
+    # sbin=['0f140010140011140000'].pack('H*')
+    # Base_nlri::Nlri_element.new(sbin)
+    # assert_equal('', sbin.unpack('H*')[0])
+    
+    
   end
-end
-class NLRI_Ip6_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    assert_equal('0410',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/4').to_shex)
-    assert_equal('0510',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/5').to_shex)
-    assert_equal('0710',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/7').to_shex)
-    assert_equal('0811',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/8').to_shex)
-    assert_equal('091100',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/9').to_shex)
-    assert_equal('30111122223333',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/48').to_shex)
-    assert_equal('3111112222333300',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/49').to_shex)
-    assert_equal('401111222233334444',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/64').to_shex)
-    assert_equal('41111122223333444400',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/65').to_shex)
-    assert_equal('7f11112222333344445555666677778888',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/127').to_shex)
-    assert_equal('8011112222333344445555666677778888',Nlri::Ip6.new('1111:2222:3333:4444:5555:6666:7777:8888/128').to_shex)
-  end
-end
-
-class Withdrawn_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    nlri1 = Withdrawn.new
-    assert_equal('0000', nlri1.to_shex)
-    nlri1 << Withdrawn::Ip4.new('20.0.0.0/15')
+  def test_nlri
+    nlri1 = Nlri.new
+    nlri1 << Base_nlri::Ip4.new('20.0.0.0/15')
     nlri1 << '20.0.0.0/17'
     nlri1 << '20.0.0.0/24'
     s = '0f140010140011140000'
-    nlri2 = Withdrawn.new([s].pack('H*'))
-    assert_equal('000a0f140010140011140000', nlri2.to_shex)
-    assert_equal('000a0f140010140011140000', nlri2.to_shex(true))
-    assert_equal('0f140010140011140000', nlri2.to_shex(false))
+    nlri2 = Nlri.new([s].pack('H*'))
+    assert_equal('0f140010140011140000', nlri2.to_shex)
+    assert_raise(ArgumentError)  { nlri2.to_shex(true) }
     assert_equal(3,nlri2.nlris.size)
   end
-end
-
-class Prefix_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    assert_equal('::/128',Prefix.new.to_s)
-    assert_equal(2,Prefix.new.afi)
-    assert_equal('192.168.0.0/16',Prefix.new('192.168.0.0/16').to_s)
-    assert_equal(1,Prefix.new('192.168.0.0/16').afi)
-    assert(Prefix.new('192.168.0.0/16').ipv4?)
-    assert_equal('10c0a8',Prefix.new('192.168.0.0/16').to_shex)
-    assert_equal('402009000400040000',Prefix.new('2009:4:4::/64').to_shex)
-    assert Prefix.new('2009:4:4::/64').ipv6?
-    assert_equal('2009:4:4::/64',Prefix.new('2009:4:4::/64').to_s)
+  def test_nlris
+    nlri = Nlri.new
+    nlri << [101, '101.0.0.0/8']
+    nlri << [102, '102.0.0.0/8']
+    nlri << [103, '103.0.0.0/8']
+    nlri << { :path_id=> 104, :nlri_element=> '104.0.0.0/8' }
+    nlri << { :path_id=> 105, :nlri_element=> '105.0.0.0/8' }
+    assert_match(/ID: 102, 102.0/, nlri.to_s)
+    assert_match(/ID: 104, 104.0/, nlri.to_s)
+    assert_match(/ID: 105, 105.0/, nlri.to_s)
   end
-end
-
-class Vpn_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    assert_equal('5800000001000000010a0000', Vpn.new('10.0.0.1/24', Rd.new(1,1)).to_shex)
-    assert_equal('00000001000000010a0000', Vpn.new('10.0.0.1/24', Rd.new(1,1)).to_shex(false))
-    assert_equal('RD=1:1, IPv4=10.0.0.0/24', Vpn.new('10.0.0.1/24', Rd.new(1,1)).to_s)
-    assert_equal(88, Vpn.new('10.0.0.1/24', Rd.new(1,1)).bit_length)
-    assert_equal(1,Vpn.new('10.0.0.1/24', Rd.new(1,1)).afi)
-    assert_equal(true,Vpn.new('10.0.0.1/24', Rd.new(1,1)).ipv4?)
-    assert_equal(false,Vpn.new('10.0.0.1/24', Rd.new(1,1)).ipv6?)
-    assert_equal(2,Vpn.new('2009:4:5::/105', Rd.new(1,1)).afi)
-    assert_equal(false,Vpn.new('2009:4:5::/105', Rd.new(1,1)).ipv4?)
-    assert_equal(true,Vpn.new('2009:4:5::/105', Rd.new(1,1)).ipv6?)
-    assert_equal('RD=1:1, IPv6=2009:4:5::/105',Vpn.new('2009:4:5::/105', Rd.new(1,1)).to_s)
-    assert_equal('700000000100000001200900040005',Vpn.new('2009:4:5::/48', Rd.new(1,1)).to_shex)
-    assert_equal(169,Vpn.new('2009:4:5::/105', Rd.new(1,1)).bit_length)
+  def test_withdrawns_ext
+    nlri = Withdrawn.new
+    nlri << [101, '101.0.0.0/8']
+    nlri << [102, '102.0.0.0/8']
+    nlri << [103, '103.0.0.0/8']
+    nlri << { :path_id=> 104, :nlri_element=> '104.0.0.0/8' }
+    nlri << { :path_id=> 105, :nlri_element=> '105.0.0.0/8' }
+    assert_match(/ID: 102, 102.0/, nlri.to_s)
+    assert_match(/ID: 104, 104.0/, nlri.to_s)
+    assert_match(/ID: 105, 105.0/, nlri.to_s)
   end
-  def test_2
-    vpn = Vpn.new(['5800000001000000010a0000'].pack('H*'))
-    assert_equal(  '5800000001000000010a0000', vpn.to_shex)
-    assert_equal(  '00000001000000010a0000', vpn.to_shex(false))
-    vpn = Vpn.new(['700000000100000001200900040005'].pack('H*'), 2)
-    assert_equal(  '700000000100000001200900040005', vpn.to_shex)
-    vpn = Vpn.new(['700000000100000001200900040005'].pack('H*'), 2)
-    assert_equal(  '700000000100000001200900040005', vpn.to_shex)
+  def test_withdrawns
+    nlri = Withdrawn.new
+    nlri << '101.0.0.0/8'
+    nlri << '102.0.0.0/8'
+    nlri << '103.0.0.0/8'
+    assert_equal('086508660867', nlri.to_shex)
+    assert_match(/102.0/, nlri.to_s)
+    assert_match(/103.0/, nlri.to_s)
+    nlri1 = Withdrawn.new nlri.encode[2..-1].is_packed
+    nlri2 = Nlri.factory nlri.encode[2..-1].is_packed, 1, 1
+    assert_equal(nlri1.to_shex, nlri2.to_shex)
+    
+    # 16d403741755c68816d40830
   end
-end
-
-class Labeled_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    assert_equal('Label Stack=1,2,3 (bottom) 10.0.0.0/24', Labeled.new(Prefix.new('10.0.0.1/24'),1,2,3).to_s)
-    assert_equal(3*24+24, Labeled.new(Prefix.new('10.0.0.1/24'),1,2,3).bit_length)
-    assert_equal('600000100000200000310a0000', Labeled.new(Prefix.new('10.0.0.1/24'),1,2,3).to_shex)
-    assert_equal('6b0006510000006400000064c0a800',Labeled.new(Vpn.new('192.168.0.0/19', Rd.new(100,100)),101).to_shex)
-    assert_equal('d8000651000000640000006420090004000500000000000000000001',Labeled.new(Vpn.new('2009:4:5::1', Rd.new(100,100)),101).to_shex)
-    assert_equal(24+64+128,Labeled.new(Vpn.new('2009:4:5::1', Rd.new(100,100)),101).bit_length)
-    assert_equal(24+64+64,Labeled.new(Vpn.new('2009:4:5::1/64', Rd.new(100,100)),101).bit_length)
-    assert_equal(24*3+64+48,Labeled.new(Vpn.new('2009:4:5::1/48', Rd.new(100,100)),101,102,103).bit_length)
-    assert_equal('9800065100000064000000642009000400050000',Labeled.new(Vpn.new('2009:4:5::1/64', Rd.new(100,100)),101).to_shex)
-    assert_equal('9800065100000064000000642009000400050000',Labeled.new(['9800065100000064000000642009000400050000'].pack('H*'),2).to_shex)
+  
+  def test_factory_ip4_elements
+    s = '07640766076607680869'
+    nlri =  Nlri.factory([s].pack('H*'),1,1)
+    s = '0f140010140011140000'
+    nlri =  Nlri.factory([s].pack('H*'),1,1)
+    assert_equal("20.0.0.0/15\n20.0.0.0/16\n20.0.0.0/17", nlri.to_s)
+    assert_equal(s, nlri.to_shex)
+  end
+  def test_factory_ip4_elements_extented
+    s = '000000650764000000660766000000670766000000680768000000690869'
+    nlri =  Nlri.factory([s].pack('H*'),1,1,true)
+    assert_match(/ID: 102, 102.0/, nlri.to_s)
+    assert_match(/ID: 104, 104.0/, nlri.to_s)
+    assert_match(/ID: 105, 105.0/, nlri.to_s)
+    assert_equal(s, nlri.to_shex)
   end
 end

data/test/optional_parameters/add_path_test.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright 2011 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#
+# This file is part of BGP4R.
+# 
+# BGP4R is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# BGP4R is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BGP4R.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require "test/unit"
+require 'bgp4r'
+require "bgp/optional_parameters/add_path"
+
+class TestBgpOptionalParametersAddPath < Test::Unit::TestCase
+  include BGP::OPT_PARM::CAP
+  def test_1
+    ap = Add_path.new
+    ap.add( :send, 1, 1)
+    assert_equal '0206450400010101', ap.to_shex
+    ap.add( :recv, 2, 128)
+    assert_equal '020a45080001010100028002', ap.to_shex
+    ap.add :send_and_receive, :ipv6, :unicast
+    assert_equal '020e450c000101010002010300028002', ap.to_shex
+  end
+  def test_2
+    ap = Add_path.new
+    ap.add( :send, 1, 1)
+    ap.add( :send, 2, 128)
+    ap.add( :send_and_recv, 2, 128)
+    assert ap.send? 1, 1
+    assert ! ap.send?( 1, 2)
+    assert ap.send?( 2, 128)
+    assert ap.recv?( 2, 128)
+  end
+  def test_3
+    ap1 = Add_path.new_array [[1, 1 ,2 ], [2, 10, 10]]
+    ap2 = Add_path.new_array [[:send, :ipv4 ,:multicast], [:recv, 10, 10]]
+    assert_equal ap1.to_shex, ap2.to_shex
+  end
+end

data/test/optional_parameters/capability_test.rb

@@ -38,6 +38,11 @@ class Capability_Test < Test::Unit::TestCase
     cap = Capability.factory([s].pack('H*'))
     assert_instance_of(Graceful_restart, cap)
   end
+  def test_factory_add_path
+    s = '020e450c000101010002800200020103'
+    cap = Capability.factory([s].pack('H*'))
+    assert_instance_of(Add_path, cap)
+  end
   def test_factory_as4
     s = '0206410400000064'
     cap = Capability.factory([s].pack('H*'))
@@ -61,6 +66,11 @@ class Capability_Test < Test::Unit::TestCase
     cap = Capability.factory([s].pack('H*'))
     assert_equal(Orf, cap.class)
   end
+  def test_factory_add_path
+    s = '020e450c000101010002800200020103'
+    cap = Capability.factory([s].pack('H*'))
+    assert_instance_of(Add_path, cap)
+  end
   def test_factory_unknown
     s = '0207640576616c7565'
     cap = Capability.factory([s].pack('H*'))

data/test/optional_parameters/graceful_restart_test.rb

@@ -1,5 +1,6 @@
 require "test/unit"
 require "bgp/optional_parameters/graceful_restart"
+require 'bgp/common'
 
 class TestBgpOptionalParametersGracefulCapRestart < Test::Unit::TestCase
   include BGP::OPT_PARM::CAP

data/test/path_attributes/mp_reach_test.rb

@@ -72,36 +72,234 @@ class Mp_reach_Test < Test::Unit::TestCase
     #puts mpr
   end
   def test_6
-    mpr =  Mp_reach.new(:safi=>2, :nexthop=> ['2009:9:19::1/128'], :prefix=> ['2009:1::/64', '2009:2::/64', '2009:3::/64'])
+    mpr =  Mp_reach.new(:safi=>2, :nexthop=> ['2009:9:19::1/128'], :nlris=> ['2009:1::/64', '2009:2::/64', '2009:3::/64'])
     assert_equal("\n    AFI IPv6 (2), SAFI Multicast (2)\n    nexthop: 2009:9:19::1\n      2009:1::/64\n      2009:2::/64\n      2009:3::/64", mpr.mp_reach)
     assert_equal(mpr.to_shex, Mp_reach.new(mpr.encode).to_shex)
-    mpr =  Mp_reach.new(:safi=>1, :nexthop=> ['10.0.0.1','10.0.0.2'], :prefix=> '192.168.0.0/24')
+    mpr =  Mp_reach.new(:safi=>1, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlris=> '192.168.0.0/24')
     assert_equal("\n    AFI IPv4 (1), SAFI Unicast (1)\n    nexthop: 10.0.0.1, 10.0.0.2\n      192.168.0.0/24", mpr.mp_reach)
     assert_equal(mpr.to_shex, Mp_reach.new(mpr.encode).to_shex)
-    mpr =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlri=> {:prefix=> '192.168.0.0/24', :label=>101} )
+    mpr =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlris=> {:prefix=> '192.168.0.0/24', :label=>101} )
     assert_equal("\n    AFI IPv4 (1), SAFI Labeled NLRI (4)\n    nexthop: 10.0.0.1, 10.0.0.2\n      Label Stack=101 (bottom) 192.168.0.0/24", mpr.mp_reach)
     assert_equal(mpr.to_shex, Mp_reach.new(mpr.encode).to_shex)
-    mpr = Mp_reach.new(:safi=>128, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlri=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101})
+    mpr = Mp_reach.new(:safi=>128, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101})
     assert_equal("\n    AFI IPv4 (1), SAFI Labeled VPN Unicast (128)\n    nexthop: 10.0.0.1, 10.0.0.2\n      Label Stack=101 (bottom) RD=100:100, IPv4=192.168.0.0/24", mpr.mp_reach)
     assert_equal(mpr.to_shex, Mp_reach.new(mpr.encode).to_shex)
-    mpr = Mp_reach.new(:safi=>128, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlri=> {:rd=> Rd.new(100,100), :prefix=> Prefix.new('192.168.0.0/24'), :label=>101})
+    mpr = Mp_reach.new(:safi=>128, :nexthop=> ['10.0.0.1','10.0.0.2'], :nlris=> {:rd=> Rd.new(100,100), :prefix=> Prefix.new('192.168.0.0/24'), :label=>101})
     assert_equal("\n    AFI IPv4 (1), SAFI Labeled VPN Unicast (128)\n    nexthop: 10.0.0.1, 10.0.0.2\n      Label Stack=101 (bottom) RD=100:100, IPv4=192.168.0.0/24", mpr.mp_reach)
     assert_equal(mpr.to_shex, Mp_reach.new(mpr.encode).to_shex)
   end
   def test_7
-    mpr =  Mp_reach.new(:safi=>2, :nexthop=> '2009:9:19::1/128', :prefix=> [
+    mpr =  Mp_reach.new(:safi=>2, :nexthop=> '2009:9:19::1/128', :nlris=> [
       '2009:1::/64', '2009:2::/64', '2009:3::/64', '2009:4::/64', '2009:5::/64', '2009:6::/64'])
     assert_equal("\n    AFI IPv6 (2), SAFI Multicast (2)\n    nexthop: 2009:9:19::1\n      2009:1::/64\n      2009:2::/64\n      2009:3::/64\n      2009:4::/64\n      2009:5::/64\n      2009:6::/64", mpr.mp_reach)
-    mpr =  Mp_reach.new(:safi=>1, :nexthop=> '10.0.0.1', :prefix=> [
+    mpr =  Mp_reach.new(:safi=>1, :nexthop=> '10.0.0.1', :nlris=> [
       '192.168.0.0/24', '192.168.1.0/24', '192.168.2.0/24', '192.168.3.0/24', '192.168.4.0/24', '192.168.5.0/24'])
     assert_equal("\n    AFI IPv4 (1), SAFI Unicast (1)\n    nexthop: 10.0.0.1\n      192.168.0.0/24\n      192.168.1.0/24\n      192.168.2.0/24\n      192.168.3.0/24\n      192.168.4.0/24\n      192.168.5.0/24", mpr.mp_reach)
   end
   def test_8
-    mpr =  Mp_reach.new(:safi=>1, :nexthop=> '10.0.0.1', :prefix=> [
+    mpr =  Mp_reach.new(:safi=>1, :nexthop=> '10.0.0.1', :nlris=> [
       '192.168.0.0/24', '192.168.1.0/24', '192.168.2.0/24', '192.168.3.0/24', '192.168.4.0/24', '192.168.5.0/24'])
     assert_equal(Mp_unreach,mpr.new_unreach.class)
     mpr2 = Mp_reach.new(mpr)
     assert_equal(mpr.encode, mpr2.encode)
     assert_equal(Mp_unreach, Mp_unreach.new(mpr.new_unreach).class)
   end
+  
+  def test_afi_1
+    mpr1 =  Mp_reach.new(:safi=>1, :nexthop=> ['10.0.0.1'], :nlris=> '192.168.1.0/24')
+    mpr2 =  Mp_reach.new(:safi=>1, :nexthop=> ['10.0.0.1'], :nlris=> '192.168.1.0/24', :path_id=>100)
+    mpr3 =  Mp_reach.new(:safi=>2, :nexthop=> ['10.0.0.1'], :nlris=> ['192.168.1.0/24','192.168.2.0/24'])
+    mpr4 =  Mp_reach.new(:safi=>2, :nexthop=> ['10.0.0.1'], :nlris=> ['192.168.1.0/24','192.168.2.0/24'], :path_id=>100)
+    mpr5 =  Mp_reach.new(:safi=>1, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:prefix=> '192.168.1.0/24', :path_id=> 100},
+      {:prefix=> '192.168.2.0/24', :path_id=> 101},
+      {:prefix=> '192.168.2.0/24', :path_id=> 102},
+    ])
+    
+    assert_equal('800e0d000101040a0000010018c0a801', mpr1.to_shex)
+    assert_equal('800e11000101040a000001000000006418c0a801', mpr2.to_shex)
+    assert_equal attr_len(mpr1)+4, attr_len(mpr2)
+    
+    assert_equal('800e11000102040a0000010018c0a80118c0a802', mpr3.to_shex)
+    assert_equal('800e19000102040a000001000000006418c0a8010000006418c0a802', mpr4.to_shex)
+    assert_equal attr_len(mpr3)+8, attr_len(mpr4)
+
+    assert_equal('800e21000101040a000001000000006418c0a8010000006518c0a8020000006618c0a802', mpr5.to_shex)
+    
+  end
+  
+  def test_afi_1_ntop
+    
+    s = '800e11000102040a0000010018c0a80118c0a802'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, false)
+    assert_match(/^\s+192.168.1.0\/24/, mpr.to_s)
+    assert_match(/^\s+192.168.1.0\/24/, mpr.to_s)
+
+    s = '800e19000102040a000001000000006418c0a8010000006418c0a802'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, true)
+    assert_match(/^\s+ID=100, 192.168.1.0\/24/, mpr.to_s)
+    assert_match(/^\s+ID=100, 192.168.1.0\/24/, mpr.to_s)
+  end
+  
+
+  def test_afi_2
+    mpr1 =  Mp_reach.new(:safi=>1, :nexthop=> ['2011:1:7::1'], :nlris=>  '2011:1::/32')
+    mpr2 =  Mp_reach.new(:safi=>1, :nexthop=> ['2011:1:7::1'], :nlris=>  '2011:1::/32', :path_id=>100)
+    mpr3 =  Mp_reach.new(:safi=>2, :nexthop=> ['2011:1:7::1'], :nlris=> ['2011:1::/32','2011:2::/32'])
+    mpr4 =  Mp_reach.new(:safi=>2, :nexthop=> ['2011:1:7::1'], :nlris=> ['2011:1::/32','2011:2::/32'], :path_id=>100)
+    mpr5 =  Mp_reach.new(:safi=>1, :nexthop=> ['2011:1:7::1'], :nlris=> [
+      {:prefix=> '2011:1::/32', :path_id=> 100},
+      {:prefix=> '2011:2::/32', :path_id=> 101},
+      {:prefix=> '2011:3::/32', :path_id=> 102},
+    ])
+    
+    assert_equal('800e1a0002011020110001000700000000000000000001002020110001', mpr1.to_shex)
+    assert_equal('800e1e000201102011000100070000000000000000000100000000642020110001', mpr2.to_shex)
+    assert_equal attr_len(mpr1)+4, attr_len(mpr2)
+    
+    assert_equal('800e1f00020210201100010007000000000000000000010020201100012020110002', mpr3.to_shex)
+    assert_equal('800e27000202102011000100070000000000000000000100000000642020110001000000642020110002', mpr4.to_shex)
+    assert_equal attr_len(mpr3)+8, attr_len(mpr4)
+
+    assert_equal('800e30000201102011000100070000000000000000000100000000642020110001000000652020110002000000662020110003', mpr5.to_shex)
+    
+    
+  end
+  
+  def test_afi_2_ntop
+    
+    s = '800e1f00020210201100010007000000000000000000010020201100012020110002'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, false)
+    assert_match(/^\s+2011:1::\/32/, mpr.to_s)
+    assert_match(/^\s+2011:2::\/32/, mpr.to_s)
+
+    s = '800e27000202102011000100070000000000000000000100000000642020110001000000642020110002'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, true)
+    assert_match(/^\s+ID=100, 2011:1::\/32/, mpr.to_s)
+    assert_match(/^\s+ID=100, 2011:2::\/32/, mpr.to_s)
+  end
+
+  def test_safi_4
+    mpr1 =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1'], :nlris=> {:prefix=> '192.168.0.0/24', :label=>101} )
+    mpr2 =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1'], :nlris=> {:prefix=> '192.168.0.0/24', :label=>101, :path_id=>100} )
+    mpr3 =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:prefix=> '192.168.0.0/24', :label=>101,},
+      {:prefix=> '192.168.1.0/24', :label=>102,},
+      {:prefix=> '192.168.1.0/24', :label=>103,}
+    ])
+    mpr4 =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1'], :path_id=> 100, :nlris=> [
+      {:prefix=> '192.168.0.0/24', :label=>101,},
+      {:prefix=> '192.168.1.0/24', :label=>102,},
+      {:prefix=> '192.168.1.0/24', :label=>103,}
+    ])
+    mpr5 =  Mp_reach.new(:safi=>4, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:prefix=> '192.168.0.0/24', :label=>101, :path_id=>100},
+      {:prefix=> '192.168.1.0/24', :label=>102, :path_id=>101},
+      {:prefix=> '192.168.1.0/24', :label=>103, :path_id=>103},
+    ])
+    
+    assert_equal('800e10000104040a0000010030000651c0a800', mpr1.to_shex)
+    assert_equal('800e14000104040a000001000000006430000651c0a800', mpr2.to_shex)
+    assert_equal attr_len(mpr1)+4, attr_len(mpr2)
+    
+    assert_equal('800e1e000104040a0000010030000651c0a80030000661c0a80130000671c0a801', mpr3.to_shex)
+    assert_equal('800e2a000104040a000001000000006430000651c0a8000000006430000661c0a8010000006430000671c0a801', mpr4.to_shex)
+    assert_equal attr_len(mpr3)+12, attr_len(mpr4)
+
+    assert_equal('800e2a000104040a000001000000006430000651c0a8000000006530000661c0a8010000006730000671c0a801', mpr5.to_shex)
+    
+  end
+  
+  def test_safi_128
+    mpr1 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101}
+    mpr2 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101, :path_id=>100}
+    mpr3 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
+    ]
+    mpr4 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :path_id=> 100, :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103},
+    ]
+    mpr5 = Mp_reach.new :safi=>128, :nexthop=> ['10.0.0.1'], :nlris=> [
+      {:rd=> [100,100], :prefix=> '192.168.0.0/24', :label=>101, :path_id=>101},
+      {:rd=> [100,100], :prefix=> '192.168.1.0/24', :label=>102, :path_id=>102},
+      {:rd=> [100,100], :prefix=> '192.168.2.0/24', :label=>103, :path_id=>103},
+    ]
+
+    assert_equal('800e200001800c00000000000000000a00000100700006510000006400000064c0a800', mpr1.to_shex)
+    assert_equal('800e240001800c00000000000000000a0000010000000064700006510000006400000064c0a800', mpr2.to_shex)
+    assert_equal attr_len(mpr1)+4, attr_len(mpr2)
+    
+    assert_equal('800e3e0001800c00000000000000000a00000100700006510000006400000064c0a800700006610000006400000064c0a801700006710000006400000064c0a802', mpr3.to_shex)
+    assert_equal('800e4a0001800c00000000000000000a0000010000000064700006510000006400000064c0a80000000064700006610000006400000064c0a80100000064700006710000006400000064c0a802', mpr4.to_shex)
+    assert_equal attr_len(mpr3)+12, attr_len(mpr4)
+
+    assert_equal('800e4a0001800c00000000000000000a0000010000000065700006510000006400000064c0a80000000066700006610000006400000064c0a80100000067700006710000006400000064c0a802', mpr5.to_shex)
+
+    # 800e3e 0001 80 0c 00000000000000000a000001 00
+    #    700006510000006400000064c0a800
+    #    700006610000006400000064c0a801
+    #    700006710000006400000064c0a802
+    # 
+    # 
+    # 800e4a0001800c00000000000000000a000001 00
+    #    00000064 700006510000006400000064c0a800
+    #    00000064 700006610000006400000064c0a801
+    #    00000064 700006710000006400000064c0a802
+    # 
+    # 
+    # 800e4a 0001 80 0c 00000000000000000a000001 00 
+    #   00000065 700006510000006400000064c0a800
+    #   00000066 700006610000006400000064c0a801
+    #   00000067 700006710000006400000064c0a802
+
+  end
+  
+  def test_safi_4_ntop
+    
+    s = '800e1e000104040a0000010030000651c0a80030000661c0a80130000671c0a801'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, false)
+    assert_match(/^\s+Label Stack=101 /, mpr.to_s)
+    assert_match(/^\s+Label Stack=102 /, mpr.to_s)
+    assert_match(/^\s+Label Stack=103 /, mpr.to_s)
+
+    s = '800e2a000104040a000001000000006430000651c0a8000000006430000661c0a8010000006430000671c0a801'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, true)
+    assert_match(/ID=100, Label Stack=101 /, mpr.to_s)
+    assert_match(/ID=100, Label Stack=102 /, mpr.to_s)
+    assert_match(/ID=100, Label Stack=103 /, mpr.to_s)
+  end
+  
+  def test_safi_128_ntop
+    
+    s = '800e3e0001800c00000000000000000a00000100700006510000006400000064c0a800700006610000006400000064c0a801700006710000006400000064c0a802'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, false)
+    assert_match(/^\s+Label Stack=101 /, mpr.to_s)
+    assert_match(/^\s+Label Stack=102 /, mpr.to_s)
+    assert_match(/^\s+Label Stack=103 /, mpr.to_s)
+
+    s = '800e4a0001800c00000000000000000a0000010000000065700006510000006400000064c0a80000000066700006610000006400000064c0a80100000067700006710000006400000064c0a802'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin, true)
+    assert_match(/ID=101, Label Stack=101 /, mpr.to_s)
+    assert_match(/ID=102, Label Stack=102 /, mpr.to_s)
+    assert_match(/ID=103, Label Stack=103 /, mpr.to_s)
+  end
+  
+  private
+  
+  def attr_len(attr)
+    attr.encode[2,1].unpack('C')[0]
+  end
+  
 end