bgp4r 0.0.12 → 0.0.13

data/test/{common_test.rb → unit/common_test.rb}

@@ -24,18 +24,18 @@ require "bgp/common"
 
 require 'test/unit'
 class Common_Test < Test::Unit::TestCase
-  def test_ipaddr_1
+  def test_array_pack_returns_a_packed_string
     s = [1,2,3].pack('C*')
     assert(s.is_packed?)
     assert( ! "1234".is_packed?)
   end
-  def test_ipaddr_2
+  def test_ipaddr_create
     ip = IPAddr.new('10.0.0.1')
     assert_equal('0a000001', ip.to_shex)
     assert_equal('0a000001', IPAddr.create(ip.encode).to_shex)
     assert_equal('0a000001', IPAddr.create(ip.to_i).to_shex)
   end
-  def test_ipaddr_3
+  def test_ipaddr_netmask
     assert_equal(32, IPAddr.new('10.0.0.1').mlen)
     assert_equal(16, IPAddr.new('10.0.0.1/16').mlen)
     assert_equal(7, IPAddr.new('10.0.0.0/7').mlen)
@@ -54,18 +54,18 @@ class Common_Test < Test::Unit::TestCase
     assert_equal('ffff:ffff:ffff:0000:0000:0000:0000:0000',IPAddr.new('2011:1:18::1/48').netmask)
     assert_equal('ffff:ffff:0000:0000:0000:0000:0000:0000',IPAddr.new('2011:1:18::1/32').netmask)
   end
-  def test_ipaddr_4
+  def test_ipaddr_arithmetic
     ip1 = IPAddr.new('10.0.0.1/28')
     ip2 = IPAddr.new('10.0.0.1/24')
     ip3 = IPAddr.new('10.0.0.1/12')
     assert_equal('10.0.0.16/28', ip1 ^ 1)
     assert_equal('10.0.0.32/28', ip1 ^ 2)
-    assert_equal('10.0.1.0/24', ip2 ^ 1)
-    assert_equal('10.0.2.0/24', ip2 ^ 2)
+    assert_equal('10.0.1.0/24',  ip2 ^ 1)
+    assert_equal('10.0.2.0/24',  ip2 ^ 2)
     assert_equal('10.16.0.0/12', ip3 ^ 1)
     assert_equal('10.32.0.0/12', ip3 ^ 2)
   end
-  def test_string_1      
+  def test_string_pack
     sbin = ['00'].pack('H*')
     assert_equal '0x0000:  00', sbin.hexlify.join
     sbin = ['0001'].pack('H*')
@@ -79,7 +79,4 @@ class Common_Test < Test::Unit::TestCase
     assert_equal '0x0001:  1011 1213 1415 1617 1819 1a1b 1c1d 1e1f', sbin.hexlify[2]
     assert_equal '0x0002:  20', sbin.hexlify[3]
   end
-  def test_nlri
-    assert_equal('14000000', IPAddr.new_nlri4(['101400'].pack('H*')).to_shex)
-  end
 end

data/test/{iana_test.rb → unit/iana_test.rb}

@@ -25,16 +25,17 @@ require "bgp/iana"
 require 'test/unit'
 class TestBgpIana < Test::Unit::TestCase
   def test_afi?
-    assert_equal 1, IANA.afi?(:ip)
-    assert_equal 2, IANA.afi?(:ip6)
+    assert_equal 1, IANA.afi?(:ipv4)
+    assert_equal 2, IANA.afi?(:ipv6)
     assert_equal 5, IANA.afi?(:bbn)
     assert_equal 12, IANA.afi?(:appletalk)
-    assert_equal 'IP', IANA.afi?(1)
-    assert_equal 'IP6',IANA.afi?(2)
+    assert_equal 'IPv4', IANA.afi?(1)
+    assert_equal 'IPv6', IANA.afi?(2)
+    assert_equal 'NSAP', IANA.afi?(3)
   end
   def test_safi?
-    assert_equal 1, IANA.safi?(:unicast_nlri)
-    assert_equal 2, IANA.safi?(:multicast_nlri)
+    assert_equal 1, IANA.safi?(:unicast)
+    assert_equal 2, IANA.safi?(:multicast)
     assert_equal 4, IANA.safi?(:label_nlri)
     assert_equal 5, IANA.safi?(:mcast_vpn)
     assert_equal 64, IANA.safi?(:tunnel)

