bgp4r 0.0.11 → 0.0.12

data/test/messages/update_test.rb

@@ -30,7 +30,6 @@ class Update_Test < Test::Unit::TestCase
     sbin = [s].pack('H*')
     u = Update.new(sbin)
     assert_equal(Update, Message.factory(sbin).class)
-    #TODO: more tests with nrli, with withdrawns....
   end
   def test_2
     s = "
@@ -59,29 +58,28 @@ class Update_Test < Test::Unit::TestCase
     m = Message.factory([s].pack('H*'))
     w = Update.withdrawn(m)
     assert_equal(Update,w.class)
-    assert_equal('000a200a0a0a0a2020202020', w.withdrawn.to_shex)
+    assert_equal('200a0a0a0a2020202020', w.withdrawn.to_shex)
   end
   def test_4
     an_update = Update.new(
-      Path_attribute.new(
-        Origin.new(1),
-        Next_hop.new('192.168.1.5'),
-        Multi_exit_disc.new(100),
-        Local_pref.new(100),
-        As_path.new(100,200,300),
-        Communities.new('1311:1 311:59 2805:64')
-      ),
-      Nlri.new('77.0.0.0/17', '78.0.0.0/18', '79.0.0.0/19')
+    Path_attribute.new(
+    Origin.new(1),
+    Next_hop.new('192.168.1.5'),
+    Multi_exit_disc.new(100),
+    Local_pref.new(100),
+    As_path.new(100,200,300),
+    Communities.new('1311:1 311:59 2805:64')
+    ),
+    Nlri.new('77.0.0.0/17', '78.0.0.0/18', '79.0.0.0/19')
     )
-    # Ship it!
+    
     assert_equal(3*2, an_update.encode4.size - an_update.encode.size)
   end
-  
   def test_5
     an_update = Update.new( Path_attribute.new( Origin.new(1),
-                                                Next_hop.new('10.0.0.1'),
-                                                Multi_exit_disc.new(100)
-                                                ))
+     Next_hop.new('10.0.0.1'),
+     Multi_exit_disc.new(100)
+    ))
     assert ! an_update.path_attribute.has?(Local_pref), "Should not contain a Local Pref attr."
     an_update << Local_pref.new(113)
     assert an_update.path_attribute.has?(Local_pref), "Should contain a Local Pref attr."
@@ -94,13 +92,13 @@ class Update_Test < Test::Unit::TestCase
     an_update << Nlri.new('21.0.0.0/11', '22.0.0.0/22')
     assert_equal 4, an_update.nlri.size
   end
-  
+
   def test_6
     s = 'ffffffffffffffffffffffffffffffff004a02000000274001010040020a0202000000c80000006440030428000101c0080c0137003b051f00010af50040114d0000124e0000134f0000'
-    m = Message.factory([s].pack('H*'), true)
+    m = Message.factory([s].pack('H*'), Update::Info.new(true))
     assert_not_nil m
     assert_instance_of(Update, m)
-    assert m.as4byte?
+    assert_equal(s, m.to_shex(Update::Info.new(true)))
   end
 
   def test_7
@@ -127,10 +125,12 @@ class Update_Test < Test::Unit::TestCase
     cluster: 0.0.0.1
     "
   end
-  
+
   def test_8
+    o = Update::Info.new(true)
+    def o.recv_inet_unicast? ; false ; end
     s = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0072020000001F4001010040020A0204212C051319351AFE400304557200D9C00804212C045C175D76D6175D76DE1659299C175929981659235C16592D6417592D6417592D6617592D6217C3D228185D73241859284417C3FE84165C727015592190'
-    m = Update.new([s].pack('H*'), true)
+    m = Update.new([s].pack('H*'), o)
     pa = m.path_attribute
     assert_equal '556533011 422910718', pa[As_path].as_path
     assert_equal '85.114.0.217', pa[Next_hop].next_hop
@@ -139,27 +139,124 @@ class Update_Test < Test::Unit::TestCase
     pa[:as_path].find_sequence.prepend(100)
     assert_equal '100 556533011 422910718', pa[As_path].as_path
   end
-  
+
   def test_9
