jesnault-bgp4r 0.0.2 → 0.0.3

data/examples/routegen

@@ -0,0 +1,85 @@
+#--
+#
+# Copyright 2008, 2009 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#++
+
+require 'rubygems'
+require 'bgp4r'
+require 'yaml'
+include BGP
+
+require 'pp'
+config_file = ARGV[0] ||= File.basename($0) + ".yml"
+
+Log.create
+Log.level=Logger::DEBUG
+config = YAML::load_file(config_file)
+
+p config
+
+config.keys.each do |k|
+  case k
+  when 'neighbor'
+    neighbor = config['neighbor']
+    neighbor.keys.each do |k|
+      case k
+      when /router\s+id/        ; @router_id = neighbor[k]
+      when /my\s+as/            ; @my_as = neighbor[k]
+      when 'holdtime'           ; @holdtime = neighbor[k]
+      when /neighbor\s+address/ ; @neighbor_addr = neighbor[k]
+      when /local\s+address/    ; @local_addr = neighbor[k]
+      when 'capabilities'
+      end
+    end
+  when 'routes'
+    routes = config['routes']
+    routes.keys.each do |k|
+      case k
+      when /nlri(|s)/
+        _pfx, _npfx, _pack = routes[k].split(',')
+        @nlri = IPAddr.new _pfx
+        @times = _npfx.to_i ||=1
+        @pack = _pack.to_i  ||=1 
+      when /next\s*hop/     ; @nexthop= routes[k]
+      when /local\s*pref/   ; @local_pref= routes[k]
+      when /med/          ; @med = routes[k]
+      when /origin/       ; @origin = routes[k]
+      when /communities/  ; @communities = routes[k]
+      when /as\s*path/      ; @as_path= routes[k]
+      end
+    end
+  end
+end
+
+neighbor = Neighbor.new \
+  :version => 4,
+  :my_as=> @my_as,
+  :remote_addr => @neighbor_addr,
+  :local_addr => @local_addr,
+  :id=> @router_id,
+  :holdtime=> @holdtime
+
+# neighbor.capability :as4_byte
+
+pa = Path_attribute.new(
+  Origin.new(@origin),
+  Next_hop.new(@nexthop),
+  Local_pref.new(@local_pref),
+  Communities.new(*(@communities.split.map { |com| com.to_i})),
+  As_path.new(*(@as_path.split.map { |as| as.to_i}))
+)
+
+neighbor.start
+
+nlris = Nlri.new
+(1..@times.to_i).each do |n|
+  nlris << (@nlri ^ n)
+  next unless (n % @pack) == 0 or (n == @times)
+  neighbor.send_message Update.new(pa, nlris)
+  nlris = Nlri.new
+end
+
+Thread.stop

data/examples/routegen.yml

@@ -0,0 +1,50 @@
+# YAML config file for routegen demo.
+# $ ruby routegen routegen.yaml
+--- 
+neighbor: 
+  router id: 1.1.1.1
+  my as: 100
+  holdtime: 180
+  local address: 192.168.1.6
+  neighbor address: 192.168.1.199
+  capabilities: 
+  - four byte as
+routes: 
+  nlris: 11.0.0.0/28, 1999, 127
+  next hop: 192.168.1.6
+  local pref: 100
+  med: 100
+  origin: 1
+  communities: 100:1 200:1 300:1
+  as path: 200 300 400 500
+
+...
+
+produces:
+
+ios#show ip route summary | inc bgp
+bgp 100         0           1999        107946      287856
+ios#
+
+ios#show ip bgp ipv4 unicast 
+BGP table version is 13995, local router ID is 172.21.2.1
+Status codes: s suppressed, d damped, h history, * valid, > best, i - internal,
+              r RIB-failure
+Origin codes: i - IGP, e - EGP, ? - incomplete
+
+   Network          Next Hop            Metric LocPrf Weight Path
+*>i11.0.0.16/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.32/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.48/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.64/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.80/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.96/28     192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.112/28    192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.128/28    192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.144/28    192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.160/28    192.168.1.6                   100      0 200 300 400 500 e
+*>i11.0.0.176/28    192.168.1.6                   100      0 200 300 400 500 e
+
+...
+
+  

data/test/aggregator_test.rb