data/test/{messages → unit/messages}/capability_test.rb

@@ -68,7 +68,7 @@ end
 class TestBgpMessagesCapability < Test::Unit::TestCase
   include BGP
   include BGP::OPT_PARM
-  def test_capability_1
+  def test_adding_dyn_cap_to_message
     cap_msg = BGP::Capability.new
     assert_equal('ffffffffffffffffffffffffffffffff001306', cap_msg.to_shex)
     cap_msg <<  BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.new(1,1))
@@ -76,14 +76,21 @@ class TestBgpMessagesCapability < Test::Unit::TestCase
     cap_msg <<  BGP::Capability::Revision.advertise( 20, DYN_CAP::Mbgp.new(1,2))
     assert_match(/^(ff){16}002b06\s*000000000a01000400010001\s*000000001401000400010002/, cap_msg.to_shex)
   end
-  def test_capability_2
+  def test_new_cap_message_with_dyn_caps
     cap_msg = BGP::Capability.new(
       BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.new(1,1)),
       BGP::Capability::Revision.advertise( 20, DYN_CAP::Mbgp.new(1,2))
     )
     assert_match(/^(ff){16}002b06\s*000000000a01000400010001\s*000000001401000400010002/, cap_msg.to_shex)
   end
-  def test_capability_3
+  def test_new_cap_message_with_dyn_caps_verbose
+    cap_msg = BGP::Capability.new(
+      BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.advertise( 20, DYN_CAP::Mbgp.ipv4_multicast)
+    )
+    assert_match(/^(ff){16}002b06\s*000000000a01000400010001\s*000000001401000400010002/, cap_msg.to_shex)
+  end
+  def test_capability_advertise_remove_dyn_caps
 
     s = 'Capability (6), length: 91
   Seqn        Action     Ack bits    Capability
@@ -95,14 +102,24 @@ class TestBgpMessagesCapability < Test::Unit::TestCase
   0x00000020  Withdraw   Rsp (0x81)  MBGP IPv4, Unicast'
 
     cap_msg = BGP::Capability.new(
-    BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.new(1,1)),
-    BGP::Capability::Revision.advertise_ack_request( 20, DYN_CAP::Mbgp.new(1,1)),
-    BGP::Capability::Revision.advertise_ack_response( 20, DYN_CAP::Mbgp.new(1,1)),
-    BGP::Capability::Revision.remove( 10, DYN_CAP::Mbgp.new(1,1)),
-    BGP::Capability::Revision.remove_ack_request( 20, DYN_CAP::Mbgp.new(1,1)),
-    BGP::Capability::Revision.remove_ack_response( 20, DYN_CAP::Mbgp.new(1,1))
+      BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.new(1,1)),
+      BGP::Capability::Revision.advertise_ack_request( 20, DYN_CAP::Mbgp.new(1,1)),
+      BGP::Capability::Revision.advertise_ack_response( 20, DYN_CAP::Mbgp.new(1,1)),
+      BGP::Capability::Revision.remove( 10, DYN_CAP::Mbgp.new(1,1)),
+      BGP::Capability::Revision.remove_ack_request( 20, DYN_CAP::Mbgp.new(1,1)),
+      BGP::Capability::Revision.remove_ack_response( 20, DYN_CAP::Mbgp.new(1,1))
     )
     assert_equal s, cap_msg.to_s