+    # FFFFFFFFFF
+    # 0023 02 000C 16D40374 1755C688 16D40830 0000
     s = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF002302000C16D403741755C68816D408300000'
     m = Update.new([s].pack('H*'))
     assert m.withdrawn, "Should contain withdrawn routes."
     assert_equal 3,m.withdrawn.nlris.size
   end
+ 
+  def test_10
+    o = Update::Info.new(true)
+    def o.recv_inet_unicast? ; true ; end
+    def o.send_inet_unicast? ; true ; end
+    upd1 = Update.new(
+      Path_attribute.new(
+       As_path.new(100)
+      ),
+      Ext_Nlri.new(100, Nlri.new('77.0.0.0/17'))
+    )
+    assert_equal('ffffffffffffffffffffffffffffffff0028020000000940020602010000006400000064114d0000', upd1.to_shex(o))
+    # Need to tell the factory we are dealing with a ext nlri.
+    upd2 = Update.factory(upd1.encode(o), o)
+    assert_equal(upd1.to_shex(o), upd2.to_shex(o))
+  end
   
-  #--
-  # def test_10
-  #   s = 'ffff ffff ffff ffff ffff ffff ffff ffff
-  #   005f 0200 0000 4440 0101 0040 020e 0206
-  #   0064 212c 232a 0ddd 53f9 5ba0 4003 0428
-  #   0000 01c0 0810 212c 044d 232a 232a 232a
-  #   fc9d 000d 000b f011 1202 0400 0023 2a00
-  #   000d dd00 0053 f900 0302 9e18 5bd9 c5
-  #   '.split.join
-  #   m = Update.new([s].pack('H*'))
-  #   p m.path_attribute[:next_hop]
-  #   p m.path_attribute[:as_path]
-  # end
-  #++
+  def test_path_id_and_as4byte
+    o = Update::Info.new(true)
+    def o.recv_inet_unicast? ; true ; end
+    def o.send_inet_unicast? ; true ; end
+    upd1 = Update.new(
+     Path_attribute.new(
+      Origin.new,
+      As_path.new(100),
+      Local_pref.new(10),
+      Multi_exit_disc.new(20),
+      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},
+      ]))
+    )
+    assert_match(/ff{16}....020000/, upd1.to_shex)
+    assert upd1.path_attribute.has_a_mp_reach_attr?, "Expecting a MP_REACH Attr."
+    assert_match(/ID=100, Label Stack=102/,upd1.path_attribute[:mp_reach].to_s)
+    
+    # received as2byte encode aspath attr
+    upd2 = Update.factory upd1.encode, :as4byte=> false, :path_id=>true
+    # received as4byte encode aspath attr
+    upd3 = Update.factory upd1.encode(o), :as4byte=> true, :path_id=>true
+    assert_equal upd1.to_shex, upd2.to_shex
+    assert_equal upd2.to_shex, upd3.to_shex
+    
+  end
+  
+  # updates with path_id
+  
+  def ext_update(s)
+    sbin = [s.split.join].pack('H*')
+    o = Update::Info.new(true)
+    def o.path_id?(*args) ; true ; end
+    def o.recv_inet_unicast? ; true ; end
+    def o.send_inet_unicast? ; true ; end
+    Update.factory(sbin,o)
+  end
+  
+  def test_path_id_inet_unicast
+    upd = ext_update "
+    ffff ffff ffff ffff ffff ffff ffff ffff
+    003c 0200 0000 1c40 0101 0040 0200 4003
+    040a 0000 0180 0404 0000 0066 4005 0400
+    0000 6500 0000 6419 1400 0000"
+    assert_equal(BGP::Update, upd.class)
+    assert_equal 'ID: 100, 20.0.0.0/25', upd.nlri.nlris[0].to_s
+    
+  end
+  
+  def test_path_id_inet_mpls_vpn_unicast
+    s = "
+    ffff ffff ffff ffff ffff ffff ffff ffff
+    005f 0200 0000 4840 0101 0140 0200 8004
+    0400 0000 0040 0504 0000 0001 c010 0800
+    0200 0400 0000 0190 0e00 2400 0180 0c00
+    0000 0000 0000 0001 0101 0100 0000 0001
+    7003 e801 0000 0013 0000 0011 0a01 01"
+    upd = ext_update(s)
+
+    s2 = "
+    ffffffffffffffffffffffffffffffff
+    005e
+    02
+    0000
+    0047
+    40010101
+    400200
+    80040400000000
+    40050400000001
+    c010080002000400000001
+    800e240001800c00000000000000000101010100000000017003e80100000013000000110a0101
+    "
+    assert_equal(BGP::Update, upd.class)
+    assert upd.path_attribute.has_a_mp_reach_attr?
+    assert_equal s2.split.join, upd.to_shex
+    assert_equal s2.split.join, ext_update(upd.to_shex).to_shex
+    
+  end
+  
+  def test_path_id_inet_mpls_vpn_unicast_withdrawn
+    upd = ext_update "
+    ffff ffff ffff ffff ffff ffff ffff ffff
+    0031 0200 0000 1a90 0f00 1600 0180 0000
+    0001 7080 0001 0000 0001 0000 0001 0a01
+    01"
+    assert upd.has_a_path_attribute?
+    assert upd.path_attribute.has_a_mp_unreach_attr?
+    mp_unreach = upd.path_attribute[:mp_unreach]
+    assert_equal 1, mp_unreach.nlris[0].path_id
+    assert_equal 'ID=1, Label Stack=524288 (bottom) RD=1:1, IPv4=10.1.1.0/24', mp_unreach.nlris[0].to_s
+  end
 
 end