@@ -0,0 +1,66 @@
+#--
+# 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/aggregator'
+require 'test/unit'
+class Aggregator_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    aggregator = Aggregator.new('10.0.0.1',100)
+    aggregator.encode4
+    assert_equal(aggregator.encode4, aggregator.encode)
+    assert_equal('10.0.0.1, 100', aggregator.aggregator)
+    assert_equal('c0070600640a000001', aggregator.to_shex)
+    assert_equal('c00708000000640a000001', aggregator.to_shex(true))
+    assert_equal(aggregator.to_shex, Aggregator.new(aggregator.encode).to_shex)
+    assert_equal("[OTcr]  (7) Aggregator: [c0070600640a000001] '10.0.0.1, 100'", aggregator.to_s)
+  end
+  def test_2
+    aggregator = Aggregator.new('10.0.0.1',100)
+    assert_equal('10.0.0.1, 0.100', aggregator.aggregator(true))
+    aggregator = Aggregator.new('10.0.0.1',0xdeadbeef)
+    assert_equal('10.0.0.1, 57005.48879', aggregator.aggregator(true))
+    assert_equal('c00708deadbeef0a000001', aggregator.to_shex(true))
+    aggregator = Aggregator.new(aggregator.encode(true),true)
+    assert_equal('10.0.0.1, 3735928559', aggregator.aggregator)
+    assert_equal(0xdeadbeef, aggregator.as)
+  end
+  def test3
+    ag2 = Aggregator.new('10.0.0.1',100)
+    ag4 = As4_aggregator.new('10.0.0.1',100)
+    assert_equal('c01208000000640a000001', ag4.to_shex)
+    assert_not_equal(ag2.to_shex(true), ag4.to_shex)
+    assert_equal('10.0.0.1, 0.100',ag4.aggregator)
+    assert_equal("[OTcr] (18) As4 Aggregator: [c01208000000640a00000...] '10.0.0.1, 0.100'",ag4.to_s)
+    assert_equal(ag4.to_shex,As4_aggregator.new(ag4.encode).to_shex)
+  end
+  def test4
+    ag2 = Aggregator.new('10.0.0.1',100)
+    ag = Aggregator.new(ag2)
+    assert_equal(ag2.encode, ag.encode)
+    ag4 = As4_aggregator.new('10.0.0.1',100)
+    ag = As4_aggregator.new(ag4)
+    assert_raise(ArgumentError) {As4_aggregator.new(ag2)}
+    assert_equal(ag4.encode, ag.encode)
+  end
+end

data/test/as_path_test.rb