+    
+    cap_msg2 = BGP::Capability.new(
+      BGP::Capability::Revision.advertise( 10, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.advertise_ack_request( 20, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.advertise_ack_response( 20, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.remove( 10, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.remove_ack_request( 20, DYN_CAP::Mbgp.ipv4_unicast),
+      BGP::Capability::Revision.remove_ack_response( 20, DYN_CAP::Mbgp.ipv4_unicast)
+    )
+    assert_equal(cap_msg.to_shex, cap_msg2.to_shex)
   end
   def test_factory
     s = 'ffffffffffffffffffffffffffffffff002b06000000000a01000400010001000000001401000400010002'

data/test/{messages → unit/messages}/route_refresh_test.rb

@@ -28,7 +28,7 @@ class Route_refresh_Test < Test::Unit::TestCase
   def test_1
     s = "ffffffffffffffffffffffffffffffff00170500010001"
     sbin = [s].pack('H*')
-    assert_equal(Route_refresh, Message.factory(sbin).class)
+    assert_equal(BGP::Route_refresh, Message.factory(sbin).class)
     rr =  Message.factory(sbin)
     assert_equal(s, rr.to_shex)
     rr.afi, rr.safi=2,2
@@ -37,9 +37,9 @@ class Route_refresh_Test < Test::Unit::TestCase
     assert_equal('ffffffffffffffffffffffffffffffff00170500020002', rr.to_shex)
     assert_raise(ArgumentError) { rr.safi=0x100 }
     assert_raise(ArgumentError) { rr.afi=-1 }
-    assert_equal(s, Route_refresh.new(1,1).to_shex)
-    assert_equal(s, Route_refresh.new(:afi=>1, :safi=>1).to_shex)
-    assert_equal({:afi=>1, :safi=>1}, Route_refresh.new(:afi=>1, :safi=>1).to_hash)
+    assert_equal(s, BGP::Route_refresh.new(1,1).to_shex)
+    assert_equal(s, BGP::Route_refresh.new(:afi=>1, :safi=>1).to_shex)
+    assert_equal({:afi=>1, :safi=>1}, BGP::Route_refresh.new(:afi=>1, :safi=>1).to_hash)
     assert_equal(s, Message.route_refresh(1,1).unpack('H*')[0])
   end
 end

data/test/{messages → unit/messages}/update_test.rb

@@ -25,13 +25,13 @@ require 'bgp4r'
 
 class Update_Test < Test::Unit::TestCase
   include BGP
-  def test_1
+  def test_factory_to_create_an_update_message
     s = "ffffffffffffffffffffffffffffffff006b0200000054400101024002009004040000000040050400000064c0100800020c8f04127ee8800a0800000001000000048009045134134d800e1f0001800c00000000000000005134134d00680114d100000c8f041291480a39"
     sbin = [s].pack('H*')
     u = Update.new(sbin)
     assert_equal(Update, Message.factory(sbin).class)
   end
-  def test_2
+  def test_factory_to_create_an_update_message_with_multiple_nlris
     s = "
     ffff ffff ffff ffff
     ffff ffff ffff ffff 0070 0200 0000 5940
@@ -53,14 +53,25 @@ class Update_Test < Test::Unit::TestCase
     assert_equal(2,m.nlri.size)
     assert_equal("10.10.10.10/32\n32.32.32.32/32", m.nlri.to_s)
   end
-  def test_3
+  def test_factory_to_create_a_widthdrawn_message
     s = 'ffffffffffffffffffffffffffffffff0050020000002f40010101400304c0a80105800404000000644005040000006440020402010064c0080c051f00010137003b0af50040200a0a0a0a2020202020'
     m = Message.factory([s].pack('H*'))
     w = Update.withdrawn(m)
     assert_equal(Update,w.class)
     assert_equal('200a0a0a0a2020202020', w.withdrawn.to_shex)
   end
-  def test_4
+  
+  def __test_experiment
+    upd = Update.new do
+      path_attribute << Local_pref.new
+      path_attribute << Origin.new
+      path_attribute << Next_hop.new('10.1.1.1')
+      10.times { |i| nlri << "10.0.#{i}.0/24"}
+    end
+    puts upd
+  end
+  
+  def test_verify_as4_byte_encoding
     an_update = Update.new(
     Path_attribute.new(
     Origin.new(1),
@@ -75,7 +86,7 @@ class Update_Test < Test::Unit::TestCase
     
     assert_equal(3*2, an_update.encode4.size - an_update.encode.size)
   end
-  def test_5
+  def test_verify_access_to_update_info
     an_update = Update.new( Path_attribute.new( Origin.new(1),
      Next_hop.new('10.0.0.1'),
      Multi_exit_disc.new(100)
@@ -93,7 +104,7 @@ class Update_Test < Test::Unit::TestCase
     assert_equal 4, an_update.nlri.size
   end
 
-  def test_6
+  def test_factory_to_build_update_with_session_info
     s = 'ffffffffffffffffffffffffffffffff004a02000000274001010040020a0202000000c80000006440030428000101c0080c0137003b051f00010af50040114d0000124e0000134f0000'
     m = Message.factory([s].pack('H*'), Update::Info.new(true))
     assert_not_nil m
@@ -101,7 +112,7 @@ class Update_Test < Test::Unit::TestCase
     assert_equal(s, m.to_shex(Update::Info.new(true)))
   end
 
-  def test_7
+  def _test_7
     # build an update from a yaml description
     # advertised 172.18.179.192/27 
     # origin igp
@@ -126,7 +137,7 @@ class Update_Test < Test::Unit::TestCase
     "
   end
 
-  def test_8
+  def test_verify_one_can_modify_update_info
     o = Update::Info.new(true)
     def o.recv_inet_unicast? ; false ; end
     s = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0072020000001F4001010040020A0204212C051319351AFE400304557200D9C00804212C045C175D76D6175D76DE1659299C175929981659235C16592D6417592D6417592D6617592D6217C3D228185D73241859284417C3FE84165C727015592190'
@@ -140,7 +151,7 @@ class Update_Test < Test::Unit::TestCase
     assert_equal '100 556533011 422910718', pa[As_path].as_path
   end
 
-  def test_9
+  def test_crate_a_withdrawn_update_message
     # FFFFFFFFFF
     # 0023 02 000C 16D40374 1755C688 16D40830 0000
     s = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF002302000C16D403741755C68816D408300000'
@@ -149,7 +160,7 @@ class Update_Test < Test::Unit::TestCase
     assert_equal 3,m.withdrawn.nlris.size
   end
  
-  def test_10
+  def test_factory_to_create_an_update_message_witth_ext_inet_unicast_nlris
     o = Update::Info.new(true)
     def o.recv_inet_unicast? ; true ; end
     def o.send_inet_unicast? ; true ; end
@@ -157,7 +168,7 @@ class Update_Test < Test::Unit::TestCase
       Path_attribute.new(
        As_path.new(100)
       ),
-      Ext_Nlri.new(100, Nlri.new('77.0.0.0/17'))
+      Nlri.new([100,'77.0.0.0/17'])
     )
     assert_equal('ffffffffffffffffffffffffffffffff0028020000000940020602010000006400000064114d0000', upd1.to_shex(o))
     # Need to tell the factory we are dealing with a ext nlri.
@@ -183,7 +194,7 @@ class Update_Test < Test::Unit::TestCase
     )
     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)
+    assert_match(/ID=100, IPv4/,upd1.path_attribute[:mp_reach].to_s)
     
     # received as2byte encode aspath attr
     upd2 = Update.factory upd1.encode, :as4byte=> false, :path_id=>true
@@ -205,18 +216,18 @@ class Update_Test < Test::Unit::TestCase
     Update.factory(sbin,o)
   end
   
-  def test_path_id_inet_unicast
+  def test_factory_to_build_and_update_for_inet_unicast_with_path_id
     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
+    assert_equal 'ID=100, 20.0.0.0/25', upd.nlri.nlris[0].to_s
     
   end
   
-  def test_path_id_inet_mpls_vpn_unicast
+  def test_factory_to_build_and_update_for_inet_mpls_vpn_unicast_with_path_id
     s = "
     ffff ffff ffff ffff ffff ffff ffff ffff
     005f 0200 0000 4840 0101 0140 0200 8004
@@ -246,7 +257,7 @@ class Update_Test < Test::Unit::TestCase
     
   end
   
-  def test_path_id_inet_mpls_vpn_unicast_withdrawn
+  def test_factory_to_build_a_withdrawn_update_for_inet_mpls_vpn_unicast_with_path_id
     upd = ext_update "
     ffff ffff ffff ffff ffff ffff ffff ffff
     0031 0200 0000 1a90 0f00 1600 0180 0000
@@ -256,7 +267,7 @@ class Update_Test < Test::Unit::TestCase
     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
+    assert_equal 'Label Stack=524288 (bottom) RD=1:1, ID=1, IPv4=10.1.1.0/24', mp_unreach.nlris[0].to_s
   end
 
 end

data/test/{neighbor → unit/neighbor}/add_path_cap_test.rb

@@ -26,6 +26,16 @@ class TestBgpNeighborAddPathCap < Test::Unit::TestCase
     assert   session_cap.path_id_send?(1,1)
     assert ! session_cap.send_inet_multicast?
   end
+  def test_add_path_recv_inet_unicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send, 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.recv_inet_unicast?
+    assert    session_cap.path_id_recv?(1,1)
+    assert  ! session_cap.send_inet_unicast?
+    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))
@@ -51,4 +61,35 @@ class TestBgpNeighborAddPathCap < Test::Unit::TestCase
     assert  ! session_cap.send_inet6_multicast?
     assert  ! session_cap.recv_inet6_multicast?
   end
+
+  def test_add_path_send_inet_unicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :recv, 1, 1))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send, 1, 1))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert   session_cap.send_inet_unicast?
+    assert   session_cap.path_id_send?(1,1)
+    assert ! session_cap.path_id_recv?(1,1)
+    assert ! session_cap.send_inet_multicast?
+  end
+  def test_add_path_send_inet_unicast_2
+    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, 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_recv_inet6_multicast
+    peer    = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :send, 2, 2))
+    speaker = Open.new(4,100, 200, '10.0.0.1', OPT_PARM::CAP::Add_path.new( :recv, 2, 2))
+    session_cap = Neighbor::Capabilities.new(speaker, peer)
+    assert ! session_cap.path_id_recv?(2,1)
+    assert   session_cap.path_id_recv?(2,2)
+    assert ! session_cap.path_id_send?(2,2)
+    assert   session_cap.recv_inet6_multicast?
+    assert ! session_cap.recv_inet_multicast?
+    assert ! session_cap.send_inet_unicast?
+  end
+
 end

