libnet4r 0.1

data/test/tc_arp.rb

@@ -0,0 +1,169 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'libnet4r'
+
+class TC_Libnet_ARP < Test::Unit::TestCase
+  def test_unpack
+    bytes = [
+      0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xaa, 0xbb, 0xcc, 0xdd,
+      0xee, 0xff, 0xc0, 0xa8, 0x01, 0x64, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xc0, 0xa8, 0x01, 0x7b
+    ].pack("C*")
+
+    a = Libnet::ARP.decode(bytes)
+
+    assert_equal(0x0001, a.htype)
+    assert_equal(0x0800, a.protocol)
+    assert_equal(6, a.hlen)
+    assert_equal(4, a.plen)
+    assert_equal(1, a.operation)
+    assert_equal([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff].pack("C*"), a.sender_haddr)
+    assert_equal([0xc0, 0xa8, 0x01, 0x64].pack("C*"), a.sender_paddr)
+    assert_equal([0x11, 0x22, 0x33, 0x44, 0x55, 0x66].pack("C*"), a.target_haddr)
+    assert_equal([0xc0, 0xa8, 0x01, 0x7b].pack("C*"), a.target_paddr)
+    assert_nil(a.payload)
+
+    assert_raise ArgumentError do
+      Libnet::ARP.decode("foobar")
+    end
+  end
+
+  def test_pack
+    exp_bytes = [
+      0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xaa, 0xbb, 0xcc, 0xdd,
+      0xee, 0xff, 0xc0, 0xa8, 0x01, 0x64, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xc0, 0xa8, 0x01, 0x7b
+    ].pack("C*")
+
+    # build the ARP header object separately
+    a = Libnet::ARP.new
+
+    a.htype        = 1
+    a.protocol     = 0x0800
+    a.hlen         = 6
+    a.plen         = 4
+    a.operation    = 1
+    a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+    a.sender_paddr = '192.168.1.100'
+    a.target_haddr = '11:22:33:44:55:66'
+    a.target_paddr = '192.168.1.123'
+
+    l = Libnet.new
+
+    assert_nil(a.ptag)
+
+    l.build_arp(a)
+
+    assert(a.ptag > 0)
+    assert_equal(exp_bytes, l.pack)
+
+    # build the ARP header as a yielded object
+    l = Libnet.new
+
+    l.build_arp do |a|
+      a.htype        = 1
+      a.protocol     = 0x0800
+      a.hlen         = 6
+      a.plen         = 4
+      a.operation    = 1
+      a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+      a.sender_paddr = '192.168.1.100'
+      a.target_haddr = '11:22:33:44:55:66'
+      a.target_paddr = '192.168.1.123'
+    end
+
+    assert(a.ptag > 0)
+
+    assert_equal(exp_bytes, l.pack)
+  end
+
+  def test_modify_ptag
+    arp1 = [
+      0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xaa, 0xbb, 0xcc, 0xdd,
+      0xee, 0xff, 0xc0, 0xa8, 0x01, 0x64, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xc0, 0xa8, 0x01, 0x7b
+    ].pack("C*")
+    arp2 = [
+      0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x02, 0xaa, 0xbb, 0xcc, 0xdd,
+      0xee, 0xff, 0xc0, 0xa8, 0x01, 0x64, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xc0, 0xa8, 0x01, 0x7b
+    ].pack("C*")
+
+    l = Libnet.new
+
+    a = l.build_arp do |a|
+      a.htype        = 1
+      a.protocol     = 0x0800
+      a.hlen         = 6
+      a.plen         = 4
+      a.operation    = 1
+      a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+      a.sender_paddr = '192.168.1.100'
+      a.target_haddr = '11:22:33:44:55:66'
+      a.target_paddr = '192.168.1.123'
+    end
+
+    assert(a.ptag > 0)
+
+    ptag = a.ptag
+
+    assert_equal(arp1, l.pack)
+
+    a.operation = 2
+
+    l.build_arp(a)
+
+    assert_equal(ptag, a.ptag)
+
+    assert_equal(arp2, l.pack)
+  end
+
+  def test_missing_fields
+    l = Libnet.new
+
+    assert_raise ArgumentError do
+      l.build_arp { |e| }
+    end
+
+    assert_raise ArgumentError do
+      l.build_arp do |a|
+        a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+        a.target_haddr = '11:22:33:44:55:66'
+      end
+    end
+  end
+
+  def test_frame
+    exp_bytes = [
+      0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0x22, 0x33, 0x22, 0x33, 0x22, 0x33,
+      0x08, 0x06,
+      0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xaa, 0xbb, 0xcc, 0xdd,
+      0xee, 0xff, 0xc0, 0xa8, 0x01, 0x64, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xc0, 0xa8, 0x01, 0x7b
+    ].pack("C*")
+
+    l = Libnet.new(:link)
+
+    a = l.build_arp do |a|
+      a.htype        = 1
+      a.protocol     = 0x0800
+      a.hlen         = 6
+      a.plen         = 4
+      a.operation    = 1
+      a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+      a.sender_paddr = '192.168.1.100'
+      a.target_haddr = '11:22:33:44:55:66'
+      a.target_paddr = '192.168.1.123'
+    end
+
+    e = l.build_ethernet do |e|
+      e.dst  = '12:34:56:78:90:ab'
+      e.src  = '22:33:22:33:22:33'
+      e.type = 0x0806
+    end
+
+    assert_equal(exp_bytes, l.pack)
+  end
+end
+

