bgp4r 0.0.3

data/test/mp_reach_test.rb

@@ -0,0 +1,143 @@
+#--
+# 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 'bgp/mp_reach'
+require 'test/unit'
+
+class Mp_reach_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    s = '800e30000202102009000900190000000000000000000100402009000100000000402009000200000000402009000300000000'
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin)
+    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(2, mpr.afi)
+    assert_equal(2, mpr.safi)
+    assert_equal(s, mpr.to_shex)
+  end
+  def test_2
+    s = "800e2500020120200900090019000000000000000000012009000900190000000000000000000200"
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin)
+    assert_equal("\n    AFI IPv6 (2), SAFI Unicast (1)\n    nexthop: 2009:9:19::1, 2009:9:19::2", mpr.mp_reach)
+    assert_equal(2, mpr.afi)
+    assert_equal(1, mpr.safi)
+    assert_equal(s, mpr.to_shex)
+  end
+  def test_3
+    s = "800e0d000102080a0000010a00000200"
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin)
+    assert_equal("\n    AFI IPv4 (1), SAFI Multicast (2)\n    nexthop: 10.0.0.1, 10.0.0.2", mpr.mp_reach)
+    assert_equal(1, mpr.afi)
+    assert_equal(2, mpr.safi)
+    assert_equal(s, mpr.to_shex)
+  end
+  def test_4
+    s = "800e11000102040a0000010018c0a80118c0a802"
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin)
+    assert_equal("\n    AFI IPv4 (1), SAFI Multicast (2)\n    nexthop: 10.0.0.1\n      192.168.1.0/24\n      192.168.2.0/24", mpr.mp_reach)
+    assert_equal(1, mpr.afi)
+    assert_equal(2, mpr.safi)
+    assert_equal(s, mpr.to_shex)
+  end
+  def test_5
+    s = "800e39000204102009000900190000000000000000000100580006512009000100000000580006612009000200000000580006712009000300000000"
+    sbin = [s].pack('H*') 
+    mpr = Mp_reach.new(sbin)
+    assert_equal("\n    AFI IPv6 (2), SAFI Labeled NLRI (4)\n    nexthop: 2009:9:19::1\n      Label Stack=101 (bottom) 2009:1::/64\n      Label Stack=102 (bottom) 2009:2::/64\n      Label Stack=103 (bottom) 2009:3::/64", mpr.mp_reach)
+    assert_equal(2, mpr.afi)
+    assert_equal(4, mpr.safi)
+    assert_equal(s, mpr.to_shex)
+    #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'])
+    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')
+    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} )
+    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})
+    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})
+    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=> [
+      '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=> [
+      '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=> [
+      '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
+end
+
+class Mp_unreach_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    mpur = Mp_unreach.new(:safi=>1, :prefix=>['10.0.0.0/16', '10.1.0.0/16'])
+    assert_raise(ArgumentError) { Mp_unreach.new }
+  end
+  
+  def test_2
+    mpur = Mp_unreach.new(:safi=>2, :prefix=>['192.168.1.0/24', '192.168.2.0/24'])
+    assert_equal('800f0b00010218c0a80118c0a802', mpur.to_shex)
+    
+     mpur = Mp_unreach.new(:safi=>2, :prefix=>['2007:1::/64', '2007:2::/64','2007:3::/64'])
+     assert_equal('800f1e000202402007000100000000402007000200000000402007000300000000', mpur.to_shex)
+
+     #mpur = Mp_unreach.new(:safi=>2, :prefix=>['2007:1::/64, 101', '2007:2::/64,102','2007:3::/64, 103'])
+     mpur = Mp_unreach.new(:safi=>4, :nlri=> [
+       {:prefix=>'2007:1::/64', :label=> 101},
+       {:prefix=>'2007:2::/64', :label=> 102},
+       {:prefix=>'2007:3::/64', :label=> 103},])
+    assert_equal('800f27000204580006512007000100000000580006612007000200000000580006712007000300000000', mpur.to_shex)
+    assert_match(/^800f..000204/,mpur.to_shex)
+    assert_match(/58000651200700010000000058/,mpur.to_shex)
+    assert_match(/58000661200700020000000058/,mpur.to_shex)
+    assert_match(/580006712007000300000000$/,mpur.to_shex)
+
+    mpur = Mp_unreach.new(:safi=>128, :nlri=> [
+      {:rd=> Rd.new(100,100), :prefix=> Prefix.new('192.168.1.0/24'), :label=>101},
+      {:rd=> Rd.new(100,100), :prefix=> Prefix.new('192.168.2.0/24'), :label=>102},
+      {:rd=> Rd.new(100,100), :prefix=> Prefix.new('192.168.3.0/24'), :label=>103},])
+    assert_match(/^800f..000180/,mpur.to_shex)
+    assert_equal("700006510000006400000064c0a801",mpur.nlris[0].to_shex)
+    assert_equal("700006610000006400000064c0a802",mpur.nlris[1].to_shex)
+
+  end
+end

data/test/multi_exit_disc_test.rb

@@ -0,0 +1,46 @@
+#--
+# 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 "bgp/multi_exit_disc"
+require 'test/unit'
+class Multi_exit_disc_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal("80040400000000", Multi_exit_disc.new.to_shex)
+    assert_equal("80040400000064", Multi_exit_disc.new(100).to_shex)
+    assert_equal("800404000000c8", Multi_exit_disc.new(200).to_shex)
+    assert_equal("800404000000c8", Multi_exit_disc.new(:med=>200).to_shex)
+    assert_equal("800404000000c8", Multi_exit_disc.new(:multi_exit_disc=>200).to_shex)
+    assert_raise(ArgumentError) { Multi_exit_disc.new(:local_pref=>200) }
+    assert_equal("(0x00c8) 200", Multi_exit_disc.new(200).multi_exit_disc)
+    assert_equal("[Oncr]  (4) Multi Exit Disc: [800404000000c8] '(0x00c8) 200'", Multi_exit_disc.new(200).to_s)
+    assert_raise(ArgumentError) { Multi_exit_disc.new({})}
+  end
+  def test_2
+    mp =  Multi_exit_disc.new(200)
+    assert_equal("800404000000c8", Multi_exit_disc.new(mp.encode).to_shex)
+    assert_equal("(0x00c8) 200", Multi_exit_disc.new(200).multi_exit_disc)
+    assert_equal(200, Multi_exit_disc.new(200).to_i)
+    mp1 = Multi_exit_disc.new(mp)
+    assert_equal(mp.encode, mp.encode)
+  end
+end

data/test/neighbor_test.rb

@@ -0,0 +1,50 @@
+#--
+# 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 "bgp/neighbor"
+require 'bgp/message'
+
+class TestBgpNeighbor < Test::Unit::TestCase
+  include BGP
+  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_cap.ipv4_unicast
+    neighbor.capability Mbgp_cap.ipv4_multicast
+    neighbor.capability Route_refresh_cap.new
+    neighbor.capability Route_refresh_cap.new 128
+    neighbor.capability As4_cap.new(100)
+    open_msg = neighbor.instance_eval { _open_msg_ }
+    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
+end

data/test/next_hop_test.rb

@@ -0,0 +1,37 @@
+#--
+# 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 'bgp/next_hop'
+require 'test/unit'  
+class Next_hop_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    next_hop = Next_hop.new('10.0.0.1')
+    assert_equal('10.0.0.1', next_hop.next_hop)
+    assert_equal("[wTcr]  (3)   Next Hop: [4003040a000001] '10.0.0.1'", next_hop.to_s)
+    assert_equal(167772161, next_hop.to_i)
+    assert_equal('4003040a000001', next_hop.to_shex)
+    assert_equal(next_hop.to_shex, Next_hop.new(next_hop.encode).to_shex)
+    next_hop1 = Next_hop.new(next_hop)
+    assert_equal(next_hop.encode, next_hop1.encode)
+  end
+end

data/test/nlri_test.rb

@@ -0,0 +1,189 @@
+#--
+# 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 'bgp/nlri'
+require 'test/unit'  
+class NLRI_Ip4_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)
+  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])
+
+  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')
+    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))
+    assert_equal(3,nlri2.nlris.size)
+  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)
+         
+  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)      
+  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('402009000400040000',Prefix.new('2009:4:4::/64').ipv6?)
+    assert_equal('2009:4:4::/64',Prefix.new('2009:4:4::/64').to_s)
+  end
+end
+class Inet_unicast_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal(1,Inet_unicast.new('192.168.0.0/16').afi)
+    assert_equal(1,Inet_unicast.new('192.168.0.0/16').safi)
+    assert_equal(2,Inet_unicast.new('2009:4:4::/64').afi)
+    assert_equal(1,Inet_unicast.new('2009:4:4::/64').safi)
+    assert_equal(1,Inet_multicast.new('192.168.0.0/16').afi)
+    assert_equal(2,Inet_multicast.new('192.168.0.0/16').safi)
+    assert_equal(2,Inet_multicast.new('2009:4:4::/64').afi)
+    assert_equal(2,Inet_multicast.new('2009:4:4::/64').safi)
+  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)
+  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)
+  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)
+  end
+end