data/test/{neighbor → unit/neighbor}/neighbor_test.rb

@@ -23,14 +23,18 @@
 require "test/unit"
 require 'bgp4r'
 require 'test/helpers/server'
+include BGP
+include BGP
+include BGP::OPT_PARM::CAP
+include BGP::TestHelpers
+
 
 class TestBgpNeighbor < Test::Unit::TestCase
   include BGP
   include BGP::OPT_PARM::CAP
   include BGP::TestHelpers
-  def setup
-  end
   def teardown
+    stop_server
   end
   def test_open_msg
     neighbor = Neighbor.new \
@@ -50,7 +54,6 @@ class TestBgpNeighbor < Test::Unit::TestCase
     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 \
@@ -71,7 +74,6 @@ class TestBgpNeighbor < Test::Unit::TestCase
     @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)
@@ -79,7 +81,6 @@ class TestBgpNeighbor < Test::Unit::TestCase
     @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
@@ -96,7 +97,6 @@ class TestBgpNeighbor < Test::Unit::TestCase
             "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
@@ -115,7 +115,6 @@ class TestBgpNeighbor < Test::Unit::TestCase
             "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
@@ -134,9 +133,7 @@ class TestBgpNeighbor < Test::Unit::TestCase
             "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)
@@ -154,8 +151,29 @@ class TestBgpNeighbor < Test::Unit::TestCase
             "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
