packetfu 1.1.10 → 1.1.11

data/test/test_eth.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# -*- coding: binary -*-
+
 require 'test/unit'
 $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
@@ -6,85 +8,85 @@ puts "Testing #{PacketFu.version}: #{$0}"
 
 class EthTest < Test::Unit::TestCase
 
-	def test_ethmac
-		dst = "\x00\x03\x2f\x1a\x74\xde"
-		e = PacketFu::EthMac.new
-		e.read dst
-		assert_equal(dst, e.to_s)
-		assert_equal(0x32f, e.oui.oui)
-		assert_equal("\x1a\x74\xde", e.nic.to_s)
-		assert_equal(222, e.nic.n2)
-	end
+  def test_ethmac
+    dst = "\x00\x03\x2f\x1a\x74\xde"
+    e = PacketFu::EthMac.new
+    e.read dst
+    assert_equal(dst, e.to_s)
+    assert_equal(0x32f, e.oui.oui)
+    assert_equal("\x1a\x74\xde", e.nic.to_s)
+    assert_equal(222, e.nic.n2)
+  end
 
-	def test_ethmac_ipad
-		dst = "\x7c\x6d\x62\x01\x02\x03"
-		e = PacketFu::EthMac.new
-		e.read dst
-		assert_equal(dst, e.to_s)
-		assert_equal(0x6d62, e.oui.oui)
-	end
+  def test_ethmac_ipad
+    dst = "\x7c\x6d\x62\x01\x02\x03"
+    e = PacketFu::EthMac.new
+    e.read dst
+    assert_equal(dst, e.to_s)
+    assert_equal(0x6d62, e.oui.oui)
+  end
 
-	def test_ethmac_class
-		src = "\x00\x1b\x11\x51\xb7\xce"
-		e = PacketFu::EthMac.new
-		e.read src
-		assert_instance_of(PacketFu::EthMac, e)
-	end
+  def test_ethmac_class
+    src = "\x00\x1b\x11\x51\xb7\xce"
+    e = PacketFu::EthMac.new
+    e.read src
+    assert_instance_of(PacketFu::EthMac, e)
+  end
 
-	def test_eth
-		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
-		src = "\x00\x1b\x11\x51\xb7\xce"
-		dst = "\x00\x03\x2f\x1a\x74\xde"
-		e = PacketFu::EthHeader.new
-		e.eth_dst = dst
-		e.eth_src = src
-		e.eth_proto = "\x08\x00"
-		assert_equal(header, e.to_s)
-		assert_equal(header, PacketFu::EthHeader.new.read(header).to_s)
-	end
+  def test_eth
+    header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+    src = "\x00\x1b\x11\x51\xb7\xce"
+    dst = "\x00\x03\x2f\x1a\x74\xde"
+    e = PacketFu::EthHeader.new
+    e.eth_dst = dst
+    e.eth_src = src
+    e.eth_proto = "\x08\x00"
+    assert_equal(header, e.to_s)
+    assert_equal(header, PacketFu::EthHeader.new.read(header).to_s)
+  end
 
-	def test_macaddr
-		dst = "\x00\x03\x2f\x1a\x74\xde"
-		dstmac = "00:03:2f:1a:74:de"
-		assert_equal(dstmac,PacketFu::EthHeader.str2mac(dst))
-		assert_equal(dst, PacketFu::EthHeader.mac2str(dstmac))
-	end
+  def test_macaddr
+    dst = "\x00\x03\x2f\x1a\x74\xde"
+    dstmac = "00:03:2f:1a:74:de"
+    assert_equal(dstmac,PacketFu::EthHeader.str2mac(dst))
+    assert_equal(dst, PacketFu::EthHeader.mac2str(dstmac))
+  end
 
 end
 
 class EthPacketTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_eth_create
-		sample_packet = PcapFile.new.file_to_array(:f => 'sample.pcap')[0]
-		e = EthPacket.new
-		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
-		assert_kind_of EthPacket, e
-		assert_kind_of EthHeader, e.headers[0]
-		assert e.is_eth?
-		assert !e.is_tcp?
-		e.eth_dst = "\x00\x03\x2f\x1a\x74\xde"
-		e.eth_src = "\x00\x1b\x11\x51\xb7\xce"
-		e.eth_proto = 0x0800
-		assert_equal header, e.to_s[0,14]
-	end
+  def test_eth_create
+    sample_packet = PcapFile.new.file_to_array(:f => 'sample.pcap')[0]
+    e = EthPacket.new
+    header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+    assert_kind_of EthPacket, e
+    assert_kind_of EthHeader, e.headers[0]
+    assert e.is_eth?
+    assert !e.is_tcp?
+    e.eth_dst = "\x00\x03\x2f\x1a\x74\xde"
+    e.eth_src = "\x00\x1b\x11\x51\xb7\xce"
+    e.eth_proto = 0x0800
+    assert_equal header, e.to_s[0,14]
+  end
 