data/test/origin_test.rb

@@ -0,0 +1,57 @@
+#--
+# 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 'bgp/origin'
+require 'test/unit'  
+class Origin_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal("40010100", Origin.new.to_shex)
+    assert_equal("40010100", Origin.new(:igp).to_shex)
+    assert_equal("40010101", Origin.new(:egp).to_shex)
+    assert_equal("40010102", Origin.new(:incomplete).to_shex)
+  end
+  def test_2
+    assert_equal("40010100", Origin.new(0).to_shex)
+    assert_equal("40010101", Origin.new(1).to_shex)
+    assert_equal("40010102", Origin.new(2).to_shex)
+  end
+  def test_3
+    assert_equal("40010100", Origin.new(:origin =>  0 ).to_shex)
+    assert_equal("40010101", Origin.new(:origin =>  1 ).to_shex)
+    assert_equal("40010102", Origin.new(:origin =>  2 ).to_shex)
+  end
+  def test_4
+    assert_equal("40010100", Origin.new( Origin.new.encode).to_shex)
+  end
+  def test_5
+    assert_equal("igp", Origin.new.origin)
+    assert_equal("igp", Origin.new(:igp).origin)
+    assert_equal("egp", Origin.new(:egp).origin)
+    assert_equal("incomplete", Origin.new(:incomplete).origin)
+  end
+  def test_6
+    assert_equal("[wTcr]  (1)     Origin: [40010100] 'igp'", Origin.new.to_s)
+    assert_equal("[wTcr]  (1)     Origin: [40010100] 'igp'", Origin.new(:igp).to_s)
+    assert_equal("Origin (1), length: 1, Flags [T]: igp\n   0x0000: ", Origin.new.to_s(:tcpdump))
+  end
+end

data/test/originator_id_test.rb

@@ -0,0 +1,38 @@
+#--
+# 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 'bgp/originator_id'
+require 'test/unit'  
+class Originator_id_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    orig_id = Originator_id.new('10.0.0.1')
+    assert_equal('10.0.0.1', orig_id.originator_id)
+    assert_equal("[Oncr]  (9) Originator Id: [8009040a000001] '10.0.0.1'", orig_id.to_s)
+    assert_equal(167772161, orig_id.to_i)
+    assert_equal('8009040a000001', orig_id.to_shex)
+    assert_equal('80090401010101', Originator_id.new('1.1.1.1').to_shex)
+    assert_equal(orig_id.to_shex, Originator_id.new(orig_id.encode).to_shex)
+    orig_id1 = Originator_id.new(orig_id)
+    assert_equal(orig_id.encode, orig_id1.encode)
+  end
+end