+  def test_add_capabilities_using_sym
+    neighbor = Neighbor.new(4,100,180,'0.0.0.2')
+    neighbor.capability :as4_byte
+    neighbor.capability :route_refresh
+    neighbor.capability :route_refresh, 128
+    neighbor.capability :mbgp, :ipv4, :unicast
+    neighbor.capability :mbgp, :ipv4, :multicast
+    assert_equal('ffffffffffffffffffffffffffffffff003d0104006400b400000002200206410400000064020202000202800002060104000100010206010400010002', neighbor.open.to_shex)
+    assert_equal(5, neighbor.instance_eval { @opt_parms}.size)
+  end
+  def test_add_capabilities_using_method_missing
+    n = Neighbor.new(4,100,180,'0.0.0.2')
+    n.capability_mbgp_ipv4_unicast
+    n.capability_mbgp_ipv4_multicast
+    n.capability_mbgp_ipv4_mpls_vpn_unicast
+    n.capability_mbgp_ipv6_mpls_vpn_multicast
+    n.capability_mbgp_nsap_mpls_vpn_unicast
+    n.capability_mbgp_nsap_unicast
+    n.capability_route_refresh
+    n.capability_route_refresh 128
+    n.capability_four_byte_as
+    assert_equal(9, n.instance_eval { @opt_parms }.size )
+    assert_equal('ffffffffffffffffffffffffffffffff005d0104006400b4000000024002060104000100010206010400010002020601040001008002060104000200810206010400030080020601040003000102020200020280000206410400000064', n.open.to_shex)
+  end
+end