@@ -0,0 +1,149 @@
+#--
+# 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/as_path'
+require 'test/unit'
+
+class Segment_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal(BGP::ATTR::SEQUENCE, As_path::Segment.new(:sequence, 1).seg_type)
+    assert_equal([1], As_path::Segment.new(:sequence, 1).as)
+    assert_equal([1,2,3], As_path::Segment.new(:sequence, 1,2,3).as)
+    assert_equal('1 2 3', As_path::Segment.new(:sequence, 1,2,3).to_s)
+  end
+  def test_2
+    assert_equal('02010001', As_path::Segment.new(:sequence, 1).to_shex)
+    assert_equal('020100000001', As_path::Segment.new(:sequence, 1).to_shex(true))
+    assert_equal('02010001', As_path::Segment.new(['02010001'].pack('H*')).to_shex)
+    assert_equal('0203000100020003', As_path::Segment.new(:sequence, 1,2,3).to_shex)
+    assert_equal('0203000100020003', As_path::Sequence.new(1,2,3).to_shex)
+  end
+  def test_3
+    assert_equal('01010001', As_path::Segment.new(:set, 1).to_shex)
+    assert_equal('030100000001', As_path::Segment.new(:confed_sequence, 1).to_shex(true))
+    assert_equal('030100000001', As_path::Segment.new(:confed_sequence, 1).to_shex(true))
+    assert_equal('030100000001', As_path::Confed_sequence.new(1).to_shex(true))
+    assert_equal('040100000001', As_path::Confed_set.new(1).to_shex(true))
+    assert_equal('02010001', As_path::Segment.new(['02010001'].pack('H*')).to_shex)
+  end
+  def test_4
+    seg = As_path::Segment.factory(['0203000100020003'].pack('H*'))
+    assert_equal(As_path::Sequence,seg.class)
+    seg = As_path::Segment.factory(['0103000100020003'].pack('H*'))
+    assert_equal(As_path::Set,seg.class)
+    seg = As_path::Segment.factory(['0303000100020003'].pack('H*'))
+    assert_equal(As_path::Confed_sequence,seg.class)
+    seg = As_path::Segment.factory(['0403000100020003'].pack('H*'))
+    assert_equal(As_path::Confed_set,seg.class)
+    seg = As_path::Segment.factory(['0203000100020003'].pack('H*'))
+    assert_equal(As_path::Sequence,seg.class)
+    assert_equal('0203000100020003', seg.to_shex)
+    assert_equal('0203000000010000000200000003', seg.to_shex(true))
+    seg = As_path::Segment.factory(['0203000000010000000200000003'].pack('H*'), true)
+    assert_equal('0203000000010000000200000003', seg.to_shex(true))
+    assert_equal('0203000100020003', seg.to_shex(false))
+  end
+end
+
+class As_path_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal('400200', As_path.new.to_shex)
+    path =  As_path.new(1)
+    assert_equal("40020402010001", As_path.new(1).to_shex)
+    assert_equal("40020402010001", As_path.new(As_path::Sequence.new(1)).to_shex)
+    assert_equal("40020402010001", As_path.new(As_path::Segment.new(:sequence,1)).to_shex)
+    assert_equal("4002080203000100020003", As_path.new(1,2,3).to_shex)
+    assert_equal("4002080203000100020003", As_path.new(As_path::Sequence.new(1,2,3)).to_shex)
+    assert_equal("4002080203000100020003", As_path.new(As_path::Segment.new(:sequence,1,2,3)).to_shex)
+  end
+  def test_2
+    path =  As_path.new(['4002080203000100020003'].pack('H*').is_packed)
+    assert_equal('4002080203000100020003', path.to_shex)
+    path << As_path::Set.new(1,2,3)
+    path << As_path::Confed_sequence.new(1,2,3)
+    assert_equal('400218020300010002000301030001000200030303000100020003', path.to_shex)
+    assert_equal('40021802030...', path.to_shex_len(10))
+    assert_equal("[wTcr]  (2)    As Path: [400218020300010002000...] '1 2 3 {1, 2, 3} (1 2 3)'", path.to_s)
+  end
+  def test_3
+    path = As_path.new(1,2,3)
+    path.as4byte=true
+    assert_equal('40020e0203000000010000000200000003', path.to_shex)
+    assert_equal('4002080203000100020003', path.to_shex(false))
+    path.as4byte=false
+    assert_equal('4002080203000100020003', path.to_shex)
+    assert_equal('40020e0203000000010000000200000003', path.to_shex(true))
+  end
+  def test_4
+    assert_equal('400200', As_path.new.to_shex)
+    path =  As_path.new(1)
+    assert_equal("1", As_path.new(1).as_path)
+    assert_equal("1", As_path.new(As_path::Sequence.new(1)).as_path)
+    assert_equal("1", As_path.new(As_path::Segment.new(:sequence,1)).as_path)
+    assert_equal("1 2 3 4 5 6 7", As_path.new(1,2,3,4,5,6,7).as_path)
+    assert_equal("{1, 2, 3}", As_path.new(As_path::Set.new(1,2,3)).as_path)
+    assert_equal("(1 2 3)", As_path.new(As_path::Segment.new(:confed_sequence,1,2,3)).as_path)
+    assert_equal("[1, 2, 3]", As_path.new(As_path::Segment.new(:confed_set,1,2,3)).as_path)
+    assert_equal("[wTcr]  (2)    As Path: [400208040300010002000...] '[1, 2, 3]'", As_path.new(As_path::Segment.new(:confed_set,1,2,3)).to_s)
+  end
+  def test_5
+    two_byte_as = '4002080203000100020003'
+    four_byte_as = '40020e0203000000010000000200000003'
+    path = As_path.new([four_byte_as].pack('H*'),true)
+    assert_equal(two_byte_as, path.to_shex)
+    assert_equal(four_byte_as, path.to_shex(true))
+    path = As_path.new([two_byte_as].pack('H*'))
+    assert_equal(two_byte_as, path.to_shex)
+    assert_equal(four_byte_as, path.to_shex(true))
+    asp = As_path.new(['40020c020500010002000300040005c0080c051f00010137003b0af50040'].pack('H*'))
+    asp2 = As_path.new(asp)
+    assert_equal(asp.encode, asp2.encode)
+  end
+end
+
+class As4_path_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal('c01100', As4_path.new.to_shex)
+    path =  As4_path.new(1)
+    assert_equal("c01106020100000001", As4_path.new(1).to_shex)
+    assert_equal("c01106020100000001", As4_path.new(As_path::Sequence.new(1)).to_shex)
+    assert_equal("c01106020100000001", As4_path.new(As_path::Segment.new(:sequence,1)).to_shex)
+    assert_equal("c0110e0203000000010000000200000003", As4_path.new(1,2,3).to_shex)
+    assert_equal("c0110e0203000000010000000200000003", As4_path.new(As_path::Sequence.new(1,2,3)).to_shex)
+    assert_equal("c0110e0203000000010000000200000003", As4_path.new(As_path::Segment.new(:sequence,1,2,3)).to_shex)
+  end
+  def test_2
+    path =  As4_path.new(['c0110e0203000000010000000200000003'].pack('H*'))
+    assert_equal('c0110e0203000000010000000200000003', path.to_shex)
+    path << As_path::Set.new(1,2,3)
+    path << As_path::Confed_sequence.new(1,2,3)
+    assert_equal('c0112a020300000001000000020000000301030000000100000002000000030303000000010000000200000003', path.to_shex)
+    assert_equal('c0112a02030...', path.to_shex_len(10))
+    assert_equal('1 2 3 {1, 2, 3} (1 2 3)',path.as_path)
+    assert_equal("[OTcr] (17)   As4 Path: [c0112a020300000001000...] '1 2 3 {1, 2, 3} (1 2 3)'",path.to_s)
+  end
+end
+
+#MiniTest::Unit.autorun