data/test/tc_class.rb

@@ -0,0 +1,219 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'libnet4r'
+
+class TC_Libnet_Class < Test::Unit::TestCase
+  def test_addr2name4
+    assert_respond_to(Libnet, :addr2name4)
+
+    ip = 0xcdea6d12
+
+    assert_equal("rubyforge.org", Libnet.addr2name4(ip))
+    assert_equal("rubyforge.org", Libnet.addr2name4(ip, true))
+    assert_equal("205.234.109.18", Libnet.addr2name4(ip, false))
+  end
+
+  # FIXME: I don't know of a valid IPv6 address to use here
+  def test_addr2name6
+    assert_respond_to(Libnet, :addr2name6)
+
+    ip = Libnet.ipv6_aton("fe80::20d:93ff:fe2f:3704")
+
+    assert_equal("fe80::20d:93ff:fe2f:3704", Libnet.addr2name6(ip, false))
+  end
+
+  def test_hex_aton
+    assert_respond_to(Libnet, :hex_aton)
+
+    bytes1 = [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff].pack("C*")
+    bytes2 = [0x01, 0x23, 0x45, 0x67, 0x89, 0xab].pack("C*")
+
+    assert_equal(bytes1, Libnet.hex_aton("aa:bb:cc:dd:ee:ff"))
+    assert_equal(bytes2, Libnet.hex_aton("01:23:45:67:89:ab"))
+
+    assert_raise ArgumentError do
+      Libnet.hex_aton("aa:bb:cc:dd:ee:fg")
+    end
+  end
+
+  def test_ipv4_aton
+    assert_respond_to(Libnet, :ipv4_aton)
+
+    assert_equal(0xcdea6d12, Libnet.ipv4_aton("205.234.109.18"))
+
+    # check for invalid ip address
+    assert_raise ArgumentError do
+      Libnet.ipv4_aton("256.234.109.18")
+    end
+
+    assert_raise ArgumentError do
+      Libnet.ipv4_aton("205.234.109")
+    end
+
+    assert_raise ArgumentError do
+      Libnet.ipv4_aton("205.234.109.ab")
+    end
+  end
+
+  def test_ipv4_ntoa
+    assert_respond_to(Libnet, :ipv4_ntoa)
+
+    assert_equal("205.234.109.18", Libnet.ipv4_ntoa(0xcdea6d12))
+  end
+
+  def test_ipv6_aton
+    ip6_1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack("C*")
+    ip6_2 = [
+      0x80, 0x5b, 0x2d, 0x9d, 0xdc, 0x28, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x57,
+      0xd4, 0xc8, 0x1f, 0xff
+    ].pack("C*")
+
+    assert_respond_to(Libnet, :ipv6_aton)
+
+    assert_equal(ip6_1, Libnet.ipv6_aton("::"))
+    assert_equal(ip6_2, Libnet.ipv6_aton("805b:2d9d:dc28::fc57:d4c8:1fff"))
+
+    # check for invalid ip address
+    assert_raise ArgumentError do
+      Libnet.ipv6_aton("1234")
+    end
+
+    assert_raise ArgumentError do
+      Libnet.ipv6_aton("1234::4321:abcd::dcba")
+    end
+  end
+
+  def test_ipv6_ntoa
+    ip6_1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack("C*")
+    ip6_2 = [
+      0x80, 0x5b, 0x2d, 0x9d, 0xdc, 0x28, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x57,
+      0xd4, 0xc8, 0x1f, 0xff
+    ].pack("C*")
+
+    assert_respond_to(Libnet, :ipv6_ntoa)
+
+    assert_equal("::", Libnet.ipv6_ntoa(ip6_1))
+    assert_equal("805b:2d9d:dc28::fc57:d4c8:1fff", Libnet.ipv6_ntoa(ip6_2))
+
+    assert_raise ArgumentError do
+      Libnet.hexdump(Libnet.ipv6_ntoa("foobar"))
+    end
+  end
+
+  def test_hexdump
+    assert_respond_to(Libnet, :hexdump)
+
+    bytes = [
+      0xde, 0xad, 0xbe, 0xef, 0xfe, 0xed, 0xfa, 0xce, 0x00, 0x11, 0x22, 0x33,
+      0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+      0xcb
+    ].pack("C*")
+
+    dump = <<_END_
+0x00000000: deadbeef feedface 00112233 44556677
+0x00000010: 8899aabb ccddeeff cb
+_END_
+
+    assert_equal(dump, Libnet.hexdump(bytes))
+  end
+
+  def test_write
+    l = Libnet.new(:link)
+
+    l.build_arp do |a|
+      a.htype        = 1
+      a.protocol     = 0x0800
+      a.hlen         = 6
+      a.plen         = 4
+      a.operation    = 1
+      a.sender_haddr = 'aa:bb:cc:dd:ee:ff'
+      a.sender_paddr = '192.168.1.100'
+      a.target_haddr = '11:22:33:44:55:66'
+      a.target_paddr = '192.168.1.123'
+    end
+
+    l.build_ethernet do |e|
+      e.dst  = '12:34:56:78:90:ab'
+      e.src  = '22:33:22:33:22:33'
+      e.type = 0x0806
+    end
+
+    if Process.uid > 0 && Process.euid > 0
+      # user is not root, so we should get an exception here
+      assert_raise RuntimeError do
+        l.write
+      end
+    else
+      # user is root, so this should work
+      assert_equal(42, l.write)
+    end
+  end
+
+  def test_write_bytes
+    eth = [
+      0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0x12, 0x34, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
+      0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+    ].pack("C*")
+    ip4 = [
+      0x45, 0x12, 0x00, 0x40, 0x43, 0x21, 0x00, 0x00, 0x48, 0x11, 0xac, 0x24,
+      0xc0, 0xa8, 0x01, 0x02, 0xc0, 0xa8, 0x01, 0x03, 0x74, 0x68, 0x65, 0x20,
+      0x71, 0x75, 0x69, 0x63, 0x6b, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0x20,
+      0x66, 0x6f, 0x78, 0x20, 0x6a, 0x75, 0x6d, 0x70, 0x65, 0x64, 0x20, 0x6f,
+      0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x7a, 0x79,
+      0x20, 0x64, 0x6f, 0x67
+    ].pack("C*")
+    ip6 = [
+      0x62, 0x2d, 0xbe, 0xef, 0x00, 0x54, 0x11, 0x18, 0x00, 0x11, 0x22, 0x33,
+      0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+      0xaa, 0xbb, 0xaa, 0xbb, 0xcc, 0xdd, 0xcc, 0xdd, 0xee, 0xff, 0xee, 0xff,
+      0x22, 0x33, 0x22, 0x33, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63,
+      0x6b, 0x20, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x66, 0x6f, 0x78, 0x20,
+      0x6a, 0x75, 0x6d, 0x70, 0x65, 0x64, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x20,
+      0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x7a, 0x79, 0x20, 0x64, 0x6f, 0x67
+    ].pack("C*")
+
+    l = Libnet.new(:link)
+
+    if Process.uid > 0 && Process.euid > 0
+      # user is not root, so we should get an exception here
+      assert_raise RuntimeError do
+        l.write_bytes(eth)
+      end
+    else
+      # user is root, so this should work
+      n = l.write_bytes(eth)
+      assert_equal(eth.length, n)
+    end
+
+    l = Libnet.new(:raw4)
+
+    if Process.uid > 0 && Process.euid > 0
+      # user is not root, so we should get an exception here
+      assert_raise RuntimeError do
+        l.write_bytes(ip4)
+      end
+    else
+      # user is root, so this should work
+      n = l.write_bytes(ip4)
+      assert_equal(ip4.length, n)
+    end
+
+    l = Libnet.new(:raw6)
+
+    if Process.uid > 0 && Process.euid > 0
+      # user is not root, so we should get an exception here
+      assert_raise RuntimeError do
+        l.write_bytes(ip6)
+      end
+    else
+      # FIXME: I keep getting "no route to host" errors here, not sure how to
+      # fix this yet
+      # # user is root, so this should work
+      # n =l.write_bytes(ip6)
+      # assert_equal(ip6.length, n)
+    end
+  end
+end
+