data/test/unit/nlris/labeled_test.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+
+require "bgp/nlris/labeled"
+require 'bgp/nlris/prefix'
+
+class TestBgpNlrisLabeled < Test::Unit::TestCase
+  include BGP
+  def test_new
+    assert_equal('Label Stack=100 (bottom) 10.0.0.0/8',  Labeled.new(Prefix.new('10.0.0.1/8'), 100).to_s)
+    assert_equal('Label Stack=100,101 (bottom) 10.0.0.0/8',  Labeled.new(Prefix.new('10.0.0.1/8'), 100,101).to_s)
+    assert_equal('Label Stack=100,101,102 (bottom) 10.0.0.0/8',  Labeled.new(Prefix.new('10.0.0.1/8'), 100,101,102).to_s)
+    assert_equal('200006410a',  Labeled.new(Prefix.new('10.0.0.1/8'), 100).to_shex)
+    assert_equal('380006400006510a',  Labeled.new(Prefix.new('10.0.0.1/8'), 100,101).to_shex)
+    assert_equal('500006400006500006610a',  Labeled.new(Prefix.new('10.0.0.1/8'), 100,101,102).to_shex)
+    #FIXME: add labeled  and labeled vpn tests
+  end
+  def test_new_ntop
+    assert_equal('Label Stack=100 (bottom) 10.0.0.0/8', Labeled.new_ntop(['200006410a'].pack('H*'), 1, 1).to_s)
+    assert_equal('Label Stack=100,101 (bottom) 10.0.0.0/8', Labeled.new_ntop(['380006400006510a'].pack('H*'), 1, 1).to_s)
+    assert_equal('Label Stack=100,101,102 (bottom) 10.0.0.0/8', Labeled.new_ntop(['500006400006500006610a'].pack('H*'), 1, 1).to_s)
+    assert_equal('200006410a', Labeled.new_ntop(['200006410a'].pack('H*'), 1, 1).to_shex)
+    assert_equal('380006400006510a', Labeled.new_ntop(['380006400006510a'].pack('H*'), 1, 1).to_shex)
+    assert_equal('500006400006500006610a', Labeled.new_ntop(['500006400006500006610a'].pack('H*'), 1, 1).to_shex)
+    #FIXME: add labeled  and labeled vpn tests
+  end
+  def test_new_ntop_path_id
+    #FIXME: add labeled  and labeled vpn tests
+  end
+
+end

data/test/unit/nlris/nlri_test.rb

@@ -0,0 +1,103 @@
+#--
+# Copyright 2008, 2009, 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 'bgp/nlris/nlris'
+
+class Nlri_Test < Test::Unit::TestCase
+  include BGP
+
+  def test_nlri
+    nlri1 = Nlri.new
+    nlri1 << '20.0.0.0/15'
+    nlri1 << '20.0.0.0/17'
+    nlri1 << '20.0.0.0/24'
+    s = '0f140010140011140000'
+    nlri2 = Nlri.new_ntop([s].pack('H*'))
+    assert_equal('0f140010140011140000', nlri2.to_shex)
+    assert_equal('000a0f140010140011140000', nlri2.to_shex(true))
+    assert_equal(3,nlri2.nlris.size)
+  end
+  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=> '104.0.0.0/8' }
+    nlri << { :path_id=> 105, :nlri=> '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)
+    
+    nlri2 = Nlri.new(
+      [101, '101.0.0.0/8'],
+      [102, '102.0.0.0/8'],
+      [103, '103.0.0.0/8'],
+      [104, '104.0.0.0/8'],
+      [105, '105.0.0.0/8']
+    )
+    assert_equal(nlri.to_shex, nlri2.to_shex)
+  end
+  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=> '104.0.0.0/8' }
+    nlri << { :path_id=> 105, :nlri=> '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_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_ntop nlri.encode[2..-1]
+    nlri2 = Nlri.factory nlri.encode[2..-1], 1, 1
+    assert_equal(nlri1.to_shex, nlri2.to_shex)
+
+    # 16d403741755c68816d40830
+  end
+
+  def test_nlri_factory
+    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_nlri_factory_extended 
+    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