-	def test_eth_new
-		p = EthPacket.new(
-		:eth_dst => "\x00\x03\x2f\x1a\x74\xde",
-		:eth_src => "\x00\x1b\x11\x51\xb7\xce",
-		:eth_proto => 0x0800)
-		header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
-		assert_equal header, p.to_s[0,14]
-	end
+  def test_eth_new
+    p = EthPacket.new(
+    :eth_dst => "\x00\x03\x2f\x1a\x74\xde",
+    :eth_src => "\x00\x1b\x11\x51\xb7\xce",
+    :eth_proto => 0x0800)
+    header = "00032f1a74de001b1151b7ce0800".scan(/../).map { |x| x.to_i(16) }.pack("C*")
+    assert_equal header, p.to_s[0,14]
+  end
 
-	def test_eth_write
-		p = EthPacket.new(
-		:eth_dst => "\x00\x03\x2f\x1a\x74\xde",
-		:eth_src => "\x00\x1b\x11\x51\xb7\xce",
-		:eth_proto => 0x0800)
-		p.to_f('eth_test.pcap')
-	end
+  def test_eth_write
+    p = EthPacket.new(
+    :eth_dst => "\x00\x03\x2f\x1a\x74\xde",
+    :eth_src => "\x00\x1b\x11\x51\xb7\xce",
+    :eth_proto => 0x0800)
+    p.to_f('eth_test.pcap')
+  end
 
 end
 

data/test/test_hsrp.rb

@@ -4,16 +4,16 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class HSRPTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_hsrp_read
-		sample_packet = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')[0]
-		pkt = Packet.parse(sample_packet)
-		assert pkt.is_hsrp?
-		assert pkt.is_udp?
-		assert_equal(0x2d8d, pkt.udp_sum.to_i)
-		# pkt.to_f('udp_test.pcap','a')
-	end
+  def test_hsrp_read
+    sample_packet = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')[0]
+    pkt = Packet.parse(sample_packet)
+    assert pkt.is_hsrp?
+    assert pkt.is_udp?
+    assert_equal(0x2d8d, pkt.udp_sum.to_i)
+    # pkt.to_f('udp_test.pcap','a')
+  end
 
 end
 

data/test/test_inject.rb

@@ -6,24 +6,24 @@ require 'packetfu'
 
 class InjectTest < Test::Unit::TestCase
 
-	def test_cap
-		assert_nothing_raised { PacketFu::Capture }
-	end
-
-	def test_whoami
-		assert_nothing_raised { PacketFu::Utils.whoami?(:iface => (ENV['IFACE'] || 'lo')) }
-	end
-
-	def test_to_w
-		assert_equal(Process.euid, 0, "TEST FAIL: This test must be run as root")
-		conf = PacketFu::Utils.whoami?(:iface => (ENV['IFACE'] || 'lo'))
-		p = PacketFu::UDPPacket.new(:config => conf)
-		p.udp_dport = 12345
-		p.udp_sport = 12345
-		p.payload = "PacketFu test packet"
-		p.recalc
-		assert p.to_w
-	end
+  def test_cap
+    assert_nothing_raised { PacketFu::Capture }
+  end
+
+  def test_whoami
+    assert_nothing_raised { PacketFu::Utils.whoami?(:iface => PacketFu::Utils.default_int) }
+  end
+
+  def test_to_w
+    assert_equal(Process.euid, 0, "TEST FAIL: This test must be run as root")
+    conf = PacketFu::Utils.whoami?(:iface => PacketFu::Utils.default_int)
+    p = PacketFu::UDPPacket.new(:config => conf)
+    p.udp_dport = 12345
+    p.udp_sport = 12345
+    p.payload = "PacketFu test packet"
+    p.recalc
+    assert p.to_w
+  end
 
 end
 

data/test/test_invalid.rb

