ospfv2 0.0.2 → 0.0.3

data/test/unit/lsa/tlv/link_type_test.rb

@@ -0,0 +1,16 @@
+require "test/unit"
+
+require "lsa/tlv/link_type"
+
+class TestLsaTlvLinkType < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert_equal("0001000101000000", LinkType_Tlv.new().to_shex)
+    assert_equal("Link Type : p2p", LinkType_Tlv.new({:link_type=>1}).to_s)
+    assert_equal("Link Type : multiaccess", LinkType_Tlv.new({:link_type=>2}).to_s)
+    assert_equal(1, LinkType_Tlv.new({:link_type=>1}).to_hash[:link_type])
+    assert_equal("0001000101000000", LinkType_Tlv.new({:link_type=>1}).to_shex)
+    assert_equal("0001000101000000", LinkType_Tlv.new(LinkType_Tlv.new({:link_type=>1}).encode).to_shex)
+    assert_equal(true, LinkType_Tlv.new({:link_type=>1}).kind_of?(SubTlv))
+  end
+end

data/test/unit/lsa/tlv/local_interface_test.rb

@@ -0,0 +1,15 @@
+require "test/unit"
+
+require "lsa/tlv/local_interface"
+
+class TestTlvLsaLocalInterface < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert_equal("0003000400000000", LocalInterfaceIpAddress_Tlv.new().to_shex)
+    assert_equal("Interface Address : 1.1.1.1", LocalInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_s)
+    assert_equal("1.1.1.1", LocalInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_hash[:ip_address])
+    assert_equal("0003000401010101", LocalInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_shex)
+    assert_equal("0003000401010101", LocalInterfaceIpAddress_Tlv.new(LocalInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).encode).to_shex)
+  end
+end
+

data/test/unit/lsa/tlv/maximum_bandwidth_test.rb

@@ -0,0 +1,14 @@
+require "test/unit"
+
+require "lsa/tlv/maximum_bandwidth"
+
+class TestLsaTlvMaximumBandwidth < Test::Unit::TestCase
+  include OSPFv2
+  def test_case_name
+    assert_equal("0006000400000000", MaximumBandwidth_Tlv.new().to_shex)
+    assert_equal("Maximum bandwidth : 10000", MaximumBandwidth_Tlv.new( :max_bw=>10_000.0 ).to_s)
+    assert_equal("00060004449c4000", MaximumBandwidth_Tlv.new( :max_bw=>10_000.0 ).to_shex)
+    assert_equal(10000, MaximumBandwidth_Tlv.new( :max_bw=>10_000.0 ).to_hash[:max_bw])
+    assert_equal("00060004449c4000", MaximumBandwidth_Tlv.new(['00060004449c4000'].pack('H*')).to_shex)
+  end
+end

data/test/unit/lsa/tlv/maximum_reservable_bandwidth_test.rb

@@ -0,0 +1,13 @@
+require "test/unit"
+
+require "lsa/tlv/maximum_reservable_bandwidth"
+
+class TestLsaTlvMaximumReservableBandwitdh < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert_equal("0007000400000000", MaximumReservableBandwidth_Tlv.new().to_shex)
+    assert_equal("Maximum reservable bandwidth : 10000", MaximumReservableBandwidth_Tlv.new({:max_resv_bw=>10_000}).to_s)
+    assert_equal(255, MaximumReservableBandwidth_Tlv.new({:max_resv_bw=>255}).to_hash[:max_resv_bw])
+    assert_equal("0007000445ffff00", MaximumReservableBandwidth_Tlv.new({:max_resv_bw=>0xffff}).to_shex)
+  end
+end

data/test/unit/lsa/tlv/remote_interface_test.rb

@@ -0,0 +1,14 @@
+require "test/unit"
+
+require "lsa/tlv/remote_interface"
+
+class TestLsaTlvRemoteInterface < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert_equal("0004000400000000", RemoteInterfaceIpAddress_Tlv.new().to_shex)
+    assert_equal("Neighbor Address : 1.1.1.1", RemoteInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_s)
+    assert_equal("1.1.1.1", RemoteInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_hash[:ip_address])
+    assert_equal("0004000401010101", RemoteInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).to_shex)
+    assert_equal("0004000401010101", RemoteInterfaceIpAddress_Tlv.new(RemoteInterfaceIpAddress_Tlv.new({:ip_address=>"1.1.1.1"}).encode).to_shex)
+  end
+end

data/test/unit/lsa/tlv/router_address_test.rb

