bgp4r 0.0.13 → 0.0.14

data/test/unit/messages/update_test.rb

@@ -46,6 +46,27 @@ class Update_Test < Test::Unit::TestCase
     assert_equal(Update, m.class)
     assert_equal(s, m.to_shex)
     assert_equal(9, m.path_attribute.size)
+  
+    h = {
+      :path_attributes=> {
+        :origin=>:incomplete,
+        :as_path=>{},
+        :multi_exit_disc=>0,
+        :local_pref=>100,
+        :communities=>["10283:20103"],
+        :route_target=>[10283, 30000],
+        :cluster_ids=>["0.0.0.1"],
+        :origin_id=>"81.52.17.128",
+        :mp_reach=> {
+          :safi=>128,
+          :afi=>1,
+          :nlris=>{:label=>1851, :rd=>[3215, 1291308], :prefix=>"172.31.63.251/32"},
+          :nexthop=>["81.52.17.128"]
+        }
+      }
+    }
+  
+    assert_equal(h, m.to_hash)
 
     s = 'ffffffffffffffffffffffffffffffff0050020000002f40010101400304c0a80105800404000000644005040000006440020402010064c0080c051f00010137003b0af50040200a0a0a0a2020202020'
     m = Message.factory([s].pack('H*'))
@@ -57,18 +78,27 @@ class Update_Test < Test::Unit::TestCase
     s = 'ffffffffffffffffffffffffffffffff0050020000002f40010101400304c0a80105800404000000644005040000006440020402010064c0080c051f00010137003b0af50040200a0a0a0a2020202020'
     m = Message.factory([s].pack('H*'))
     w = Update.withdrawn(m)
+    assert_equal({:withdrawns=>["10.10.10.10/32", "32.32.32.32/32"]}, w.to_hash)
     assert_equal(Update,w.class)
     assert_equal('200a0a0a0a2020202020', w.withdrawn.to_shex)
   end
   
-  def __test_experiment
+  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"}
+      5.times { |i| nlri << "10.0.#{i}.0/24"}
     end
-    puts upd
+    h = {
+      :path_attributes=>{
+        :local_pref=>100, 
+        :next_hop=>"10.1.1.1", 
+        :origin=>:igp
+      }, 
+      :nlris=>["10.0.0.0/24", "10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24", "10.0.4.0/24"]
+    }
+    assert_equal(h, upd.to_hash)
   end
   
   def test_verify_as4_byte_encoding
@@ -158,6 +188,7 @@ class Update_Test < Test::Unit::TestCase
     m = Update.new([s].pack('H*'))
     assert m.withdrawn, "Should contain withdrawn routes."
     assert_equal 3,m.withdrawn.nlris.size
+    assert_equal({:withdrawns=>["212.3.116.0/22", "85.198.136.0/23", "212.8.48.0/22"]}, m.to_hash)
   end
  
   def test_factory_to_create_an_update_message_witth_ext_inet_unicast_nlris
@@ -174,6 +205,7 @@ class Update_Test < Test::Unit::TestCase
     # 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))
+    assert_equal({:path_attributes=>{:as_path=>{:sequence=>[100]}}, :nlris=>["ID=100, 77.0.0.0/17"]}, upd1.to_hash)
   end
   
   def test_path_id_and_as4byte
@@ -202,7 +234,25 @@ class Update_Test < Test::Unit::TestCase
     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
-    
+    h = {
+      :path_attributes=>{
+        :as_path=>{:sequence=>[100]},
+        :multi_exit_disc=>20,
+        :mp_reach=>{
+          :nexthop=>["10.0.0.1"],
+          :safi=>128,
+          :afi=>1,
+          :nlris=>[
+            {:label=>101,:rd=>[100, 100],:prefix=>"192.168.0.0/24",:path_id=>100},
+            {:label=>102,:rd=>[100, 100],:prefix=>"192.168.1.0/24",:path_id=>100},
+            {:label=>103,:rd=>[100, 100],:prefix=>"192.168.2.0/24",:path_id=>100}
+          ]
+        },
+        :local_pref=>10,
+        :origin=>:igp
+      }
+    }
+    assert_equal(h, upd3.to_hash)
   end
   
   # updates with path_id
@@ -254,7 +304,22 @@ class Update_Test < Test::Unit::TestCase
     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
