packetfu 1.1.1 → 1.1.2

data/test/packetfu_spec.rb

@@ -1,90 +0,0 @@
-$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
-require 'packetfu'
-
-unless %x{#{$0} --version} =~ /^2\.6/
-	puts "PacketFu needs rspec 2.6 or so."
-	exit 1
-end
-
-describe PacketFu, "version information" do
-	it "reports a version number" do
-		PacketFu::VERSION.should match /^1\.[0-9]\.[0-9]$/
-	end
-	its(:version) {should eq PacketFu::VERSION} 
-
-	it "can compare version strings" do
-		PacketFu.binarize_version("1.2.3").should == 0x010203
-		PacketFu.binarize_version("3.0").should == 0x030000
-		PacketFu.at_least?("1.0").should be_true
-		PacketFu.at_least?("4.0").should be_false
-		PacketFu.older_than?("4.0").should be_true
-		PacketFu.newer_than?("1.0").should be_true
-	end
-
-	it "can handle .pre versions" do
-		PacketFu.binarize_version("1.7.6.pre").should == 0x010706
-		PacketFu.at_least?("0.9.0.pre").should be_true
-	end
-end
-
-describe PacketFu, "instance variables" do
-	it "should have a bunch of instance variables" do
-		PacketFu.instance_variable_get(:@byte_order).should == :little
-		PacketFu.instance_variable_get(:@pcaprub_loaded).should_not be_nil
-	end
-end
-
-describe PacketFu, "pcaprub deps" do
-	it "should check for pcaprub" do
-		begin
-			has_pcap = false
-			require 'pcaprub'
-			has_pcap = true
-		rescue LoadError
-		end
-		if has_pcap
-			PacketFu.instance_variable_get(:@pcaprub_loaded).should be_true
-		else
-			PacketFu.instance_variable_get(:@pcaprub_loaded).should be_false
-		end
-	end
-end
-
-describe PacketFu, "protocol requires" do
-	it "should have some protocols defined" do
-		PacketFu::EthPacket.should_not be_nil
-		PacketFu::IPPacket.should_not be_nil
-		PacketFu::TCPPacket.should_not be_nil
-		expect { PacketFu::FakePacket }.to raise_error
-	end
-end
-
-describe PacketFu, "packet class list management" do
-
-	before(:all) do
-		class PacketFu::FooPacket < PacketFu::Packet; end
-		class PacketFu::BarPacket < PacketFu::Packet; end
-		class PacketFu::PacketBaz; end
-	end
-
-	it "should allow packet class registration" do
-		PacketFu.add_packet_class(PacketFu::FooPacket).should be_kind_of Array
-		PacketFu.add_packet_class(PacketFu::BarPacket).should be_kind_of Array
-	end
-
-	its(:packet_classes) {should include(PacketFu::FooPacket)}
-
-	it "should disallow non-classes as packet classes" do
-		expect { PacketFu.add_packet_class("A String") }.to raise_error
-	end
-
-	its(:packet_prefixes) {should include("bar")}
-
-	# Don't really have much utility for this right now.
-	it "should allow packet class deregistration" do
-		PacketFu.remove_packet_class(PacketFu::BarPacket)
-		PacketFu.packet_prefixes.should_not include("bar")
-		PacketFu.add_packet_class(PacketFu::BarPacket)
-	end
-
-end

data/test/ptest.rb

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib/")
-require 'pcaprub'
-require 'packetfu'
-include PacketFu
-
-if Process.euid.zero? 
-	puts ">> Interface: " << Pcap.lookupdev
-else
-	puts ">> No interface access"
-end	
-puts ">> Version: " << PacketFu.version
-
-# vim: nowrap sw=2 sts=0 ts=2 ff=unix ft=ruby
-
-

data/test/structfu_spec.rb

@@ -1,335 +0,0 @@
-$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
-require 'packetfu'
-
-describe StructFu, "mixin methods" do
-
-	before :each do
-		class StructClass
-			include StructFu
-		end
-		@sc = StructClass.new
-	end
-
-	it "should provide the basic StructFu methods" do
-		@sc.respond_to?(:sz).should be_true
-		@sc.respond_to?(:len).should be_true
-		@sc.respond_to?(:typecast).should be_true
-		@sc.respond_to?(:body=).should be_true
-	end
-end	
-
-describe StructFu::Int, "basic Int class" do
-
-	before :each do
-		@int = StructFu::Int.new(8)
-	end
-
-	it "should have an initial state" do
-		new_int = StructFu::Int.new
-		new_int.value.should be_nil
-		new_int.endian.should be_nil
-		new_int.width.should be_nil
-		new_int.default.should == 0
-	end
-
-	it "should raise when to_s'ed directly" do
-		expect { @int.to_s}.to raise_error
-	end
-
-	it "should have a value of 8" do
-		@int.value.should == 8
-		@int.to_i.should == 8
-		@int.to_f.to_s.should == "8.0"
-	end
-
-	it "should read an integer" do
-		@int.read(7)
-		@int.to_i.should == 7
-	end
-
-end
-
-describe StructFu::Int8, "one byte value" do
-
-	before :each do
-		@int = StructFu::Int8.new(11)
-	end
-
-	it "should have an initial state" do
-		new_int = StructFu::Int8.new
-		new_int.value.should be_nil
-		new_int.endian.should be_nil
-		new_int.width.should == 1
-		new_int.default.should == 0
-	end
-
-	it "should print a one character packed string" do
-		@int.to_s.should == "\x0b"
-	end
-
-	it "should have a value of 11" do
-		@int.value.should == 11
-		@int.to_i.should == 11
-		@int.to_f.to_s.should == "11.0"
-	end
-
-	it "should reset with a new integer" do
-		@int.read(2)
-		@int.to_i.should == 2
-		@int.to_s.should == "\x02"
-		@int.read(254)
-		@int.to_i.should == 254
-		@int.to_s.should == "\xfe"
-	end
-
-end
-
-describe StructFu::Int16, "two byte value" do
-
-	before :each do
-		@int = StructFu::Int16.new(11)
-	end
-
-	it "should have an initial state" do
-		new_int = StructFu::Int16.new
-		new_int.value.should be_nil
-		new_int.endian.should == :big
-		new_int.width.should == 2
-		new_int.default.should == 0
-	end
-
-	it "should print a two character packed string" do
-		@int.to_s.should == "\x00\x0b"
-	end
-
-	it "should have a value of 11" do
-		@int.value.should == 11
-		@int.to_i.should == 11
-		@int.to_f.to_s.should == "11.0"
-	end
-
-	it "should reset with a new integer" do
-		@int.read(2)
-		@int.to_i.should == 2
-		@int.to_s.should == "\x00\x02"
-		@int.read(254)
-		@int.to_i.should == 254
-		@int.to_s.should == "\x00\xfe"
-	end
-
-	it "should be able to set endianness" do
-		int_be = StructFu::Int16.new(11,:big)
-		int_be.to_s.should == "\x00\x0b"
-		int_le = StructFu::Int16.new(11,:little)
-		int_le.to_s.should == "\x0b\x00"
-	end
-
-	it "should be able to switch endianness" do
-		@int.endian.should == :big
-		@int.to_s.should == "\x00\x0b"
-		@int.endian = :little
-		@int.endian.should == :little
-		@int.read(11)
-		@int.to_s.should == "\x0b\x00"
-	end
-
-end
-
-describe StructFu::Int16le, "2 byte little-endian value" do
-
-	before :each do
-		@int = StructFu::Int16le.new(11)
-	end
-
-	it "should behave pretty much like any other 16 bit int" do
-		@int.to_s.should == "\x0b\x00"
-	end
-
-	it "should raise when you try to change endianness" do
-		expect { @int.endian = :big }.to raise_error
-		expect { @int.endian = :little }.to raise_error
-	end
-
-end
-
-describe StructFu::Int16be, "2 byte big-endian value" do
-
-	before :each do
-		@int = StructFu::Int16be.new(11)
-	end
-
-	it "should behave pretty much like any other 16 bit int" do
-		@int.to_s.should == "\x00\x0b"
-	end
-
-	it "should raise when you try to change endianness" do
-		expect { @int.endian = :big }.to raise_error
-		expect { @int.endian = :little }.to raise_error
-	end
-
-end
-
-describe StructFu::Int32, "four byte value" do
-
-	before :each do
-		@int = StructFu::Int32.new(11)
-	end
-
-	it "should have an initial state" do
-		new_int = StructFu::Int32.new
-		new_int.value.should be_nil
-		new_int.endian.should == :big
-		new_int.width.should == 4
-		new_int.default.should == 0
-	end
-
-	it "should print a four character packed string" do
-		@int.to_s.should == "\x00\x00\x00\x0b"
-	end
-
-	it "should have a value of 11" do
-		@int.value.should == 11
-		@int.to_i.should == 11
-		@int.to_f.to_s.should == "11.0"
-	end
-
-	it "should reset with a new integer" do
-		@int.read(2)
-		@int.to_i.should == 2
-		@int.to_s.should == "\x00\x00\x00\x02"
-		@int.read(254)
-		@int.to_i.should == 254
-		@int.to_s.should == "\x00\x00\x00\xfe"
-	end
-
-	it "should be able to set endianness" do
-		int_be = StructFu::Int32.new(11,:big)
-		int_be.to_s.should == "\x00\x00\x00\x0b"
-		int_le = StructFu::Int32.new(11,:little)
-		int_le.to_s.should == "\x0b\x00\x00\x00"
-	end
-
-	it "should be able to switch endianness" do
-		@int.endian.should == :big
-		@int.to_s.should == "\x00\x00\x00\x0b"
-		@int.endian = :little
-		@int.endian.should == :little
-		@int.read(11)
-		@int.to_s.should == "\x0b\x00\x00\x00"
-	end
-
-end
-
-describe StructFu::Int32le, "4 byte little-endian value" do
-
-	before :each do
-		@int = StructFu::Int32le.new(11)
-	end
-
-	it "should behave pretty much like any other 32 bit int" do
-		@int.to_s.should == "\x0b\x00\x00\x00"
-	end
-
-	it "should raise when you try to change endianness" do
-		expect { @int.endian = :big }.to raise_error
-		expect { @int.endian = :little }.to raise_error
-	end
-
-end
-
-describe StructFu::Int32be, "4 byte big-endian value" do
-
-	before :each do
-		@int = StructFu::Int32be.new(11)
-	end
-
-	it "should behave pretty much like any other 32 bit int" do
-		@int.to_s.should == "\x00\x00\x00\x0b"
-	end
-
-	it "should raise when you try to change endianness" do
-		expect { @int.endian = :big }.to raise_error
-		expect { @int.endian = :little }.to raise_error
-	end
-
-end
-
-describe StructFu::String, "a sligtly more special String" do
-
-	before :each do
-		@str = StructFu::String.new("Oi, a string")
-	end
-
-	it "should behave pretty much like a string" do
-		@str.should be_kind_of(String)
-	end
-
-	it "should have a read method" do
-		@str.should respond_to(:read)
-	end
-
-	it "should read data like other StructFu things" do
-		@str.read("hello")
-		@str.should == "hello"
-	end
-
-end
-
-describe StructFu::IntString do
-
-	it "should be" do
-		StructFu::IntString.should be
-	end
-
-	it "should have a length and value" do
-		istr = StructFu::IntString.new("Avast!")
-		istr.to_s.should == "\x06Avast!"
-	end
-
-	it "should have a 16-bit length and a value" do
-		istr = StructFu::IntString.new("Avast!",StructFu::Int16)
-		istr.to_s.should == "\x00\x06Avast!"
-	end
-
-	it "should have a 32-bit length and a value" do
-		istr = StructFu::IntString.new("Avast!",StructFu::Int32)
-		istr.to_s.should == "\x00\x00\x00\x06Avast!"
-	end
-
-	before :each do
-		@istr = StructFu::IntString.new("Avast!",StructFu::Int32)
-	end
-
-	it "should report the correct length with a new string" do
-		@istr.to_s.should == "\x00\x00\x00\x06Avast!"
-		@istr.string = "Ahoy!"
-		@istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
-	end
-
-	it "should report the correct length with a new string" do
-		@istr.string = "Ahoy!"
-		@istr.to_s.should == "\x00\x00\x00\x05Ahoy!"
-	end
-
-	it "should keep the old length with a new string" do
-		@istr[:string] = "Ahoy!"
-		@istr.to_s.should == "\x00\x00\x00\x06Ahoy!"
-	end
-
-	it "should allow for adjusting the length manually" do
-		@istr.len = 16
-		@istr.to_s.should == "\x00\x00\x00\x10Avast!"
-	end
-
-	it "should read in an expected string" do
-		data = "\x00\x00\x00\x09Yo ho ho!"
-		@istr.read(data)
-		@istr.to_s.should == data
-	end
-
-	it "should raise when a string is too short" do
-		data = "\x01A"
-		expect { @istr.read(data) }.to raise_error
-	end
-
-end