@@ -0,0 +1,16 @@
+require "test/unit"
+
+require "lsa/tlv/router_address"
+
+class TestLsaTlvRouterAddress < Test::Unit::TestCase
+  include OSPFv2
+  def test_new
+    assert_equal("0001000400000000", RouterAddress_Tlv.new().to_shex)
+    assert_equal("RouterID TLV: 1.1.1.1", RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").to_s)
+    assert_equal("1.1.1.1", RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").to_hash[:ip_address])
+    assert_equal("0001000401010101", RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").to_shex)
+    assert_equal("0001000401010101", RouterAddress_Tlv.new(RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").encode).to_shex)
+    assert_equal(true, RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").is_a?(Tlv))
+    assert_equal(1, RouterAddress_Tlv.new(:ip_address=>"1.1.1.1").tlv_type)
+  end
+end

data/test/unit/lsa/tlv/tlv_factory_test.rb

@@ -0,0 +1,89 @@
+require "test/unit"
+
+require "lsa/tlv/tlv_factory"
+
+class TestLsaTlvTlvFactory < Test::Unit::TestCase
+  include OSPFv2
+  def test_router_address
+    h = {:tlv_type=>1, :ip_address=>"1.1.1.1"}
+    tlv = Tlv.factory(h)
+    assert_equal(h, tlv.to_hash)
+    assert_equal(h, Tlv.factory(tlv.to_hash).to_hash)
+  end
+  def test_link
+    h = {
+      :tlv_type=>2,
+      :tlvs=> [
+        {:tlv_type=>1, :link_type=>1},
+        {:tlv_type=>2, :link_id=>"1.2.3.4"},
+        {:tlv_type=>3, :ip_address=>"1.1.1.1"},
+        {:tlv_type=>4, :ip_address=>"2.2.2.2"},
+        {:tlv_type=>5, :te_metric=>255},
+        {:max_bw=>10000, :tlv_type=>6},
+        {:tlv_type=>7, :max_resv_bw=>0.0},
+        {:tlv_type=>8, :unreserved_bw=>[100, 100, 100, 100, 100, 100, 100, 100]}
+      ]}
+    tlv = Tlv.factory(h)
+    assert_equal(h, tlv.to_hash)
+    assert_equal(h, Tlv.factory(tlv.to_hash).to_hash)
+  end
+
+end
+
+class TestSubTlvFactory < Test::Unit::TestCase
+  include OSPFv2
+  def test_link_type_sub_tlv
+    s = ['0001000101000000'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(LinkType_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+    tlv = SubTlv.factory(:tlv_type=>1, :link_type=>1)
+    assert_equal(LinkType_Tlv, tlv.class)
+    assert_equal({:link_type=>1, :tlv_type=>1}, tlv.to_hash)
+    assert_equal('0001000101000000', tlv.to_shex)
+  end
+  def test_link_id_sub_tlv
+    s = ['0002000401020304'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(LinkId_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end
+  def test_local_interface_sub_tlv
+    s = ['0003000401020304'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(LocalInterfaceIpAddress_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end      
+  def test_remote_interface_sub_tlv
+    s = ['0004000401020304'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(RemoteInterfaceIpAddress_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end   
+  def test_te_metric_sub_tlv
+    s = ['0005000400000064'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(TrafficEngineeringMetric_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end
+  def test_max_bw_sub_tlv
+    s = ['000600043f800000'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(MaximumBandwidth_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end
+  def test_max_reserv_bw_sub_tlv
+    s = ['000700043f800000'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(MaximumReservableBandwidth_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end
+  def test_unreserv_bw_sub_tlv
+    s = ['000800203e0000003e8000003ec000003f0000003f2000003f4000003f6000003f800000'].pack('H*')
+    tlv = SubTlv.factory(s)
+    assert_equal(UnreservedBandwidth_Tlv, tlv.class)
+    assert_equal(s, tlv.encode)
+  end
+
+end
+

data/test/unit/lsa/tlv/traffic_engineering_metric_test.rb

@@ -0,0 +1,15 @@
+require "test/unit"
+
+require "lsa/tlv/traffic_engineering_metric"
+
+class TestLsaTlvTrafficEngineeringMetric < Test::Unit::TestCase
+  include OSPFv2
+  def test_test
+    assert_equal("0005000400000000", TrafficEngineeringMetric_Tlv.new().to_shex)
+    assert_equal("Admin Metric : 254", TrafficEngineeringMetric_Tlv.new({:te_metric=>254}).to_s)
+    assert_equal(255, TrafficEngineeringMetric_Tlv.new({:te_metric=>255}).to_hash[:te_metric])
+    assert_equal("000500040000ffff", TrafficEngineeringMetric_Tlv.new(TrafficEngineeringMetric_Tlv.new({:te_metric=>0xffff}).encode).to_shex)
+    
+  end
+end
+

data/test/unit/lsa/traffic_engineering_test.rb

@@ -0,0 +1,65 @@
+require "test/unit"
+
+require "lsa/traffic_engineering"
+require 'lsa/tlv/tlv_factory'
+
+class TestLsaTlvTrafficEngineering < Test::Unit::TestCase
+  include OSPFv2
+  def test_new_from_hash
+      h_lsa = {:ls_age=>0,
+       :ls_type=>:area,
+       :advertising_router=>"0.0.0.0",
+       :sequence_number=>2147483649,
+       :opaque_id=>0,
+       :opaque_type=>:te_lsa,
+       :top_lvl_tlv=>
+        {:tlv_type=>2,
+         :tlvs=>
+          [{:tlv_type=>1, :link_type=>1},
+           {:tlv_type=>2, :link_id=>"1.2.3.4"},
+           {:ip_address=>"1.1.1.1", :tlv_type=>3},
+           {:ip_address=>"2.2.2.2", :tlv_type=>4},
+           {:tlv_type=>5, :te_metric=>255},
+           {:max_bw=>10000, :tlv_type=>6},
+           {:tlv_type=>7, :max_resv_bw=>7000},
+           {:tlv_type=>8,
+            :unreserved_bw=>[100, 100, 100, 100, 100, 100, 100, 100]}]},
+       :options=>0}
+      lsa = TrafficEngineering.new_hash(h_lsa)
+      assert_equal OSPFv2::TrafficEngineering, lsa.class
+      assert_equal h_lsa, lsa.to_hash
+  end
+  
+  def test_new_link_tlv
+    link_tlv = Link_Tlv.new
+
+    lsa =  TrafficEngineering.new :advertising_router=>1, :opaque_id=>0xff, :top_lvl_tlv=> link_tlv
+    assert_equal('0000000a010000ff00000001800000011444001800020000', lsa.to_shex)
+
+    link_tlv << LinkType_Tlv.new
+    assert_equal('0000000a010000ff000000018000000171d30020000200080001000101000000', lsa.to_shex)
+    link_tlv << LinkId_Tlv.new(:link_id=>'1.2.3.4')
+    assert_equal('0000000a010000ff0000000180000001ec3800280002001000010001010000000002000401020304', lsa.to_shex)
+    link_tlv << LocalInterfaceIpAddress_Tlv.new(:ip_address=>"1.1.1.1")
+    assert_equal('0000000a010000ff000000018000000150b9003000020018000100010100000000020004010203040003000401010101', lsa.to_shex)
+    link_tlv << RemoteInterfaceIpAddress_Tlv.new(:ip_address=>"2.2.2.2")
+    link_tlv << TrafficEngineeringMetric_Tlv.new(:te_metric=>255)
+    link_tlv << MaximumBandwidth_Tlv.new(:max_bw=>10_000)
+    link_tlv << MaximumReservableBandwidth_Tlv.new(:max_resv_bw=>7_000)
+    link_tlv << UnreservedBandwidth_Tlv.new(:unreserved_bw=>[100]*8)
+    
+  end
+  
+  def test_new_router_address_tlv
+    router_address = RouterAddress_Tlv.new(:ip_address=>'1.2.3.4')
+    lsa =  TrafficEngineering.new :advertising_router=>1, :opaque_id=>0xff, :top_lvl_tlv=> router_address
+    assert_equal('0000000a010000ff00000001800000018abc001c0001000401020304', lsa.to_shex)
+
+    lsa =  TrafficEngineering.new :advertising_router=>'255.255.255.255', 
+                                  :opaque_id=>0xdeadff, 
+                                  :top_lvl_tlv=> { :tlv_type=> 1, :ip_address=> '10.11.12.13'}
+    assert_equal('0000000a01deadffffffffff80000001dabc001c000100040a0b0c0d', lsa.to_shex)
+    
+  end
+  
+end

data/test/unit/neighbor/neighbor_test.rb

@@ -0,0 +1,82 @@
+require "test/unit"
+require 'lsa/router'
+
+require "neighbor/neighbor"
+
+class TestNeighborNeighbor < Test::Unit::TestCase
+  include OSPFv2
+  def test_states
+    assert Neighbor.new
+    assert_equal :down, Neighbor.new.state
+    assert Neighbor.new.in_state?(:down)
+    assert  ! Neighbor.new.in_state?(:full)
+    assert Neighbor.new.in_state?(:full, :down)
+  end
+  
+  def test_flood
+    
+    neighbor = Neighbor.new
+    def neighbor.send(packet,dest)
+      ret=[]
+      [packet].flatten.each { |p| 
+        ret << [p.class,dest]
+      }
+      ret
+    end
+    assert_equal [[String, "dest"]], neighbor.send( 'a packet', 'dest')
+    assert_equal [[String, 'dest'], [String, 'dest']], neighbor.send( ['one','two'], 'dest')
+    
+    lsas = []
+    lsas << Router.new
+    lsas << Router.new
+    
+    assert_equal 1, neighbor.flood(:lsas =>lsas).size
+    assert_equal [OSPFv2::LinkStateUpdate, "224.0.0.5"], neighbor.flood(:lsas =>lsas)[0]
+  end
+  
+end
+
+__END__
+
+
+TODO:
+
+require 'test/unit'
+require 'ospfv2/neighbor'
+
+class TestOspfv2Neighbor < Test::Unit::TestCase # :nodoc:
+  def test_init
+    neighbor = OSPFv2::Neighbor.new("1.1.1.1", "0.0.0.0", "10.0.0.1", {:netmask => '255.255.255.0', :options => 0x2})
+    assert_equal(10,neighbor.helloInt)
+    assert_equal(40,neighbor.deadInt)
+    assert_equal("1.1.1.1",neighbor.router_id)
+  end
+  def test_hello_int
+    neighbor = OSPFv2::Neighbor.new("1.1.1.1", "0.0.0.0", "10.0.0.1", {:netmask => '255.255.255.0', :options => 0x2})
+    neighbor.set({:helloInt => 5,})
+    assert_equal(5*4,neighbor.deadInt)
+    neighbor.set({:deadInt => 45,})
+    assert_equal(45,neighbor.deadInt)
+    neighbor.set({:deadInt => 0,})
+    assert_equal(20,neighbor.deadInt)
+  end
+  
+  def test_states
+    n = OSPFv2::Neighbor.new("1.1.1.1", "0.0.0.0", "10.0.0.1", {:netmask => '255.255.255.0', :options => 0x2})
+    assert_equal(:Down,n.state?)
+    assert_raise(NoMethodError) {n.newState}
+    def n.set_state(state, comment="who cares")
+      newState(state,comment)
+      state?
+    end
+    def n.INFO(s); end
+    assert_equal(:Down,n.state?)
+    assert_equal(:Full,n.set_state(:Full))
+    assert_equal(true,n.state?(:Full))
+    assert_equal(true,n.state?(:Init, :Full, :Exchange))
+    assert_equal(:Loading,n.set_state(:Loading))
+    assert_equal(false,n.state?(:Init, :Full, :Exchange))
+    assert_equal(true,n.state?(:Init, :Loading, :Exchange))
+  end  
+end
+

data/test/unit/packet/all

@@ -0,0 +1,10 @@
+require 'fileutils'
+dir = File.dirname(File.expand_path(__FILE__ ))
+
+FileUtils.chdir(dir) do
+  Dir.glob("**/*rb") do |filename| 
+    next if __FILE__ == filename
+    require File.join(dir,filename) unless filename == File.basename(__FILE__)
+  end
+end
+

data/test/unit/packet/database_description_test.rb

@@ -0,0 +1,114 @@
+require "test/unit"
+require 'pp'
+require "packet/database_description"
+
+class TestPacketDatabaseDescription < Test::Unit::TestCase
+  include OSPFv2
+  include OSPFv2::LSDB
+  def test_new
+    s = "020200340404040400000002ea7e0000000000000000000005d8000700000080" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000" +
+    "000a00010000001401020304000000c800000000"  
+    dd = DatabaseDescription.new([s].pack('H*'))
+    assert_equal dd.to_shex, DatabaseDescription.new(dd).to_shex
+    assert DatabaseDescription.new    # dd = DatabaseDescription.new
+    dd1 = DatabaseDescription.new
+    dd1.imms=7
+    dd1.dd_sequence_number= 0xc0aa4f18
+    dd1.options=Options.new 0x42
+    
+    #puts dd.to_s
+
+    s1 = '02020020c0a801c80000000008740000000000000000000005dc0007c0a56c70'
+    s2 = '02020020c0a801c80000000025c70000000000000000000005dc0007c0aa4f18'
+    
+    dd2 = DatabaseDescription.new([s1].pack('H*'))
+    assert_equal s1, dd2.to_shex
+    dd2 = DatabaseDescription.new([s2].pack('H*'))
+    assert_equal s2, dd2.to_shex
+    assert_equal 3232386840, dd2.dd_sequence_number
+    assert_equal 3232386840, dd2.seqn
+    assert_equal 1500, dd2.interface_mtu.to_i
+    assert dd2.master?
+    assert dd2.init?
+    assert dd2.more?
+    
+    h = {:imms=>7,
+     :au_type=>:null,
+     :lsas=>[],
+     :dd_sequence_number=>3232386840,
+     :packet_type=>:dd,
+     :area_id=>"0.0.0.0",
+     :interface_mtu=>1500,
+     :router_id=>"192.168.1.200",
+     :options=> 0,
+     :ospf_version=>2}
+    assert_equal(h, dd2.to_hash)
+  end
+  def _test_recv
+    s = "\002\002\0004\300\250\001\310\000\000\000\000\221\372\000\000\000\000\000\000\000\000\000\000\005\334B\001\300\241\326\356\000\000\"\001\300\250\001\310\300\250\001\310\200\000\000\320\242\r\0000"
+    dd = DatabaseDescription.new s
+    assert_equal 'database_description', dd.packet_name
+  end
+  def test_ls_db
+      ls_db = LinkStateDatabase.new(:area_id=> 0)
+      ls_db.add_loopback :router_id=>'2.2.2.2', :address=>'192.168.1.1', :metric=>10
+      ls_db.add_loopback :router_id=>'3.3.3.3', :address=>'192.168.1.2', :metric=>20
+      ls_db.add_adjacency(1, 2, '192.168.0.1/24', 2)
+      
+      assert_equal 3, ls_db.size
+      
+      dd = OspfPacket.factory( :packet_type=>:dd, :area_id=>"0.0.0.0", :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :lsas=>[], :options=>0, :ls_db => ls_db, :number_of_lsa=>1)
+      assert_equal 1, dd.instance_eval { @lsas.size }
+      assert_equal 1, ls_db.offset
+      assert_equal '00002201020202020202020280000001a8030024', dd.to_shex[-40.. -1]
+      assert dd.more?
+
+      dd = OspfPacket.factory( :packet_type=>:dd, :area_id=>"0.0.0.0", :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :lsas=>[], :options=>0, :ls_db => ls_db, :number_of_lsa=>1)
+      assert_equal 1, dd.instance_eval { @lsas.size }
+      assert_equal 2, ls_db.offset
+      assert_equal '000022010303030303030303800000011b7d0024', dd.to_shex[-40.. -1]
+      assert dd.more?
+      
+      dd = OspfPacket.factory( :packet_type=>:dd, :area_id=>"0.0.0.0", :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :lsas=>[], :options=>0, :ls_db => ls_db, :number_of_lsa=>1)
+      assert_equal 1, dd.instance_eval { @lsas.size }
+      assert_equal 3, ls_db.offset
+      assert_equal '0000220100000001000000018000000158f00030', dd.to_shex[-40.. -1]
+      assert ! dd.more?
+      
+      dd = OspfPacket.factory( :packet_type=>:dd, :area_id=>"0.0.0.0", :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :lsas=>[], :options=>0, :ls_db => ls_db, :number_of_lsa=>1)
+      assert_equal 0, dd.instance_eval { @lsas.size }
+      assert_equal 4, ls_db.offset
+      assert ! dd.more?
+      assert_equal 24+8, dd.encode.size # no lsa headers
+      
+      ls_db.offset=0
+      dd = OspfPacket.factory( :packet_type=>:dd, :area_id=>"0.0.0.0", :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :lsas=>[], :options=>0, :ls_db => ls_db)
+      assert_equal 3, dd.instance_eval { @lsas.size }
+      assert (ls_db.offset > 50)
+      assert ! dd.more?
+      assert_equal 24+8+3*20, dd.encode.size # 3 lsa headers
+      
+      shex = %{0202005cc0a801c8000000000e8b0000000000000000000005dc0000c0aa4f1800002201020202020202020280000001a8030024000022010303030303030303800000011b7d00240000220100000001000000018000000158f00030
+      }.split.join
+      assert_equal shex, dd.to_shex
+      
+  end
+  def test_new_from_hash
+    h_dd = {:packet_type=>:dd, :area_id=>"0.0.0.0", :imms=>7, :au_type=>:null, :router_id=>"192.168.1.200", :dd_sequence_number=>3232386840, :ospf_version=>2, :interface_mtu=>1500, :options=>0}
+    dd = DatabaseDescription.new(h_dd)
+    assert_equal DatabaseDescription, dd.class
+    assert_equal h_dd.merge(:lsas=>[]), dd.to_hash()
+  end
+  def test_new_from_hash_with_ls_db
+  end
+
+
+end