data/test/tc_ethernet.rb

@@ -0,0 +1,97 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'libnet4r'
+
+class TC_Libnet_Ethernet < Test::Unit::TestCase
+  def test_unpack
+    eth = [
+      0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0x12, 0x34, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
+      0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+    ].pack("C*")
+
+    e = Libnet::Ethernet.decode(eth)
+
+    assert_equal([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff].pack("C*"), e.dst)
+    assert_equal([0x11, 0x22, 0x33, 0x44, 0x55, 0x66].pack("C*"), e.src)
+    assert_equal(0x1234, e.type)
+    assert_equal("this is the message", e.payload)
+
+    assert_raise ArgumentError do
+      Libnet::Ethernet.decode("foobar")
+    end
+  end
+
+  def test_pack
+    eth = [
+      0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0x12, 0x34, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
+      0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+    ].pack("C*")
+
+    e = Libnet::Ethernet.new
+
+    e.dst = 'aa:bb:cc:dd:ee:ff'
+    e.src = [0x11, 0x22, 0x33, 0x44, 0x55, 0x66].pack("C*")
+    e.type = 0x1234
+    e.payload = "this is the message"
+
+    l = Libnet.new
+
+    assert_nil(e.ptag)
+
+    l.build_ethernet(e)
+
+    assert(e.ptag > 0)
+    assert_equal(eth, l.pack)
+
+    l = Libnet.new
+    e = nil
+
+    l.build_ethernet do |e|
+      e.dst = 'aa:bb:cc:dd:ee:ff'
+      e.src = [0x11, 0x22, 0x33, 0x44, 0x55, 0x66].pack("C*")
+      e.type = 0x1234
+      e.payload = "this is the message"
+    end
+
+    assert(e.ptag > 0)
+    assert_equal(eth, l.pack)
+  end
+
+  def test_modify_ptag
+    eth1 = [
+      0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0x12, 0x34, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
+      0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+    ].pack("C*")
+
+    eth2 = [
+      0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,
+      0xab, 0xcd, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
+      0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65
+    ].pack("C*")
+
+    l = Libnet.new
+
+    e = l.build_ethernet do |e|
+      e.dst = 'aa:bb:cc:dd:ee:ff'
+      e.src = '11:22:33:44:55:66'
+      e.type = 0x1234
+      e.payload = "this is the message"
+    end
+
+    assert_not_nil(e.ptag)
+    ptag = e.ptag
+
+    assert_equal(eth1, l.pack)
+
+    e.type = 0xabcd
+
+    l.build_ethernet(e)
+
+    assert_equal(ptag, e.ptag)
+    assert_equal(eth2, l.pack)
+  end
+end