-    
+    h = {
+      :path_attributes=>{
+        :as_path=>{}, 
+        :multi_exit_disc=>0, 
+        :mp_reach=>{
+          :nexthop=>["1.1.1.1"], 
+          :safi=>128, 
+          :afi=>1, 
+          :nlris=>{:label=>16000, :rd=>[19, 17], :prefix=>"10.1.1.0/24", :path_id=>1}
+        }, 
+        :local_pref=>1, 
+        :origin=>:egp, 
+        :route_target=>[4, 1]
+      }
+    }
+    assert_equal(h, upd.to_hash)
   end
   
   def test_factory_to_build_a_withdrawn_update_for_inet_mpls_vpn_unicast_with_path_id
@@ -268,6 +333,15 @@ class Update_Test < Test::Unit::TestCase
     mp_unreach = upd.path_attribute[:mp_unreach]
     assert_equal 1, mp_unreach.nlris[0].path_id
     assert_equal 'Label Stack=524288 (bottom) RD=1:1, ID=1, IPv4=10.1.1.0/24', mp_unreach.nlris[0].to_s
+    h = {
+      :path_attributes=>{
+        :mp_unreach=>{
+          :safi=>128, :afi=>1, 
+          :nlris=>{:label=>524288, :rd=>[1, 1], :prefix=>"10.1.1.0/24", :path_id=>1}
+        }
+      }
+    }
+    assert_equal(h, upd.to_hash)
   end
 
 end

data/test/unit/neighbor/neighbor_test.rb

@@ -24,7 +24,6 @@ require "test/unit"
 require 'bgp4r'
 require 'test/helpers/server'
 include BGP
-include BGP
 include BGP::OPT_PARM::CAP
 include BGP::TestHelpers
 

data/test/unit/nlris/label_test.rb

@@ -34,6 +34,8 @@ class Label_Test < Test::Unit::TestCase
     assert_equal('000641', Label.new(100).to_shex)
     assert_equal('000643', Label.new(100,1).to_shex)
     assert_equal({:label=>100, :exp=>1},Label.new(100,1).to_hash)
+    assert_equal({:label=>100, :exp=>1}, Label.new(:label=>100, :exp=>1).to_hash)
+    assert_equal({:label=>100, :exp=>0}, Label.new(:label=>100).to_hash)
   end
 end
 
@@ -46,5 +48,9 @@ class Label_stack_Test < Test::Unit::TestCase
     assert_equal('Label stack:(empty)', Label_stack.new.to_s)
     assert_equal(ls.encode, Label_stack.new(['000640000650000661'].pack('H*')).encode)
     assert_equal("Label Stack=100,101 (bottom)", Label_stack.new(['000640000651000661'].pack('H*')).to_s)
+    assert_equal({:labels=>[100,101]}, Label_stack.new(['000640000651000661'].pack('H*')).to_hash)
+    assert_equal({:labels=>[100,101,102]}, ls.to_hash)
+    ls = Label_stack.new :labels=>[100,101,102]
+    assert_equal('000640000650000661', ls.to_shex)
   end
 end

data/test/unit/nlris/labeled_test.rb

@@ -2,6 +2,8 @@ require "test/unit"
 
 require "bgp/nlris/labeled"
 require 'bgp/nlris/prefix'
+require 'bgp/nlris/vpn'
+require 'bgp/nlris/rd'
 
 class TestBgpNlrisLabeled < Test::Unit::TestCase
   include BGP
@@ -12,6 +14,10 @@ class TestBgpNlrisLabeled < Test::Unit::TestCase
     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)
+    assert_equal({:prefix=>"10.0.0.0/8", :labels=>[100, 101, 102]}, Labeled.new(Prefix.new('10.0.0.1/8'), 100,101,102).to_hash)
+    labeled = Labeled.new(Prefix.new('10.0.0.1/8'), 100,101,102)
+    assert_equal(labeled.to_shex, Labeled.new(labeled.to_hash).to_shex)
+    assert_equal({:prefix=>"10.0.0.0/8", :labels=>[100, 101, 102]}, Labeled.new(Prefix.new('10.0.0.1/8'), 100,101,102).to_hash)
     #FIXME: add labeled  and labeled vpn tests
   end
   def test_new_ntop
@@ -23,6 +29,12 @@ class TestBgpNlrisLabeled < Test::Unit::TestCase
     assert_equal('500006400006500006610a', Labeled.new_ntop(['500006400006500006610a'].pack('H*'), 1, 1).to_shex)
     #FIXME: add labeled  and labeled vpn tests
   end