data/test/atomic_aggregate_test.rb

@@ -0,0 +1,35 @@
+#--
+# 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/atomic_aggregate"
+
+require 'test/unit'
+class Atomic_aggregate_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal("800600", Atomic_aggregate.new.to_shex)
+    assert_equal("Atomic Aggregate (6), length: 0, Flags [O]: ", Atomic_aggregate.new.to_s)
+    obj =  Atomic_aggregate.new
+    assert_equal("800600", Atomic_aggregate.new(obj.encode).to_shex)
+  end
+end
+

data/test/attribute_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/common'
+require 'bgp/path_attribute'
+require 'test/unit'
+
+class ATTR_Test < Test::Unit::TestCase
+  include BGP
+  class Attr_test < Attr
+    def initialize
+      @type, @flags = 0, 0
+    end
+    def encode
+      @type=0xee
+      @flags=0xf
+      super()
+    end
+  end
+  def test_1
+   assert_equal('f0ee00',Attr_test.new.to_shex)
+   attr = Attr_test.new
+   assert_equal(attr.encode4, attr.encode)
+  end
+end
+class Attr_factory_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    s = ['400101014003040a000001800404000000644005040000006440020c020500010002000300040005c0080c051f00010137003b0af50040'].pack('H*')
+    assert_equal(Origin, BGP::Attr.factory(s).class)
+    assert_equal(Next_hop, BGP::Attr.factory(s).class)
+    assert_equal(Multi_exit_disc, BGP::Attr.factory(s).class)
+    assert_equal(Local_pref, BGP::Attr.factory(s).class)
+    assert_equal(As_path, BGP::Attr.factory(s).class)
+    assert_equal(Communities, BGP::Attr.factory(s).class)
+    assert_equal('',s)
+  end
+end

data/test/cluster_list_test.rb

@@ -0,0 +1,39 @@
+#--
+# 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/cluster_list'
+require 'test/unit'  
+class Cluster_list_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    list1 = Cluster_list.new('192.168.0.1','10.0.0.1')
+    list2 = Cluster_list.new('192.168.0.1 10.0.0.1')
+    assert_equal('800a08c0a800010a000001', list1.to_shex)
+    assert_equal(list1.to_shex, list2.to_shex)
+    assert_equal('192.168.0.1 10.0.0.1',list1.cluster_list)
+    assert_equal("[Oncr] (10) Cluster List: [800a08c0a800010a00000...] '192.168.0.1 10.0.0.1'", list1.to_s)
+    list3 = Cluster_list.new(['800a08c0a800010a000001'].pack('H*'))
+    assert_equal(list1.encode, list3.encode)
+    list4 = Cluster_list.new(list3)
+    assert_equal(list3.encode, list4.encode)
+  end
+end

data/test/common_test.rb