data/test/neighbor/add_path_cap_test.rb

@@ -0,0 +1,54 @@
+
+require "test/unit"
+require 'bgp4r'
+
+class TestBgpNeighborAddPathCap < Test::Unit::TestCase
+  include BGP
+  def setup
+  end
+  def test_as4_cap
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::As4.new(100))
+    peer    = Open.new(4,100, 200, '10.0.0.1')
+    assert ! Neighbor::Capabilities.new(speaker, peer).as4byte?, "AS 2-Octet encoding expected!"
+    peer = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::As4.new(100))
+    speaker    = Open.new(4,100, 200, '10.0.0.1')
+    assert ! Neighbor::Capabilities.new(speaker, peer).as4byte?, "AS 2-Octet encoding expected!"
+    peer     = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::As4.new(100))
+    speaker  = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::As4.new(100))
+    assert Neighbor::Capabilities.new(speaker, peer).as4byte?, "AS 4-Octet encoding expected!"
+  end
+  def test_add_path_send_and_recv_inet_unicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 1))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 1))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert   session_cap.send_inet_unicast?
+    assert   session_cap.path_id_recv?(1,1)
+    assert   session_cap.path_id_send?(1,1)
+    assert ! session_cap.send_inet_multicast?
+  end
+  def test_add_path_send_and_recv_inet6_multicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 2, 2))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 2, 2))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert  ! session_cap.send_inet_unicast?
+    assert  session_cap.send_inet6_multicast?
+    assert  session_cap.recv_inet6_multicast?
+  end
+  def test_add_path_send_and_recv_inet_mpls_vpn_unicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 128))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 128))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert    session_cap.send_inet_mpls_vpn_unicast?
+    assert  ! session_cap.send_inet6_multicast?
+    assert  ! session_cap.recv_inet6_multicast?
+  end
+  def test_add_path_send_and_recv_inet_mpls_vpn_multicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 129))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send_and_receive, 1, 129))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert    session_cap.send_inet_mpls_vpn_multicast?
+    assert  ! session_cap.send_inet_mpls_vpn_unicast?
+    assert  ! session_cap.send_inet6_multicast?
+    assert  ! session_cap.recv_inet6_multicast?
+  end
+end

data/test/neighbor/neighbor_test.rb