@@ -4,24 +4,24 @@ $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class InvalidTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_create_invalid
-		p = InvalidPacket.new
-		assert_kind_of InvalidPacket, p
-		assert_kind_of Packet, p
-		assert p.is_invalid?
-		assert_equal false, p.is_eth?
-		assert_not_equal EthPacket, p.class
-	end
+  def test_create_invalid
+    p = InvalidPacket.new
+    assert_kind_of InvalidPacket, p
+    assert_kind_of Packet, p
+    assert p.is_invalid?
+    assert_equal false, p.is_eth?
+    assert_not_equal EthPacket, p.class
+  end
 
-	# Sadly, the only way to generate an "InvalidPacket" is
-	# to read a packet that's less than 14 bytes. Otherwise,
-	# it's presumed to be an EthPacket. TODO: Fix this assumption!
-	def test_parse_invalid
-		p = Packet.parse("A" * 13)
-		assert_kind_of InvalidPacket, p
-	end
+  # Sadly, the only way to generate an "InvalidPacket" is
+  # to read a packet that's less than 14 bytes. Otherwise,
+  # it's presumed to be an EthPacket. TODO: Fix this assumption!
+  def test_parse_invalid
+    p = Packet.parse("A" * 13)
+    assert_kind_of InvalidPacket, p
+  end
 
 end
 

data/test/test_octets.rb

@@ -1,33 +1,35 @@
 #!/usr/bin/env ruby
+# -*- coding: binary -*-
+
 require 'test/unit'
 $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
 require 'packetfu'
 
 class OctetsTest < Test::Unit::TestCase
-	include PacketFu
+  include PacketFu
 
-	def test_octets_read
-		o = Octets.new
-		o.read("\x04\x03\x02\x01")
-		assert_equal("4.3.2.1", o.to_x)
-	end
+  def test_octets_read
+    o = Octets.new
+    o.read("\x04\x03\x02\x01")
+    assert_equal("4.3.2.1", o.to_x)
+  end
 
-	def test_octets_read_quad
-		o = Octets.new
-		o.read_quad("1.2.3.4")
-		assert_equal("1.2.3.4", o.to_x)
-		assert_equal("\x01\x02\x03\x04", o.to_s)
-		assert_equal(0x01020304, o.to_i)
-	end
+  def test_octets_read_quad
+    o = Octets.new
+    o.read_quad("1.2.3.4")
+    assert_equal("1.2.3.4", o.to_x)
+    assert_equal("\x01\x02\x03\x04", o.to_s)
+    assert_equal(0x01020304, o.to_i)
+  end
 
-	def test_octets_single_octet
-		o = Octets.new
-		o.read("ABCD")
-		assert_equal(o.o1, 0x41)
-		assert_equal(o.o2, 0x42)
-		assert_equal(o.o3, 0x43)
-		assert_equal(o.o4, 0x44)
-	end
+  def test_octets_single_octet
+    o = Octets.new
+    o.read("ABCD")
+    assert_equal(o.o1, 0x41)
+    assert_equal(o.o2, 0x42)
+    assert_equal(o.o3, 0x43)
+    assert_equal(o.o4, 0x44)
+  end
 
 end
 

data/test/test_packet.rb

@@ -1,172 +1,174 @@
 #!/usr/bin/env ruby
+# -*- coding: binary -*-
+
 require 'test/unit'
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
 require 'packetfu'
 
 class NewPacketTest < Test::Unit::TestCase
-	include PacketFu
-	
-	def test_method_missing_and_respond_to
-		p = TCPPacket.new
-		assert p.respond_to?(:ip_len)
-		assert p.ip_len = 20
-		assert !(p.respond_to? :ip_bogus_header)
-		assert_raise NoMethodError do
-			p.bogus_header = 20
-		end
-	end
-
-	def test_more_method_missing_magic
-		p = UDPPacket.new
-		assert_kind_of(UDPPacket,p)
-		assert p.is_udp?
-		assert p.is_ip?
-		assert p.is_eth?
-		assert_equal(p.ip_hl,5)
-		assert p.layer
-		assert_raise NoMethodError do 
-			p.is_blue? 
-		end
-		assert_raise NoMethodError do
-		 	p.tcp_blue
-		end
-		assert_raise NoMethodError do 
-			p.udp_blue 
-		end
-		assert_raise NoMethodError do
-			p.blue
-		end
-	end
+  include PacketFu
+  
+  def test_method_missing_and_respond_to
+    p = TCPPacket.new
+    assert p.respond_to?(:ip_len)
+    assert p.ip_len = 20
+    assert !(p.respond_to? :ip_bogus_header)
+    assert_raise NoMethodError do
+      p.bogus_header = 20
+    end
+  end
+
+  def test_more_method_missing_magic
+    p = UDPPacket.new
+    assert_kind_of(UDPPacket,p)
+    assert p.is_udp?
+    assert p.is_ip?
+    assert p.is_eth?
+    assert_equal(p.ip_hl,5)
+    assert p.layer
+    assert_raise NoMethodError do 
+      p.is_blue? 
+    end
+    assert_raise NoMethodError do
+       p.tcp_blue
+    end
+    assert_raise NoMethodError do 
+      p.udp_blue 
+    end
+    assert_raise NoMethodError do
+      p.blue
+    end
+  end
 end
 
 class PacketStrippingTest < Test::Unit::TestCase
 