+  def test_new_afi_1_safi_128_rd_0_0
+    lb = Labeled.new_ntop(['580064b10000006405591311'].pack('H*'), 1, 128)
+    assert_equal('580064b10000006405591311', lb.to_shex)
+    assert_equal('Label Stack=1611 (bottom) RD=100:89723665, IPv4=0.0.0.0/0', lb.to_s)
+    assert_equal({:rd=>[100, 89723665], :label=>1611}, lb.to_hash)
+  end
   def test_new_ntop_path_id
     #FIXME: add labeled  and labeled vpn tests
   end

data/test/unit/nlris/prefix_test.rb

@@ -42,6 +42,8 @@ class Prefix_Test < Test::Unit::TestCase
     assert_equal(1, pfx.afi)
     assert ! pfx.extended?
     assert_equal('IPv4=10.255.128.0/17', pfx.to_s_with_afi)
+    assert_equal({:prefix=>"10.255.128.0/17"}, pfx.to_hash)
+    assert_equal(pfx.to_hash, Prefix.new(pfx.to_hash).to_hash)
   end
   def test_extended
     pfx = Prefix.new(100, '10.0.0.0')
@@ -55,7 +57,8 @@ class Prefix_Test < Test::Unit::TestCase
     assert_equal('ID=100, 2011:13:11::/64', pfx.to_s)
     assert_equal('00000064402011001300110000', pfx.to_shex)
     assert_equal('ID=100, IPv6=2011:13:11::/64', pfx.to_s_with_afi)
-    
+    assert_equal({:path_id=>100, :prefix=>"2011:13:11::/64"}, pfx.to_hash)
+    assert_equal(pfx.to_hash, Prefix.new(pfx.to_hash).to_hash)
   end
   def test_inet6
     pfx =  Prefix.new('2011:13:11::0/64')
@@ -97,6 +100,7 @@ class Prefix_Test < Test::Unit::TestCase
     assert   pfx.iso?
     assert_equal(3, pfx.afi)
     assert_equal('NSAP=49.0001.0002.0003.0000.0000.0000.0000.0000.0000.00/56', pfx.to_s_with_afi)
+    assert_equal(pfx.to_hash, Prefix.new(pfx.to_hash).to_hash)
   end
   def test_new_ntop_inet
     s = '110aff80'

data/test/unit/nlris/rd_test.rb

@@ -34,6 +34,8 @@ class Rd_Test < Test::Unit::TestCase
     assert_equal('0002000000010101', Rd.new(1,'1.1.1.1').to_shex)
     assert_equal('RD=1:1 (0x01 0x0001)',Rd.new(1,1,0).to_s)
     assert_equal('RD=1:1 (0x0001 0x01)',Rd.new(1,1,2).to_s)
+    assert_equal('RD=1:1 (0x01 0x0001)',Rd.new(:rd=>[1,1]).to_s)
+    assert_equal({:rd=>[1,1]},Rd.new(:rd=>[1,1]).to_hash)
   end
   def test_2
     assert_equal('0000000100000001', Rd.new(['0000000100000001'].pack('H*')).to_shex)

data/test/unit/nlris/vpn_test.rb