@@ -0,0 +1,68 @@
+#--
+# 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/common"
+
+require 'test/unit'
+class Common_Test < Test::Unit::TestCase
+  def test_ipaddr_1
+    s = [1,2,3].pack('C*')
+    assert(s.is_packed?)
+    assert( ! "1234".is_packed?)
+  end
+  def test_ipaddr_2
+    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
+    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)
+    assert_equal(128, IPAddr.new('0::0').mlen)
+    assert_equal(96, IPAddr.new('2004::0001:3/96').mlen)
+    assert_equal('255.255.255.255', IPAddr.new('1.1.1.1').netmask)
+    assert_equal('255.255.255.255', IPAddr.new('1.1.1.1/32').netmask)
+    assert_equal('255.255.255.254', IPAddr.new('1.1.1.1/31').netmask)
+    assert_equal('255.255.255.252', IPAddr.new('1.1.1.1/30').netmask)
+    assert_equal('255.255.255.248', IPAddr.new('1.1.1.1/29').netmask)
+  end
+  def test_ipaddr_4
+    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.16.0.0/12', ip3 ^ 1)
+    assert_equal('10.32.0.0/12', ip3 ^ 2)
+  end
+  def test_string_1      
+    sbin = ['0a000001'].pack('H*')
+    assert_equal('0x0000: 0a00 0001',sbin.hexlify.join)
+  end
+  def test_nlri
+    assert_equal('14000000', IPAddr.new_nlri4(['101400'].pack('H*')).to_shex)
+  end
+end

data/test/communities_test.rb

@@ -0,0 +1,75 @@
+#--
+# 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/communities'
+
+require 'test/unit'  
+class Community_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal(0xFFFFFF01,Communities::Community.new(:no_export).to_i)
+    assert_equal(0xFFFFFF02,Communities::Community.new(:no_advertise).to_i)
+    assert_equal(0xFFFFFF03,Communities::Community.new(:no_export_sub_confed).to_i)
+    assert_equal(0xFFFFFF04,Communities::Community.new(:no_peer).to_i)
+    assert_equal(0xdeadbeef,Communities::Community.new(0xdeadbeef).to_i)
+  end
+end
+class Communities_Test < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal('113:10 113:20 113:30 113:40', Communities.new("113:10", "113:20", "113:30", "113:40").communities)
+    assert_equal('113:10 113:20 113:30 113:40', Communities.new("113:10 113:20 113:30 113:40").communities)
+    assert_equal('113:10 113:20 113:30 113:40', Communities.new("113:10, 113:20, 113:30, 113:40").communities)
+    assert_equal('113:20', Communities.new("113:20").communities)
+    com = Communities.new
+    com << '113:10'
+    assert_equal('113:10', com.communities)
+    com << '113:20'
+    assert_equal('113:10 113:20', com.communities)
+    com << '113:30'
+    assert_equal('113:10 113:20 113:30', com.communities)
+    assert_equal('c0080c0071000a007100140071001e', com.to_shex)
+    com1 = Communities.new("145:30", "145:40", "145:50", "145:60")
+    com2 = Communities.new("145:30,145:40,145:50,145:60")
+    assert_equal(com1.to_shex, com2.to_shex)
+    assert_equal(["0x91001e", "0x910028", "0x910032", "0x91003c"], com2.to_ary.collect { |c| "0x#{c.to_s(16)}" })
+    assert_equal('c008100091001e00910028009100320091003c',com1.to_shex)
+    com3 = Communities.new(0x91001E, 0x910028, 0x910032, 0x91003c)
+    assert_equal('c008100091001e00910028009100320091003c',com3.to_shex)
+    assert_equal('145:30 145:40 145:50 145:60', com3.communities)
+    assert_equal("[OTcr]  (8) Communities: [c008100091001e0091002...] '145:30 145:40 145:50 145:60'", com3.to_s)        
+    assert_equal(com3.to_shex, Communities.new(com3.encode).to_shex)
+  end
+  def test_2
+    com1 = Communities.new("145:60", "145:10", "145:30", "145:20")
+    com2 = Communities.new("145:30,145:20,145:10,145:60")
+    assert(com1 ==  com2)
+    com1.sort
+    assert_equal('145:60 145:10 145:30 145:20', com1.communities)
+    com1.sort!
+    assert_equal('145:10 145:20 145:30 145:60', com1.communities)
+    com3 = Communities.new(com1)
+    assert_equal(com1.encode, com3.encode)
+  end
+end
+
+#MiniTest::Unit.autorun