data/test/tc_header.rb

@@ -0,0 +1,163 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'libnet4r'
+
+class TestHeader1 < Libnet::Header
+  unsigned_field :foo, 4
+  unsigned_field :bar, 2, :optional => true, :aliases => [ :bar2, :bar3 ]
+  unsigned_field :baz, 1, :read_only => true, :aliases => [ :baz2 ]
+  octets_field   :qux
+end
+
+class TestHeader2 < Libnet::Header
+  unsigned_field :checksum, 4
+end
+
+class TC_Libnet_Header < Test::Unit::TestCase
+  def test_fields
+    assert_equal([:foo, :qux, :bar, :baz], TestHeader1.fields)
+    assert_equal([:foo, :qux], TestHeader1.required_fields)
+    assert_equal([:bar], TestHeader1.optional_fields)
+    assert_equal([:baz], TestHeader1.read_only_fields)
+
+    assert_equal([:checksum], TestHeader2.fields)
+    assert_equal([:checksum], TestHeader2.required_fields)
+    assert_equal([], TestHeader2.optional_fields)
+    assert_equal([], TestHeader2.read_only_fields)
+  end
+
+  def test_decode
+    assert_respond_to(TestHeader1, :decode)
+
+    # subclasses must implement the decode method
+    assert_raise NotImplementedError do
+      p = TestHeader1.new("foobarbaz")
+    end
+  end
+
+  def test_field_assignment
+    p = TestHeader1.new
+
+    # writeable fields should have assigment methods
+    assert_respond_to(p, :foo=)
+    assert_respond_to(p, :bar=)
+    assert_respond_to(p, :qux=)
+
+    assert_equal(p.foo = 1, 1)
+    assert_equal(p.bar = 2, 2)
+    assert_equal(p.qux = "stuff", "stuff")
+
+    # read-only fields should not have assignment methods
+    assert_raise NoMethodError do
+      p.baz = 1
+    end
+  end
+
+  def test_read_query
+    p = TestHeader1.new
+
+    assert_respond_to(p, :foo)
+    assert_respond_to(p, :foo?)
+    assert_respond_to(p, :bar)
+    assert_respond_to(p, :bar?)
+    assert_respond_to(p, :baz)
+    assert_respond_to(p, :baz?)
+    assert_respond_to(p, :qux)
+    assert_respond_to(p, :qux?)
+
+    assert_equal(false, p.foo?)
+    assert_equal(false, p.bar?)
+    assert_equal(false, p.baz?)
+    assert_equal(false, p.qux?)
+
+    p.foo = 1
+    p.bar = 2
+    p.qux = "stuff"
+
+    assert_equal(true, p.foo?)
+    assert_equal(true, p.bar?)
+    assert_equal(false, p.baz?)
+    assert_equal(true, p.qux?)
+
+    assert_equal(p.foo, 1)
+    assert_equal(p.bar, 2)
+    assert_equal(p.qux, "stuff")
+  end
+
+  def test_alias
+    p = TestHeader1.new
+
+    assert_respond_to(p, :bar2)
+    assert_respond_to(p, :bar2=)
+    assert_respond_to(p, :bar2?)
+    assert_respond_to(p, :bar3)
+    assert_respond_to(p, :bar3=)
+    assert_respond_to(p, :bar3?)
+
+    assert_respond_to(p, :baz2)
+    assert_respond_to(p, :baz2?)
+
+    assert_equal(false, p.respond_to?(:baz2=))
+  end
+
+  def test_range_checks
+    p = TestHeader1.new
+
+    assert_raise ArgumentError do
+      p.foo = -1
+    end
+
+    assert_equal(p.foo = 0, 0)
+    assert_equal(p.foo = 0xffffffff, 0xffffffff)
+
+    assert_raise ArgumentError do
+      p.foo = 0x100000000
+    end
+  end
+
+  def test_ptag
+    p = TestHeader1.new
+
+    assert_respond_to(p, :ptag)
+  end
+
+  def test_auto_checksum_toggle
+    p1 = TestHeader1.new
+    p2 = TestHeader2.new
+
+    assert_raise NoMethodError do
+      p1.auto_checksum?
+    end
+
+    assert_raise NoMethodError do
+      p1.auto_checksum = false
+    end
+
+    assert_respond_to(p2, :auto_checksum?)
+    assert_respond_to(p2, :auto_checksum=)
+  end
+
+  def test_check_packable
+    p = TestHeader1.new
+
+    assert(p.private_methods.include?('check_packable'))
+
+    assert_raise ArgumentError, "the following TestHeader1 required fields have not been set: foo, qux" do
+      p.send(:check_packable)
+    end
+
+    p.foo = 1
+
+    assert_raise ArgumentError, "the following TestHeader1 required fields have not been set: qux" do
+      p.send(:check_packable)
+    end
+
+    p.qux = "stuff"
+
+    assert_nothing_raised ArgumentError do
+      p.send(:check_packable)
+    end
+  end
+end
+

data/test/tc_init.rb

@@ -0,0 +1,25 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'libnet4r'
+
+class TC_Libnet_Init
+  def test_init
+    # default injection type should be :raw4
+    assert_equal(Libnet.new.injection_type, :raw4)
+
+    assert_equal(Libnet.new(:raw4).injection_type, :raw4)
+    assert_equal(Libnet.new('raw4').injection_type, :raw4)
+    assert_equal(Libnet.new(:raw).injection_type, :raw4)
+    assert_equal(Libnet.new('raw').injection_type, :raw4)
+
+    assert_equal(Libnet.new(:link).injection_type, :link)
+    assert_equal(Libnet.new('link').injection_type, :link)
+
+    assert_equal(Libnet.new(:raw4, 'en0').device, 'en0')
+
+    assert_raise ArgumentError do
+      Libnet.new(:foo)
+    end
+  end
+end