@@ -0,0 +1,50 @@
+#--
+# Copyright 2011 Jean-Michel Esnault.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+#
+# This file is part of BGP4R.
+# 
+
+require "test/unit"
+require 'bgp/nlris/vpn'
+require 'bgp/nlris/rd'
+require 'bgp/nlris/prefix'
+
+class TestNlrisVpn < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert_equal('RD=1.1.1.1:1, IPv4=10.0.0.0/8', Vpn.new("10.0.0.1/8", Rd.new('1.1.1.1',1)).to_s)
+    assert_equal('RD=1.1.1.1:1, IPv6=2011:1::/48', Vpn.new("2011:1::1/48", Rd.new('1.1.1.1',1)).to_s)
+    assert_equal('4800000001000000010a', Vpn.new("10.1.2.3/8", Rd.new(1,1)).to_shex)
+    assert_equal('RD=1:1, IPv4=10.0.0.0/8', Vpn.new(["4800000001000000010a"].pack('H*')).to_s)
+    assert_equal('4900010101010100010a00', Vpn.new("10.1.2.3/9", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('RD=1.1.1.1:1, IPv4=10.0.0.0/9', Vpn.new(["4900010101010100010a00"].pack('H*')).to_s)
+    assert_equal('4a00010101010100010a00', Vpn.new("10.1.2.3/10", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('5000010101010100010a01', Vpn.new("10.1.2.3/16", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('5100010101010100010a0100', Vpn.new("10.1.2.3/17", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('5800010101010100010a0102', Vpn.new("10.1.2.3/24", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('5900010101010100010a010200', Vpn.new("10.1.2.3/25", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('6000010101010100010a010203', Vpn.new("10.1.2.3/32", Rd.new('1.1.1.1',1)).to_shex)
+    assert_equal('4a00010101010100010a00', Vpn.new(["4a00010101010100010a00"].pack('H*')).to_shex)
+    assert_equal('5000010101010100010a01', Vpn.new(["5000010101010100010a01"].pack('H*')).to_shex)
+    assert_equal('5100010101010100010a0100', Vpn.new(["5100010101010100010a0100"].pack('H*')).to_shex)
+    assert_equal('5800010101010100010a0102', Vpn.new(["5800010101010100010a0102"].pack('H*')).to_shex)
+    assert_equal('5900010101010100010a010200', Vpn.new(["5900010101010100010a010200"].pack('H*')).to_shex)
+    assert_equal('6000010101010100010a010203', Vpn.new(["6000010101010100010a010203"].pack('H*')).to_shex)
+    assert_equal('400000000100000001', Vpn.new(Rd.new(1,1)).to_shex)
+    assert_equal('400000000100000001', Vpn.new(["400000000100000001"].pack('H*')).to_shex)
+    assert_equal('RD=1:1, IPv4=0.0.0.0/0', Vpn.new(Rd.new(1,1)).to_s)
+    vpn = Vpn.new('1.2.3.4/32', Rd.new(1,1))
+    assert_equal('000000010000000101020304', vpn.encode_without_len_without_path_id.unpack('H*')[0])
+  end
+  def test_2
+    vpn = Vpn.new("10.0.0.1/8", Rd.new('1.1.1.1',1))
+    assert_equal("RD=1.1.1.1:1, IPv4=10.0.0.0/8", vpn.to_s)
+    assert_equal({:prefix=>"10.0.0.0/8", :rd=>["1.1.1.1", 1]}, vpn.to_hash)
+    vpn = Vpn.new("10.0.0.1/8", Rd.new(1,1))
+    assert_equal("RD=1:1, IPv4=10.0.0.0/8", vpn.to_s)
+    assert_equal({:prefix=>"10.0.0.0/8", :rd=>[1, 1]}, vpn.to_hash)
+  end
+end

data/test/unit/path_attributes/aggregator_test.rb

@@ -63,4 +63,10 @@ class Aggregator_Test < Test::Unit::TestCase
     assert_raise(ArgumentError) {As4_aggregator.new(ag2)}
     assert_equal(ag4.encode, ag.encode)
   end
+  def test5
+    ag1 = Aggregator.new('10.0.0.1', 100)
+    ag2 = Aggregator.new :asn=> 100, :address=> '10.0.0.1'
+    assert_equal(ag1.encode,ag2.encode)
+    assert_equal({:asn=>100, :address=>"10.0.0.1"}, ag2.to_hash)
+  end
 end

data/test/unit/path_attributes/{aigp.rb → aigp_test.rb}

@@ -1,3 +1,32 @@
+require "test/unit"
+require "bgp/path_attributes/aigp"
+
+class TestAigp < Test::Unit::TestCase
+  include BGP
+  def test_1
+    assert Aigp.new
+    assert_equal('801a0b01000b0000000000000000', Aigp.new.to_shex)
+    assert_equal(0, Aigp.new.to_i)
+    assert_equal(4294967295, Aigp.new(0xffffffff).to_i)
+    assert_equal('801a0b01000b00000000ffffffff', Aigp.new(0xffffffff).to_shex)
+    assert_equal('(0xffffffff) 4294967295', Aigp.new(0xffffffff).metric)
+    assert_equal(72057594037927935, Aigp.new(0xffffffffffffff).to_i)
+    assert_equal('801a0b01000b00ffffffffffffff', Aigp.new(0xffffffffffffff).to_shex)
+    assert_equal('(0xffffffffffffff) 72057594037927935', Aigp.new(0xffffffffffffff).metric)
+    assert_equal('801a0b01000b0001020304050607', Aigp.new(Aigp.new(0x01020304050607).encode).to_shex) 
+    assert ! Aigp.new.is_transitive?
+    assert   Aigp.new.is_optional?    
+  end
+  def test_2
+    assert Aigp.new_hash
+    assert Aigp.new_hash :metric=> 0x1f2f3f4f5f6f7f8f
+    m1 = Aigp.new 0x1f2f3f4f5f6f7f8f
+    m2 = Aigp.new_hash :metric=> 0x1f2f3f4f5f6f7f8f
+    assert_equal(m1.encode, m2.encode)
+    assert_equal({:metric=>2247084349217275791}, m2.to_hash)
+  end
+end
+
 __END__
 
 3. AIGP Attribute

data/test/unit/path_attributes/as_path_test.rb

@@ -63,6 +63,12 @@ class Segment_Test < Test::Unit::TestCase
     assert_equal('0203000000010000000200000003', seg.to_shex(true))
     assert_equal('0203000100020003', seg.to_shex(false))
   end
+  def test_5
+    assert_equal({:set=>[1, 2]},As_path::Set.new(1,2).to_hash)
+    assert_equal({:sequence=>[3,4]},As_path::Sequence.new(3,4).to_hash)
+    assert_equal({:confed_sequence=>[5,6]},As_path::Confed_sequence.new(5,6).to_hash)
+    assert_equal({:confed_set=>[7,8]},As_path::Confed_set.new(7,8).to_hash)
+  end
 end
 
 class As_path_Test < Test::Unit::TestCase
@@ -124,6 +130,53 @@ class As_path_Test < Test::Unit::TestCase
     asp2 = As_path.new(asp)
     assert_equal(asp.encode, asp2.encode)
   end
+  def test_6
+    set1 = As_path.new_set 1,2,3,4
+    set2 = As_path.new As_path.new(As_path::Set.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_sequence 1,2,3,4
+    set2 = As_path.new As_path.new(As_path::Sequence.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_confed_set 1,2,3,4
+    set2 = As_path.new As_path.new(As_path::Confed_set.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_confed_sequence 1,2,3,4
+    set2 = As_path.new As_path.new(As_path::Confed_sequence.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+  end
+  def test_7
+    set1 = As_path.new_hash :set=> [1,2,3,4]
+    set2 = As_path.new As_path.new(As_path::Set.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_hash :sequence=> [1,2,3,4]
+    set2 = As_path.new As_path.new(As_path::Sequence.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_hash :confed_set=> [1,2,3,4]
+    set2 = As_path.new As_path.new(As_path::Confed_set.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+    set1 = As_path.new_hash :confed_sequence=> [1,2,3,4]
+    set2 = As_path.new As_path.new(As_path::Confed_sequence.new(1,2,3,4))
+    assert_equal( set1.encode, set2.encode)
+  end
+  def test_8
+    set = As_path.new_hash :set=> [1,2], :sequence=>[3,4], :confed_sequence=>[5,6], :confed_set=>[7,8]
+    assert_equal('400218010200010002020200030004030200050006040200070008', set.to_shex)
+    assert_equal [1,2], set.to_hash[:as_path][:set]
+    assert_equal [3,4], set.to_hash[:as_path][:sequence]
+    assert_equal [5,6], set.to_hash[:as_path][:confed_sequence]
+    assert_equal [7,8], set.to_hash[:as_path][:confed_set]
+    set1 = As4_path.new
+    set1 << As_path::Set.new(1,2)
+    set1 << As_path::Sequence.new(3,4)
+    set1 << As_path::Confed_sequence.new(5,6)
+    set1 << As_path::Confed_set.new(7,8)
+    set2 = As4_path.new_hash :set=> [1,2], :sequence=>[3,4], :confed_sequence=>[5,6], :confed_set=>[7,8]
+    assert_equal(set1.to_shex, set2.to_shex)    
+    assert_equal [1,2], set2.to_hash[:as_path][:set]
+    assert_equal [3,4], set2.to_hash[:as_path][:sequence]
+    assert_equal [5,6], set2.to_hash[:as_path][:confed_sequence]
+    assert_equal [7,8], set2.to_hash[:as_path][:confed_set]
+  end
 end
 
 class As4_path_Test < Test::Unit::TestCase

data/test/unit/path_attributes/atomic_aggregate_test.rb

@@ -31,5 +31,8 @@ class Atomic_aggregate_Test < Test::Unit::TestCase
     obj =  Atomic_aggregate.new
     assert_equal("800600", Atomic_aggregate.new(obj.encode).to_shex)
   end
+  def test_2
+    assert_equal({},Atomic_aggregate.new.to_hash)
+  end
 end
 

data/test/unit/path_attributes/cluster_list_test.rb

@@ -25,15 +25,20 @@ 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)
+    clist1 = Cluster_list.new('192.168.0.1','10.0.0.1')
+    clist2 = Cluster_list.new('192.168.0.1 10.0.0.1')
+    assert_equal('800a08c0a800010a000001', clist1.to_shex)
+    assert_equal(clist1.to_shex, clist2.to_shex)
+    assert_equal('192.168.0.1 10.0.0.1',clist1.cluster_list)
+    assert_equal("[Oncr] (10) Cluster List: [800a08c0a800010a00000...] '192.168.0.1 10.0.0.1'", clist1.to_s)
+    clist3 = Cluster_list.new(['800a08c0a800010a000001'].pack('H*'))
+    assert_equal(clist1.encode, clist3.encode)
+    clist4 = Cluster_list.new(clist3)
+    assert_equal(clist3.encode, clist4.encode)
+  end
+  def test_2
+    cids = ['1.1.1.1', '2.2.2.2', '3.3.3.3']
+    clist1 = Cluster_list.new_hash :cluster_ids=> cids
+    assert_equal( cids, clist1.to_hash[:cluster_ids])
   end
 end

data/test/unit/path_attributes/communities_test.rb

@@ -26,10 +26,10 @@ 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(0xFFFFFF01,Communities::Community.no_export.to_i)
+    assert_equal(0xFFFFFF02,Communities::Community.no_advertise.to_i)
+    assert_equal(0xFFFFFF03,Communities::Community.no_export_sub_confed.to_i)
+    assert_equal(0xFFFFFF04,Communities::Community.no_peer.to_i)
     assert_equal(0xdeadbeef,Communities::Community.new(0xdeadbeef).to_i)
     assert_equal '5:1234', Communities::Community.new(Communities::Community.new('5:1234')).to_s
   end
@@ -58,6 +58,11 @@ class Communities_Test < Test::Unit::TestCase
     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)
+    assert_equal({:communities=>["145:30", "145:40", "145:50", "145:60"]}, com1.to_hash)
+    com4 = Communities.new_hash :communities=> ["145:30", "145:40", "145:50", "145:60", :no_export, :no_advertise]
+    assert_equal('c008180091001e00910028009100320091003cffffff01ffffff02', com4.to_shex)
+    com5 = Communities.new_hash(com4.to_hash)
+    assert_equal(com4.to_shex, com5.to_shex)
   end
   def test_2
     com1 = Communities.new("145:60", "145:10", "145:30", "145:20")

data/test/unit/path_attributes/extended_communities_test.rb

@@ -47,14 +47,38 @@ class Extended_communitiesTest < Test::Unit::TestCase
     exc = Extended_communities.new(['c010080002282b00007530'].pack('H*'))
     assert_equal(Route_target, exc.communities[0].class)
   end
+  def test_4
+    ec = Extended_communities.new_hash  :color=> 100
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :link_bandwidth=> 999_999_999
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :route_target=> ['10.0.1.2', 10]
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :ospf_domain_id=> '9.1.0.1'
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :encapsulation=> :l2tpv3
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :route_origin=> ['10.0.1.2', 10]
+    ec2 = Extended_communities.new_hash(ec.to_hash)
+    assert_equal(ec.to_hash, Extended_communities.new_hash(ec.to_hash).to_hash)
+    ec = Extended_communities.new_hash  :color => 100, :link_bandwidth => 999_999_999, :route_origin => ['10.0.1.2', 10], :encapsulation => :ipip
+    assert_equal(100, ec.to_hash[:color]) 
+  end
   def test_sort
     ec = Extended_communities.new
+    ec.add(Color.new(100))
     ec.add(Link_bandwidth.new(999_999_999))
     ec.add(Route_target.new('10.0.1.2',10))
     ec.add(Ospf_domain_id.new('9.1.0.1'))
     ec.add(Route_target.new('11.0.1.1',10))
     ec.add(Route_target.new('8.0.1.1',10))
     ec.add(Route_target.new('7.0.1.1',8))
+    ec.add(Encapsulation.new(:l2tpv3))
     ec.add(Ospf_domain_id.new('20.0.0.1'))
     ec.add(Route_origin.new('10.0.3.2',9))
     ec.add(Route_target.new('10.0.3.2',7))
@@ -68,13 +92,16 @@ class Extended_communitiesTest < Test::Unit::TestCase
     assert_equal("Ospf domain id: 9.1.0.1:0",ec.sort.communities[6].to_s)
     assert_equal("Ospf domain id: 20.0.0.1:0",ec.sort.communities[7].to_s)
     assert_equal("Ospf router id: 10.0.0.1:0",ec.sort.communities[8].to_s)
-    assert_equal("Link bandwidth: 1000000000.0",ec.sort.communities[9].to_s)
+    assert_equal("Color: 100",ec.sort.communities[9].to_s)
+    assert_equal("Encapsulation: 1",ec.sort.communities[10].to_s)
+    assert_equal("Link bandwidth: 1000000000.0",ec.sort.communities[11].to_s)
   end
   def test_sort!
     ec = Extended_communities.new
     ec.add(Link_bandwidth.new(999_999_999))
     ec.add(Route_target.new('10.0.1.2',10))
     ec.add(Ospf_domain_id.new('9.1.0.1'))
+    ec.add(Color.new(100))
     ec.add(Route_target.new('11.0.1.1',10))
     ec.add(Route_target.new('8.0.1.1',10))
     ec.add(Route_target.new('7.0.1.1',8))
@@ -92,11 +119,11 @@ class Extended_communitiesTest < Test::Unit::TestCase
     assert_equal("Ospf domain id: 9.1.0.1:0",ec.communities[6].to_s)
     assert_equal("Ospf domain id: 20.0.0.1:0",ec.communities[7].to_s)
     assert_equal("Ospf router id: 10.0.0.1:0",ec.communities[8].to_s)
-    assert_equal("Link bandwidth: 1000000000.0",ec.communities[9].to_s)
+    assert_equal("Link bandwidth: 1000000000.0",ec.communities[10].to_s)
+    assert_equal("Color: 100",ec.communities[9].to_s)
     ec1 = Extended_communities.new(ec)
     assert_equal(ec.encode, ec1.encode)
   end
-  
   def test_compare_eql?
     ec = Extended_communities.new
     ec.add(Route_target.new('10.0.1.2',100))
@@ -110,6 +137,7 @@ class Extended_communitiesTest < Test::Unit::TestCase
     assert_equal(0, ec <=> ec2)
     assert(! ec.eql?(ec2))
   end
+    
 end
 
 #MiniTest::Unit.autorun

data/test/unit/path_attributes/extended_community_test.rb

@@ -35,20 +35,20 @@ class Extended_community_Test < Test::Unit::TestCase
   def test_to_i
     assert_equal("000200ff00deadbe",Route_target.new(0xff,0xdeadbe).to_shex)
     assert_equal(0x200ff00deadbe,Route_target.new(0xff,0xdeadbe).to_i)
-    assert_equal('030a0a0000010064', Opaque.new(10,"0a0000010064").to_shex)
-    assert_equal(0x030a0a0000010064, Opaque.new(10,"0a0000010064").to_i)
+    assert_equal('030a0a0000010064', Opaque.new(0,10,"0a0000010064").to_shex)
+    assert_equal(0x030a0a0000010064, Opaque.new(0,10,"0a0000010064").to_i)
   end
 
   def test_compare
     rt = Route_target.new(0xff,0xdeadbe)
-    op = Opaque.new(10,"0a0000010064")
+    op = Opaque.new(ATTR::XTENDED_COMMUNITY::NON_TRANSITIVE, 10,"0a0000010064")
     assert( rt < op )
   end
 
   def test_opaque
-    ec = Opaque.new(10,"0a0000010064")
+    ec = Opaque.new(ATTR::XTENDED_COMMUNITY::NON_TRANSITIVE, 10,"0a0000010064")
     ec.instance_of?(Extended_community)
-    assert_equal('030a0a0000010064', ec.to_shex)
+    assert_equal('430a0a0000010064', ec.to_shex)
     assert_equal('Opaque: 0a0000010064', ec.to_s)
   end
 
@@ -68,6 +68,7 @@ class Extended_community_Test < Test::Unit::TestCase
     assert_equal("Route origin: 2.2.2.2:333",Route_origin.new('2.2.2.2', 333).to_s)
     assert_equal("Route origin: 10:20",Route_origin.new(10, 20).to_s)
     assert_equal("000300ff00deadbe",Route_origin.new(0xff,0xdeadbe).to_shex)
+    
   end
 
   def test_ospf_domain_id
@@ -78,8 +79,8 @@ class Extended_community_Test < Test::Unit::TestCase
   end
 
   def test_ospf_router_id
-    did = Ospf_router_id.new('1.1.1.1')
-    assert_equal('Ospf router id: 1.1.1.1:0', did.to_s)
+    rid = Ospf_router_id.new('1.1.1.1')
+    assert_equal('Ospf router id: 1.1.1.1:0', rid.to_s)
     assert_equal("0107010203040000",Ospf_router_id.new('1.2.3.4').to_shex)
     assert_equal("Ospf router id: 1.2.3.4:0", Ospf_router_id.new(['0105010203040000'].pack('H*')).to_s)
   end
@@ -91,12 +92,54 @@ class Extended_community_Test < Test::Unit::TestCase
   end
   
   def test_link_bandwidth
-    assert_equal('04040000461c4000', Link_bandwidth.new(10_000).to_shex)
+    assert_equal('40040000461c4000', Link_bandwidth.new(10_000).to_shex)
     assert_equal('Link bandwidth: 10000.0', Link_bandwidth.new(10_000).to_s)
     assert_equal('Link bandwidth: 10000.0', Link_bandwidth.new(['04040000461c4000'].pack('H*')).to_s)
-    assert_equal('040400004cbebc20', Link_bandwidth.new(99_999_999).to_shex)
+    assert_equal('400400004cbebc20', Link_bandwidth.new(99_999_999).to_shex)
     assert_equal('Link bandwidth: 100000000.0', Link_bandwidth.new(99_999_999).to_s)
     assert_equal('Link bandwidth: 100000000.0', Link_bandwidth.new(['040400004cbebc20'].pack('H*')).to_s)
   end
 
+  def test_color
+    assert_equal('030b000000000000', Color.new.to_shex)
+    assert_equal('030b000000000000', Color.new(0).to_shex)
+    assert_equal('030b000000000064', Color.new(100).to_shex)
+    assert_equal('Color: 100', Color.new(100).to_s)
+    assert_equal('Color: 10000', Color.new(Color.new(10_000).encode).to_s)
+  end
+  
+  def test_encapsulation
+    assert_equal('030c000000000000', Encapsulation.new.to_shex)
+    assert_equal('030c000000000001', Encapsulation.new(1).to_shex)
+    assert_equal('030c000000000002', Encapsulation.new(2).to_shex)
+    assert_equal('030c000000000007', Encapsulation.new(7).to_shex)
+    assert_equal('030c000000000001', Encapsulation.new(:l2tpv3).to_shex)
+    assert_equal('030c000000000002', Encapsulation.new(:gre).to_shex)
+    assert_equal('030c000000000007', Encapsulation.new(:ipip).to_shex)
+    assert_equal('Encapsulation: 1', Encapsulation.new(:l2tpv3).to_s)
+    assert_equal('Encapsulation: 7', Encapsulation.new(:ipip).to_s)
+    assert_equal('Encapsulation: 2', Encapsulation.new(:gre).to_s)
+    assert_equal('Encapsulation: 7', Encapsulation.new(Encapsulation.new(7).encode).to_s)    
+  end
+
+  def test_factory
+    s = '0102070001010008 010208000101000a 01020a000102000a 01020a0003020007 01020b000101000a 
+         01030a0003020009 0105090100010000 0105140000010000 01070a0000010000 400400004e6e6b28 
+         430b000000000064 030c000000000007'.split.join
+    comms = []
+    communities = s.scan(/[0-9a-f]{16}/) { |comm| comms << Extended_community.factory([comm].pack('H*'))  }
+    assert_equal BGP::Route_target, comms[0].class
+    assert_equal BGP::Route_target, comms[1].class
+    assert_equal BGP::Route_target, comms[2].class
+    assert_equal BGP::Route_target, comms[3].class
+    assert_equal BGP::Route_target, comms[4].class
+    assert_equal BGP::Route_origin, comms[5].class
+    assert_equal BGP::Ospf_domain_id, comms[6].class
+    assert_equal BGP::Ospf_domain_id, comms[7].class
+    assert_equal BGP::Ospf_router_id, comms[8].class
+    assert_equal BGP::Link_bandwidth, comms[9].class
+    assert_equal BGP::Color, comms[10].class
+    assert_equal BGP::Encapsulation, comms[11].class
+  end
+
 end

data/test/unit/path_attributes/local_pref_test.rb

@@ -40,4 +40,9 @@ class Local_pref_Test < Test::Unit::TestCase
     lp1 = Local_pref.new(lp)
     assert_equal(lp.encode, lp1.encode)
   end
+  def test_3
+    lp = Local_pref.new_hash :local_pref=>100
+    assert_equal({:local_pref=>100}, lp.to_hash)
+    assert_equal(lp.to_hash, Local_pref.new_hash(lp.to_hash).to_hash)
+  end
 end