@@ -0,0 +1,161 @@
+#--
+# Copyright 2008, 2009 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 'test/helpers/server'
+
+class TestBgpNeighbor < Test::Unit::TestCase
+  include BGP
+  include BGP::OPT_PARM::CAP
+  include BGP::TestHelpers
+  def setup
+  end
+  def teardown
+  end
+  def test_open_msg
+    neighbor = Neighbor.new \
+      :version=> 4, 
+      :my_as=> 100, 
+      :remote_addr => '192.168.1.200',
+      :local_addr => '192.168.1.5', 
+      :id=> '1.1.1.1', 
+      :holdtime=> 20
+    neighbor.capability Mbgp.ipv4_unicast
+    neighbor.capability Mbgp.ipv4_multicast
+    neighbor.capability Route_refresh.new
+    neighbor.capability Route_refresh.new 128
+    neighbor.capability As4.new(100)
+    open_msg = neighbor.open
+    assert_equal(5,open_msg.opt_parms.size)
+    assert_equal(4,open_msg.version)
+    assert_equal(20,open_msg.holdtime)
+    assert_equal(100,open_msg.local_as)
+    # puts neighbor
+  end
+  def test_neighbor_state_methods
+    neighbor = Neighbor.new \
+      :version=> 4, 
+      :my_as=> 100, 
+      :remote_addr => '192.168.1.200', 
+      :local_addr => '192.168.1.5', 
+      :id=> '1.1.1.1', 
+      :holdtime=> 20
+    assert neighbor.is_idle?
+    assert ! neighbor.is_established?
+    assert ! neighbor.is_openrecv?
+    assert ! neighbor.is_openconfirm?
+  end
+  def test_start
+    start_server(3456)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.start :port=> 3456
+    assert_equal('Established', @c.state)
+    assert_equal('Established', @s.state)
+    stop_server
+  end
+  def test_start_no_blocking
+    start_server(3333)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.start :port=> 3333, :no_blocking=>true
+    assert_equal('OpenSent', @c.state)
+    assert_match(/(Active|OpenSent)/, @s.state)
+    stop_server
+  end
+  def test_send_and_receive_path_id_afi_1_safi_1
+    server_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    server_add_path_cap.add(:send_and_recv, 1, 1)
+    start_server(3456, server_add_path_cap)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.add_cap server_add_path_cap
+    @c.start :port=> 3456    
+    assert @s.session_info.recv_inet_unicast?, 
+            "Should have the capability to recv inet unicast reachability path info."
+    assert @s.session_info.send_inet_unicast?, 
+            "Should have the capability to send inet unicast reachability path info."
+    assert @c.session_info.recv_inet_unicast?, 
+            "Should have the capability to recv inet unicast reachability path info."
+    assert @c.session_info.send_inet_unicast?, 
+           "Should have the capability to send inet unicast reachability path info."
+    stop_server
+  end
+  def test_send_path_id_afi_1_safi_1
+    server_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    server_add_path_cap.add(:send, 1, 1)
+    client_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    client_add_path_cap.add(:recv, 1, 1)
+    start_server(3456, server_add_path_cap)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.add_cap client_add_path_cap
+    @c.start :port=> 3456    
+    assert ! @s.session_info.recv_inet_unicast?, 
+            "Should NOT have the capability to recv inet unicast reachability path info."
+    assert   @s.session_info.send_inet_unicast?, 
+            "Should have the capability to send inet unicast reachability path info."
+    assert @c.session_info.recv_inet_unicast?, 
+            "Should have the capability to recv inet unicast reachability path info."
+    assert ! @c.session_info.send_inet_unicast?, 
+           "Should NOT have the capability to send inet unicast reachability path info."
+    stop_server
+  end
+  def test_recv_path_id_afi_1_safi_1
+    server_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    server_add_path_cap.add(:recv, 1, 1)
+    client_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    client_add_path_cap.add(:send, 1, 1)
+    start_server(3456, server_add_path_cap)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.add_cap client_add_path_cap
+    @c.start :port=> 3456    
+    assert  @s.session_info.recv_inet_unicast?, 
+            "Should have the capability to recv inet unicast reachability path info."
+    assert !  @s.session_info.send_inet_unicast?, 
+            "Should NOT have the capability to send inet unicast reachability path info."
+    assert ! @c.session_info.recv_inet_unicast?, 
+            "Should NOT have the capability to recv inet unicast reachability path info."
+    assert  @c.session_info.send_inet_unicast?, 
+           "Should have the capability to send inet unicast reachability path info."
+    stop_server
+  end
+
+  def test_nor_recv_nor_send_path_id_afi_1_safi_1
+    server_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    server_add_path_cap.add(:recv, 1, 1)
+    client_add_path_cap = BGP::OPT_PARM::CAP::Add_path.new
+    client_add_path_cap.add(:recv, 1, 1)
+    start_server(3456, server_add_path_cap)
+    @c = Neighbor.new(4, 100, 180, '0.0.0.2', '127.0.0.1', '127.0.0.1')
+    @c.add_cap client_add_path_cap
+    @c.start :port=> 3456    
+    assert ! @s.session_info.recv_inet_unicast?, 
+            "Should NOT have the capability to recv inet unicast reachability path info."
+    assert !  @s.session_info.send_inet_unicast?, 
+            "Should NOT have the capability to send inet unicast reachability path info."
+    assert ! @c.session_info.recv_inet_unicast?, 
+            "Should NOT have the capability to recv inet unicast reachability path info."
+    assert ! @c.session_info.send_inet_unicast?, 
+           "Should have the capability to send inet unicast reachability path info."
+    stop_server
+  end
+
+
+end