-	include PacketFu
+  include PacketFu
 
-	def test_arp_strip
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5], :fix => true) # Really ARP request.
-		assert_kind_of(Packet,p)
-		assert_kind_of(ARPPacket,p)
-	end
+  def test_arp_strip
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5], :fix => true) # Really ARP request.
+    assert_kind_of(Packet,p)
+    assert_kind_of(ARPPacket,p)
+  end
 
 end
 
 class PacketParsersTest < Test::Unit::TestCase
-	include PacketFu
-
-	def test_parse_eth_packet
-		assert_equal(EthPacket.layer, 1)
-		assert_equal(EthPacket.layer_symbol, :link)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5]) # Really ARP.
-		assert_kind_of(Packet,p)
-		assert_kind_of(EthHeader, p.headers[0])
-		assert p.is_eth?
-		assert_equal(pcaps[5],p.to_s)
-	end
-
-	def test_parse_arp_request
-		assert_equal(ARPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[5]) # Really ARP request.
-		assert p.is_eth?
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(ARPPacket,p)
-		assert p.is_arp?
-		assert_equal(p.to_s, pcaps[5])
-		assert_equal(1, p.arp_opcode.to_i)
-		assert_equal("\x00\x01", p.headers.last[:arp_opcode].to_s)
-	end
-
-	def test_parse_arp_reply
-		assert_equal(ARPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[6]) # Really ARP reply.
-		assert_equal(p.to_s, pcaps[6])
-		assert_equal(2, p.arp_opcode.to_i)
-		assert_equal("\x00\x02", p.headers.last[:arp_opcode].to_s)
-	end
-
-	def test_parse_ip_packet
-		assert_equal(IPPacket.layer, 2)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[0]) # Really DNS request 
-		assert_equal(p.to_s[0,20], pcaps[0][0,20])
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-	end
-
-	def test_parse_tcp_packet
-		assert_equal(TCPPacket.layer, 3)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[7]) # Really FIN/ACK
-		assert_equal(p.to_s, pcaps[7])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(TCPPacket,p)
-	end
-
-	def test_parse_udp_packet
-		assert_equal(UDPPacket.layer, 3)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[0]) # Really DNS request
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(UDPPacket,p)
-	end
-
-	def test_parse_icmp_packet
-		assert_equal(ICMPPacket.layer, 3)
-		assert_equal(ICMPPacket.layer_symbol, :transport)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
-		p = Packet.parse(pcaps[3]) # Really ICMP reply
-		assert_equal(p.to_s, pcaps[3])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(ICMPPacket,p)
-	end
-
-	def test_parse_invalid_packet
-		assert_equal(InvalidPacket.layer, 0)
-		assert_equal(InvalidPacket.layer_symbol, :invalid)
-		p = Packet.parse("\xff\xfe\x00\x01")
-		assert_equal(p.to_s, "\xff\xfe\x00\x01")
-		assert_kind_of(InvalidPacket,p)
-	end
-
-	def test_parse_ipv6_packet
-		assert_equal(IPv6Packet.layer, 2)
-		assert_equal(IPv6Packet.layer_symbol, :internet)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample-ipv6.pcap')
-		p = Packet.parse(pcaps[0]) # Really an IPv6 packet 
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert(!p.kind_of?(IPPacket), "Misidentified as an IP Packet!")
-		assert_kind_of(IPv6Packet,p)
-	end
-
-	def test_parse_hsrp_packet
-		assert_equal(HSRPPacket.layer, 4)
-		assert_equal(HSRPPacket.layer_symbol, :application)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
-		p = Packet.parse(pcaps[0]) # Really an HSRP Hello packet 
-		assert_equal(p.to_s, pcaps[0])
-		assert_kind_of(EthPacket,p)
-		assert_kind_of(IPPacket,p)
-		assert_kind_of(UDPPacket,p)
-		assert_kind_of(HSRPPacket,p)
-	end
-
-	def test_parse_hsrp_as_udp
-		assert_equal(:application, HSRPPacket.layer_symbol)
-		pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
-		p = Packet.parse(pcaps[0], :parse_app => false) # Really an HSRP Hello packet 
-		assert_kind_of(UDPPacket,p)
-		assert(!p.kind_of?(HSRPPacket), "Misidentified HSRP packet when we didn't want it!" )
-	end
+  include PacketFu
+
+  def test_parse_eth_packet
+    assert_equal(EthPacket.layer, 1)
+    assert_equal(EthPacket.layer_symbol, :link)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5]) # Really ARP.
+    assert_kind_of(Packet,p)
+    assert_kind_of(EthHeader, p.headers[0])
+    assert p.is_eth?
+    assert_equal(pcaps[5],p.to_s)
+  end
+
+  def test_parse_arp_request
+    assert_equal(ARPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[5]) # Really ARP request.
+    assert p.is_eth?
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(ARPPacket,p)
+    assert p.is_arp?
+    assert_equal(p.to_s, pcaps[5])
+    assert_equal(1, p.arp_opcode.to_i)
+    assert_equal("\x00\x01", p.headers.last[:arp_opcode].to_s)
+  end
+
+  def test_parse_arp_reply
+    assert_equal(ARPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[6]) # Really ARP reply.
+    assert_equal(p.to_s, pcaps[6])
+    assert_equal(2, p.arp_opcode.to_i)
+    assert_equal("\x00\x02", p.headers.last[:arp_opcode].to_s)
+  end
+
+  def test_parse_ip_packet
+    assert_equal(IPPacket.layer, 2)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[0]) # Really DNS request 
+    assert_equal(p.to_s[0,20], pcaps[0][0,20])
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+  end
+
+  def test_parse_tcp_packet
+    assert_equal(TCPPacket.layer, 3)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[7]) # Really FIN/ACK
+    assert_equal(p.to_s, pcaps[7])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(TCPPacket,p)
+  end
+
+  def test_parse_udp_packet
+    assert_equal(UDPPacket.layer, 3)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[0]) # Really DNS request
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(UDPPacket,p)
+  end
+
+  def test_parse_icmp_packet
+    assert_equal(ICMPPacket.layer, 3)
+    assert_equal(ICMPPacket.layer_symbol, :transport)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample.pcap')
+    p = Packet.parse(pcaps[3]) # Really ICMP reply
+    assert_equal(p.to_s, pcaps[3])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(ICMPPacket,p)
+  end
+
+  def test_parse_invalid_packet
+    assert_equal(InvalidPacket.layer, 0)
+    assert_equal(InvalidPacket.layer_symbol, :invalid)
+    p = Packet.parse("\xff\xfe\x00\x01")
+    assert_equal(p.to_s, "\xff\xfe\x00\x01")
+    assert_kind_of(InvalidPacket,p)
+  end
+
+  def test_parse_ipv6_packet
+    assert_equal(IPv6Packet.layer, 2)
+    assert_equal(IPv6Packet.layer_symbol, :internet)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample-ipv6.pcap')
+    p = Packet.parse(pcaps[0]) # Really an IPv6 packet 
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert(!p.kind_of?(IPPacket), "Misidentified as an IP Packet!")
+    assert_kind_of(IPv6Packet,p)
+  end
+
+  def test_parse_hsrp_packet
+    assert_equal(HSRPPacket.layer, 4)
+    assert_equal(HSRPPacket.layer_symbol, :application)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
+    p = Packet.parse(pcaps[0]) # Really an HSRP Hello packet 
+    assert_equal(p.to_s, pcaps[0])
+    assert_kind_of(EthPacket,p)
+    assert_kind_of(IPPacket,p)
+    assert_kind_of(UDPPacket,p)
+    assert_kind_of(HSRPPacket,p)
+  end
+
+  def test_parse_hsrp_as_udp
+    assert_equal(:application, HSRPPacket.layer_symbol)
+    pcaps = PcapFile.new.file_to_array(:f => 'sample_hsrp_pcapr.cap')
+    p = Packet.parse(pcaps[0], :parse_app => false) # Really an HSRP Hello packet 
+    assert_kind_of(UDPPacket,p)
+    assert(!p.kind_of?(HSRPPacket), "Misidentified HSRP packet when we didn't want it!" )
+  end
 
 end