data/test/nlris/ext_nlri_test.rb

@@ -1,67 +1,32 @@
-#--
-# Copyright 2008, 2009 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 'test/unit'  
-require 'bgp/nlris/nlris'
+require "bgp/nlris/nlri"
+require "bgp/nlris/inet"
+require "bgp/nlris/vpn"
+require "bgp/nlris/labeled"
+require "bgp/nlris/rd"
 
 class TestExtNlri < Test::Unit::TestCase
   include BGP
-  def test_1
-    nlri1 = Nlri.new 
-    nlri1 << Nlri::Ip4.new('20.0.0.0/15')
-    nlri1 << '20.0.0.0/17'
-    nlri1 << '20.0.0.0/24'
-    s = '0f140010140011140000'
-    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)    
+  def test_ext_nlri
+    ext_nlri = Ext_Nlri.new(100, Nlri.new('10.0.0.0/8'))
+    assert_equal '00000064080a', ext_nlri.to_shex
+    assert_equal '00000064080a', Ext_Nlri.new_ntop(ext_nlri.encode).to_shex
+    assert_equal '00000001200a0a0a0a', Ext_Nlri.new_ntop(['00000001200a0a0a0a'].pack('H*')).to_shex
   end
-end
-
-class Nlri_Test < Test::Unit::TestCase
-  include BGP
-  def test_1
-    nlri1 = Nlri.new
-    nlri1 << Nlri::Ip4.new('20.0.0.0/15')
-    nlri1 << '20.0.0.0/17'
-    nlri1 << '20.0.0.0/24'
-    s = '0f140010140011140000'
-    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)
-         
+  def _test_ext_nlris
+    ext_nlri = Ext_Nlri.new(100, Nlri.new('10.0.0.0/8','20.0.0.0/8'))
+    assert_equal '00000064080a', ext_nlri.to_shex
+    assert_equal '00000064080a', Ext_Nlri.new_ntop(ext_nlri.encode).to_shex
   end
-
-  def test_2
-    nlri1 = Nlri.new
-    nlri1 << Nlri::Ip4.new('20.0.0.0/15')
-    nlri1 << '20.0.0.0/17'
-    nlri1 << '20.0.0.0/24'
-    s = '0f140010140011140000'
-    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)      
+  def test_ext_inet
+    assert_equal '0000006410c0a8', Ext_Nlri.new(100, Inet_multicast.new('192.168.0.0/16')).to_shex
+    assert_equal '00000064402011131100000000', Ext_Nlri.new(100, Inet_multicast.new('2011:1311::/64')).to_shex
+  end
+  def test_ext_labeled
+    assert_equal '00000064600000100000200000310a0000', Ext_Nlri.new(100, Labeled.new(Prefix.new('10.0.0.1/24'),1,2,3)).to_shex
+    assert_equal '00000064800006500006610000006400000064c0a8', Ext_Nlri.new(100, Labeled.new(Vpn.new('192.168.0.0/16', Rd.new(100,100)),101,102)).to_shex
+    assert_equal '00000064b80006500006600006710000006400000064200900040005', Ext_Nlri.new(100, Labeled.new(Vpn.new('2009:4:5::1/48', Rd.new(100,100)),101,102,103)).to_shex
+    assert_match(/ID=100, Label Stack=101/, Ext_Nlri.new(100, Labeled.new(Vpn.new('2009:4:5::1/48', Rd.new(100,100)),101,102,103)).to_s)
   end
-end
+end