ip 0.2.1 → 0.2.2

data/Rakefile

@@ -0,0 +1,74 @@
+#
+# Please see the COPYING file in the source distribution for copyright information.
+# 
+
+begin
+    require 'rubygems'
+    gem 'test-unit'
+rescue LoadError
+end
+
+$:.unshift 'lib'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'ip'
+
+task :default => [ :dist ]
+
+#
+# Tests
+#
+
+Rake::TestTask.new do |t|
+    t.libs << 'lib'
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true 
+end
+
+#
+# Distribution
+#
+
+task :dist      => [:test, :repackage, :gem, :rdoc]
+task :distclean => [:clobber_package, :clobber_rdoc]
+task :clean     => [:distclean]
+
+#
+# Documentation
+#
+
+Rake::RDocTask.new do |rd|
+    rd.rdoc_dir = "rdoc"
+    rd.main = "IP"
+    rd.rdoc_files.include("./lib/**/*.rb")
+    rd.options = %w(-ap)
+end
+
+#
+# Packaging
+# 
+
+spec = Gem::Specification.new do |s|
+    s.name = "ip"
+    s.version = IP::VERSION
+    s.author = "Erik Hollensbe"
+    s.email = "erik@hollensbe.org"
+    s.summary = "Ruby classes to work with IP address, ranges, and netmasks"
+    s.has_rdoc = true
+    s.files = Dir['Rakefile'] + Dir['examples/*.rb'] + Dir['lib/*.rb'] + Dir['test/*.rb'] + Dir['lib/ip/*.rb']
+    s.rubyforge_project = 'ip-address'
+end
+
+Rake::GemPackageTask.new(spec) do |s|
+end
+
+Rake::PackageTask.new(spec.name, spec.version) do |p|
+    p.need_tar_gz = true
+    p.need_zip = true
+    p.package_files.include("./Rakefile")
+    p.package_files.include("./examples/**/*.rb")
+    p.package_files.include("./lib/**/*.rb")
+    p.package_files.include("./test/**/*")
+end

data/lib/ip.rb

@@ -59,6 +59,8 @@
 
 class IP
 
+  VERSION = "0.2.2"
+
   #
   # A IP::AddressException is thrown when an IP address cannot be
   # parsed.

data/test/test_ip.rb

@@ -0,0 +1,298 @@
+begin
+    require 'rubygems'
+    gem 'test-unit'
+rescue LoadError => e 
+end
+
+require 'test/unit'
+load 'lib/ip.rb'
+
+class CIDRTest < Test::Unit::TestCase
+
+  def name
+    return "IP::CIDR tests"
+  end
+
+  def test_init_generic
+    assert_raise(IP::AddressException) { IP::CIDR.new(Hash.new) }
+    assert_raise(IP::AddressException) { IP::CIDR.new("foomatic_wootmaster/32") } 
+  end
+
+  def test_init_ipv6
+    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/asdf/32") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/foomatic_wootmaster") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("F00F:DEAD:BEEF::/255.255.255.255") }
+
+    cidr = nil
+    assert_nothing_raised() { cidr = IP::CIDR.new("F00F:DEAD:BEEF::0001/128") } 
+
+    # this sort of indirectly tests the ipv6 address manipulation.
+    assert_equal("F00F:DEAD:BEEF::1", cidr.ip.short_address, "ipv6 object constructed clean")
+    assert_equal(128, cidr.mask, "mask is set properly")
+    assert_equal("F00F:DEAD:BEEF::0001/128", cidr.cidr, "original CIDR preserved")
+  end
+
+  def test_init_ipv4
+    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/asdf/32") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/foomatic_wootmaster") }
+    assert_raise(IP::AddressException) { IP::CIDR.new("10.0.0.1/255") }
+
+    cidr = nil
+
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/32") } 
+    
+    assert_equal("10.0.0.1", cidr.ip.ip_address, "ipv4 data integrity test #1")
+    assert_equal(32, cidr.mask, "ipv4 data integrity test #2")
+    assert_equal("10.0.0.1/32", cidr.cidr, "ipv4 data integrity test #3")
+
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/255.255.255.255") }
+
+    assert_equal("10.0.0.1", cidr.ip.ip_address, "ipv4 data integrity test #4")
+    assert_equal(32, cidr.mask, "ipv4 data integrity test #5")
+    assert_equal("10.0.0.1/255.255.255.255", cidr.cidr, "ipv4 data integrity test #6")
+  end
+
+  def test_netmasks
+    cidr = nil 
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/32") }
+    assert_equal(32, cidr.short_netmask, "ipv4 netmask test #1")
+    assert_equal("255.255.255.255", cidr.long_netmask.ip_address, "ipv4 netmask test #2")
+    
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.1/255.255.255.248") }
+    assert_equal(29, cidr.short_netmask, "ipv4 netmask test #3")
+    assert_equal("255.255.255.248", cidr.long_netmask.ip_address, "ipv4 netmask test #4")
+
+    assert_nothing_raised() { cidr = IP::CIDR.new("F00F:DEAD::/16") }
+    assert_equal(16, cidr.short_netmask, "ipv6 has proper short netmask")
+    assert_raise(IP::AddressException) { cidr.long_netmask } 
+  end
+
+  def test_first_last
+    cidr = nil
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.2/24") }
+    assert_equal("10.0.0.0", cidr.first_ip.ip_address, "ipv4 first/last test #1")
+    assert_equal("10.0.0.255", cidr.last_ip.ip_address, "ipv4 first/last test #2")
+  end
+
+  def test_range
+    cidr = nil
+    assert_nothing_raised() { cidr = IP::CIDR.new("10.0.0.2/24") }
+    assert_equal(1, cidr.range.find_all { |x| x.ip_address == "10.0.0.1" }.length, "ipv4 range test #1")
+    assert_equal(0, cidr.range.find_all { |x| x.ip_address == "10.0.1.0" }.length, "ipv4 range test #2")
+
+    assert_nothing_raised() { cidr = IP::CIDR.new("::0001/120") }
+    assert_equal(1, cidr.range.find_all { |x| x.ip_address == "0:0:0:0:0:0:0:00FF" }.length, "ipv6 range test (included)")
+    assert_equal(0, cidr.range.find_all { |x| x.ip_address ==" 0:0:0:0:0:0:0:0F00" }.length, "ipv6 range test (not included)")
+  end
+
+  def test_overlaps
+    cidr, cidr2 = [nil, nil]
+    
+    assert_nothing_raised() do 
+      cidr = IP::CIDR.new("10.0.0.2/24")
+      cidr2 = IP::CIDR.new("10.0.0.1/29")
+    end
+
+    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #1")
+
+    assert_nothing_raised() { cidr2 = IP::CIDR.new("10.0.0.1/16") }
+
+    assert(cidr2.overlaps?(cidr), "ipv4 overlaps test #2")
+    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #3")
+
+    assert_nothing_raised() do 
+      cidr  = IP::CIDR.new("F00F:DEAD::/16")
+      cidr2 = IP::CIDR.new("F00F:BEEF::/16")
+    end 
+
+    assert(cidr.overlaps?(cidr2), "ipv6 #overlaps? reports correctly #1")
+    assert(cidr2.overlaps?(cidr), "ipv6 #overlaps? reports correctly #2")
+  end
+  
+  def test_includes
+    cidr, ip = [nil, nil]
+    assert_nothing_raised() do 
+      cidr = IP::CIDR.new("10.0.0.2/24")
+      ip = IP::Address::IPv4.new("10.0.0.1")
+    end
+
+    assert(cidr.includes?(ip), "ipv4 #includes? reports correctly (included)")
+    
+    assert_nothing_raised() { ip = IP::Address::IPv4.new("10.0.1.0") }
+
+    assert(!cidr.includes?(ip), "ipv4 #includes? reports correctly (not included)")
+   
+    assert_nothing_raised() do 
+      cidr = IP::CIDR.new("FF00::/16")
+      ip = IP::Address::IPv6.new("FF00::DEAD")
+    end
+    assert(cidr.includes?(ip), "ipv6 #includes? reports correctly (included)")
+    
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F000::DEAD") } 
+
+    assert(!cidr.includes?(ip), "ipv6 #includes? reports correctly (not included)")
+  end
+
+end
+
+class RangeTest < Test::Unit::TestCase
+  def name
+    return "IP::Range tests"
+  end
+
+  def test_range_generic
+    assert_raise(IP::AddressException) { IP::Range[Hash.new, ""] } 
+    assert_raise(IP::AddressException) { IP::Range["", Hash.new] } 
+    assert_raise(IP::AddressException) { IP::Range[IP::Address::IPv6.new("F00F::"), IP::Address::IPv4.new("10.0.0.1")]  }
+    assert_raise(IP::AddressException) { IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv6.new("F00F::")] } 
+  end
+
+  def test_range_ipv6
+    assert_nothing_raised() do 
+      IP::Range["::0001", "::00F0"] 
+      IP::Range[IP::Address::IPv6.new("::0001"), IP::Address::IPv6.new("::00F0")]
+    end
+
+    range = nil
+    
+    assert_nothing_raised() { range = IP::Range["::0001", "::0010"] } 
+    
+    assert_equal(1, range.find_all { |x| x.short_address == "::1" }.length, "ipv6 range check #1")
+    assert_equal(1, range.find_all { |x| x.short_address == "::0010" }.length, "ipv6 range check #2")
+    assert_equal(1, range.find_all { |x| x.short_address == "::000A" }.length, "ipv6 range check #3")
+    assert_equal(0, range.find_all { |x| x.short_address == "::0011" }.length, "ipv6 range check #4")
+  end
+
+  def test_range_ipv4
+    assert_nothing_raised() do 
+      IP::Range["10.0.0.1", "10.0.0.2"]
+      IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv4.new("10.0.0.2")]
+    end
+
+    range = nil
+    assert_nothing_raised() { range = IP::Range["10.0.0.1", "10.0.0.10"] }
+
+    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.1" }.length, "ipv4 range check #1")
+    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.10" }.length, "ipv4 range check #2")
+    assert_equal(1, range.find_all { |x| x.ip_address == "10.0.0.7" }.length, "ipv4 range check #3")
+    assert_equal(0, range.find_all { |x| x.ip_address == "10.0.0.11" }.length, "ipv4 range check #4")
+  end
+
+end
+
+class IPv6AddressTest < Test::Unit::TestCase
+  def name
+    return "IP::Address::IPv6 tests"
+  end
+  
+  def test_init
+    assert_nothing_raised() do
+      IP::Address::IPv6.new("0000:0000:0000:0000:0000:0000:0000:0001")
+      IP::Address::IPv6.new("::0001")
+      IP::Address::IPv6.new("FF00::")
+      IP::Address::IPv6.new("FF00::0001")
+      IP::Address::IPv6.new("FF00:BEEF::0001")
+      IP::Address::IPv6.new("FF00::BEEF:0001")
+      IP::Address::IPv6.new("::1.2.3.4")
+      IP::Address::IPv6.new("FFFF::1.2.3.4")
+      IP::Address::IPv6.new("FFFF:0000:0000:0000:0000:0000:1.2.3.4")
+    end
+    
+    # now, the tests that should fail
+
+    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00:BEEF:") } 
+    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00::BEEF::") } 
+    assert_raise(IP::AddressException) { IP::Address::IPv6.new("FF00::BEEF::DEAD") }
+    assert_raise(IP::AddressException) { IP::Address::IPv6.new("HF00::0001") }
+    assert_raise(IP::AddressException) { IP::Address::IPv6.new("1.2.3.4::0001") } 
+  end
+
+  def test_accessors
+    ip = nil
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF") } 
+
+    assert_equal(ip[0], ip.octet(0), "ip[0] eq ip.octet(0)")
+    assert_equal(61455, ip[0], "ip[0] is correct")
+    assert_equal("F00F", ip.octet_as_hex(0), "octet converts to hex properly")
+    assert_equal("F00F::DEAD:BEEF", ip.ip_address, '#ip_address preserves original address')
+  end
+
+  def test_address
+    ip = nil
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF") }
+    assert_equal("F00F::DEAD:BEEF", ip.short_address, 'wildcard left - #short_address returns a compressed version')
+    assert_equal("F00F:0:0:0:0:0:DEAD:BEEF", ip.long_address, 'wildcard left - #long_address returns the right thing')
+
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F:DEAD::BEEF") }
+    assert_equal("F00F:DEAD::BEEF", ip.short_address, 'wildcard right - #short_address returns a compressed version')
+    assert_equal("F00F:DEAD:0:0:0:0:0:BEEF", ip.long_address, 'wildcard right - #long_address returns the right thing')
+
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F:DEAD:0:0:0:0:0:BEEF") }
+    assert_equal("F00F:DEAD::BEEF", ip.short_address, 'no wildcard - #short_address returns a compressed version')
+    assert_equal("F00F:DEAD:0:0:0:0:0:BEEF", ip.long_address, 'no wildcard - #long_address returns the right thing')
+
+    assert_nothing_raised() { ip = IP::Address::IPv6.new("F00F::DEAD:BEEF:0:0") }
+    assert_equal("F00F:0:0:0:DEAD:BEEF::", ip.short_address, '#short_address returns a compressed version with wildcard @ right')
+  end
+
+end
+
+
+class IPv4AddressTest < Test::Unit::TestCase
+  def name
+    return "IP::Address::IPv4 tests"
+  end
+
+  def test_init
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new(Hash.new) } 
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new("asdf") }
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new("0.0.0") }
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new("256.255.255.255") } 
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new("255.255.255.255aaaa") }
+    assert_raise(IP::AddressException) { IP::Address::IPv4.new("255.255.255.") }
+  end
+  
+  def test_accessor
+    ip = nil
+    assert_nothing_raised() { ip = IP::Address::IPv4.new("10.1.2.3") }
+    assert_equal("10.1.2.3", ip.ip_address, "accessor test #1")
+    assert_equal(10, ip.octets[0], "accessor test #2")
+    assert_equal(3, ip.octets[3], "accessor test #3")
+    assert_equal(nil, ip.octets[4], "accessor test #4")
+   
+    assert_equal(ip.octet(1), ip[1],  "accessor test #5") 
+    assert_equal(1, ip[1], "accessor test #5") 
+
+    assert_raise(IP::BoundaryException) { ip[4] }
+  end
+
+end
+
+class UtilTest < Test::Unit::TestCase
+  def name
+    return "IP::Address::Util tests"
+  end
+  
+  def test_pack_unpack
+    address = "10.0.0.1"
+    assert_equal("10.0.0.1", IP::Address::Util.unpack(IP::Address::Util.pack(IP::Address::IPv4.new(address))).ip_address, "pack/unpack test")
+  end
+  
+  def test_short_netmask
+    ip = nil
+    assert_nothing_raised() { ip = IP::Address::IPv4.new("255.255.255.255") }
+    assert_equal(32, IP::Address::Util.short_netmask(ip), "Short Netmask Test #1")
+    assert_nothing_raised() { ip = IP::Address::IPv4.new("255.255.255.248") }
+    assert_equal(29, IP::Address::Util.short_netmask(ip), "Short Netmask Test #2")
+  end
+
+  def test_long_netmask
+    assert_equal("255.255.255.255", IP::Address::Util.long_netmask_ipv4(32).ip_address, "Long Netmask Test #1")
+    assert_equal("255.255.255.248", IP::Address::Util.long_netmask_ipv4(29).ip_address, "Long Netmask Test #2")
+  end
+
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: ip
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
-date: 2006-04-20 00:00:00 -07:00
+  version: 0.2.2
+date: 2008-11-02 00:00:00 -07:00
 summary: Ruby classes to work with IP address, ranges, and netmasks
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: erik@hollensbe.org
 homepage: 
 rubyforge_project: ip-address
 description: 
-autorequire: ip
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -25,20 +25,22 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Erik Hollensbe
 files: 
+- Rakefile
 - examples/check-included.rb
-- examples/check-overlap.rb
 - examples/generate-a-records.rb
+- examples/check-overlap.rb
 - lib/ip.rb
-- test/ip.rb
-- lib/ip/address.rb
+- test/test_ip.rb
 - lib/ip/cidr.rb
-- lib/ip/range.rb
 - lib/ip/util.rb
-test_files: 
-- test/ip.rb
+- lib/ip/address.rb
+- lib/ip/range.rb
+test_files: []
+
 rdoc_options: []
 
 extra_rdoc_files: []

data/test/ip.rb

@@ -1,603 +0,0 @@
-require 'test/unit'
-load 'lib/ip.rb'
-
-class CIDRTest < Test::Unit::TestCase
-
-  def name
-    return "IP::CIDR tests"
-  end
-
-  def test_init_generic
-    a = nil
-
-    begin
-      IP::CIDR.new(Hash.new)
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "only accepts string")
-
-    begin
-      IP::CIDR.new("foomatic_wootmaster/32")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-    
-    assert(a, "ensures we have a IP address")
-  end
-
-  def test_init_ipv6
-    a = nil
-
-    begin
-      IP::CIDR.new("F00F:DEAD:BEEF::")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "no subnet")
-
-    begin
-      IP::CIDR.new("F00F:DEAD:BEEF::/")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "subnet marker, no integer")
-    
-    begin
-      IP::CIDR.new("F00F:DEAD:BEEF::/asdf/32")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "'two' subnets")
-  
-    begin
-      IP::CIDR.new("F00F:DEAD:BEEF::/foomatic_wootmaster")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "junk subnet")
-
-    begin
-      IP::CIDR.new("F00F:DEAD:BEEF::/255.255.255.255")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "ipv4 long subnet on ipv6")
-
-    cidr = IP::CIDR.new("F00F:DEAD:BEEF::0001/128")
-
-    # this sort of indirectly tests the ipv6 address manipulation.
-    assert(cidr.ip.short_address == "F00F:DEAD:BEEF::1", "ipv6 object constructed clean")
-    assert(cidr.mask == 128, "mask is set properly")
-    assert(cidr.cidr == "F00F:DEAD:BEEF::0001/128", "original CIDR preserved")
-  end
-
-  def test_init_ipv4
-    a = nil
-    
-    begin
-      IP::CIDR.new("10.0.0.1")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-    
-    assert(a, "ipv4 data validation test #1")
-    
-    begin
-      IP::CIDR.new("10.0.0.1/")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-    
-    assert(a, "ipv4 data validation test #2")
-    
-    begin
-      IP::CIDR.new("10.0.0.1/asdf/32")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "ipv4 data validation test #3")
-    
-    begin
-      IP::CIDR.new("10.0.0.1/foomatic_wootmaster")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "ipv4 data validation test #4")
-
-    begin
-      IP::CIDR.new("10.0.0.1/255")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "ipv4 data validation test #5")
-
-    cidr = IP::CIDR.new("10.0.0.1/32")
-    
-    assert(cidr.ip.ip_address == "10.0.0.1", "ipv4 data integrity test #1")
-    assert(cidr.mask == 32, "ipv4 data integrity test #2")
-    assert(cidr.cidr == "10.0.0.1/32", "ipv4 data integrity test #3")
-
-    cidr = IP::CIDR.new("10.0.0.1/255.255.255.255")
-
-    assert(cidr.ip.ip_address == "10.0.0.1", "ipv4 data integrity test #4")
-    assert(cidr.mask == 32, "ipv4 data integrity test #5")
-    assert(cidr.cidr == "10.0.0.1/255.255.255.255", "ipv4 data integrity test #6")
-  end
-
-  def test_netmasks
-    a = nil
-    
-    cidr = IP::CIDR.new("10.0.0.1/32")
-    assert(cidr.short_netmask == 32, "ipv4 netmask test #1")
-    assert(cidr.long_netmask.ip_address == "255.255.255.255", "ipv4 netmask test #2")
-
-    cidr = IP::CIDR.new("10.0.0.1/255.255.255.248")
-    assert(cidr.short_netmask == 29, "ipv4 netmask test #3")
-    assert(cidr.long_netmask.ip_address == "255.255.255.248", "ipv4 netmask test #4")
-
-    cidr = IP::CIDR.new("F00F:DEAD::/16")
-    assert(cidr.short_netmask == 16, "ipv6 has proper short netmask")
-
-    begin
-      cidr.long_netmask
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "ipv6 cannot use a long netmask")
-  end
-
-  def test_first_last
-    cidr = IP::CIDR.new("10.0.0.2/24")
-    assert(cidr.first_ip.ip_address == "10.0.0.0", "ipv4 first/last test #1")
-    assert(cidr.last_ip.ip_address == "10.0.0.255", "ipv4 first/last test #2")
-  end
-
-  def test_range
-    cidr = IP::CIDR.new("10.0.0.2/24")
-    assert(cidr.range.find_all { |x| x.ip_address == "10.0.0.1" }.length == 1, "ipv4 range test #1")
-    assert(cidr.range.find_all { |x| x.ip_address == "10.0.1.0" }.length == 0, "ipv4 range test #2")
-
-    cidr = IP::CIDR.new("::0001/120")
-    assert(cidr.range.find_all { |x| x.ip_address == "0:0:0:0:0:0:0:00FF" }.length == 1, "ipv6 range test (included)")
-    assert(cidr.range.find_all { |x| x.ip_address ==" 0:0:0:0:0:0:0:0F00"    }.length == 0, "ipv6 range test (not included)")
-  end
-
-  def test_overlaps
-    cidr = IP::CIDR.new("10.0.0.2/24")
-    cidr2 = IP::CIDR.new("10.0.0.1/29")
-
-    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #1")
-
-    cidr2 = IP::CIDR.new("10.0.0.1/16")
-
-    assert(cidr2.overlaps?(cidr), "ipv4 overlaps test #2")
-    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #3")
-
-    cidr  = IP::CIDR.new("F00F:DEAD::/16")
-    cidr2 = IP::CIDR.new("F00F:BEEF::/16")
-
-    assert(cidr.overlaps?(cidr2), "ipv6 #overlaps? reports correctly #1")
-    assert(cidr2.overlaps?(cidr), "ipv6 #overlaps? reports correctly #2")
-  end
-  
-  def test_includes
-    cidr = IP::CIDR.new("10.0.0.2/24")
-    ip = IP::Address::IPv4.new("10.0.0.1")
-
-    assert(cidr.includes?(ip), "ipv4 #includes? reports correctly (included)")
-    ip = IP::Address::IPv4.new("10.0.1.0")
-    assert(!cidr.includes?(ip), "ipv4 #includes? reports correctly (not included)")
-    
-    cidr = IP::CIDR.new("FF00::/16")
-    ip = IP::Address::IPv6.new("FF00::DEAD")
-    assert(cidr.includes?(ip), "ipv6 #includes? reports correctly (included)")
-    ip = IP::Address::IPv6.new("F000::DEAD")
-    assert(!cidr.includes?(ip), "ipv6 #includes? reports correctly (not included)")
-  end
-
-end
-
-class RangeTest < Test::Unit::TestCase
-  def name
-    return "IP::Range tests"
-  end
-
-  def test_range_generic
-    a = nil
-    begin
-      IP::Range[Hash.new, ""]
-      a = false
-    rescue Exception => e
-      a = true
-    end
-
-    assert(a, "generic data types test #1")
-
-    begin
-      IP::Range["", Hash.new]
-      a = false
-    rescue Exception => e
-      a = true
-    end
-
-    assert(a, "generic data types test #2")
-    
-    begin
-      IP::Range[IP::Address::IPv6.new("F00F::"), IP::Address::IPv4.new("10.0.0.1")]
-      a = false
-    rescue Exception => e
-      a = true
-    end
-
-    assert(a, "generic data types test #3")
-    
-    begin
-      IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv6.new("F00F::")]
-      a = false
-    rescue Exception => e
-      a = true
-    end
-
-    assert(a, "generic data types test #4")
-  end
-
-  def test_range_ipv6
-    a = nil
-    
-    begin 
-      IP::Range["::0001", "::00F0"]
-      a = true
-    rescue Exception => e
-      a = false
-    end
-
-    assert(a, "ipv6 data types test #1")
-    
-    begin
-      IP::Range[IP::Address::IPv6.new("::0001"), IP::Address::IPv6.new("::00F0")]
-      a = true
-    rescue Exception => e
-      a = false
-    end
-
-    assert(a, "ipv6 data types test #2")
-
-    range = IP::Range["::0001", "::0010"]
-
-    assert(range.find_all { |x| x.short_address == "::1" }.length == 1, "ipv6 range check #1")
-    assert(range.find_all { |x| x.short_address == "::0010" }.length == 1, "ipv6 range check #2")
-    assert(range.find_all { |x| x.short_address == "::000A" }.length == 1, "ipv6 range check #3")
-    assert(range.find_all { |x| x.short_address == "::0011" }.length == 0, "ipv6 range check #4")
-  end
-
-  def test_range_ipv4
-    a = nil
-    begin
-      IP::Range["10.0.0.1", "10.0.0.2"]
-      a = true
-    rescue Exception => e
-      a = false
-    end
-    
-    assert(a, "ipv4 data types test #1")
-    
-    begin
-      IP::Range[IP::Address::IPv4.new("10.0.0.1"), IP::Address::IPv4.new("10.0.0.2")]
-      a = true
-    rescue Exception => e
-      a = false
-    end
-
-    assert(a, "ipv4 data types test #2")
-
-    range = IP::Range["10.0.0.1", "10.0.0.10"]
-
-    assert(range.find_all { |x| x.ip_address == "10.0.0.1" }.length == 1, "ipv4 range check #1")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.10" }.length == 1, "ipv4 range check #2")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.7" }.length == 1, "ipv4 range check #3")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.11" }.length == 0, "ipv4 range check #4")
-  end
-
-end
-
-class IPv6AddressTest < Test::Unit::TestCase
-  def name
-    return "IP::Address::IPv6 tests"
-  end
-  
-  def test_init
-    a = nil
-    
-    # test the good data first...
-
-    begin
-      IP::Address::IPv6.new("0000:0000:0000:0000:0000:0000:0000:0001")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "full address")
-
-    begin
-      IP::Address::IPv6.new("::0001")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "wildcard address, wildcard left")
-
-    begin
-      IP::Address::IPv6.new("FF00::")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "wildcard address, wildcard right")
-
-    begin
-      IP::Address::IPv6.new("FF00::0001")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "wildcard address, wildcard center")
-
-    begin
-      IP::Address::IPv6.new("FF00:BEEF::0001")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "wildcard address, wildcard center with two leading")
-
-    begin
-      IP::Address::IPv6.new("FF00::BEEF:0001")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "wildcard address, wildcard center with two trailing")
-
-    begin
-      IP::Address::IPv6.new("::1.2.3.4")
-      a = true
-    rescue IP::AddressException => e
-      puts e
-      a = false
-    end
-
-    assert(a, "IPv4 address in IPv6, wildcard left")
-
-    begin
-      IP::Address::IPv6.new("FFFF::1.2.3.4")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-
-    assert(a, "IPv4 in IPv6, data on wildcard @ left")
-
-    begin
-      IP::Address::IPv6.new("FFFF:0000:0000:0000:0000:0000:1.2.3.4")
-      a = true
-    rescue IP::AddressException => e
-      a = false
-    end
-    
-    assert(a, "IPv4 in IPv6, no wildcard")
-
-    # now, the tests that should fail
-    
-    begin
-      IP::Address::IPv6.new("FF00:BEEF:")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "not enough octets")
-
-    begin
-      IP::Address::IPv6.new("FF00::BEEF::")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "double wildcard no trailer")
-
-    begin
-      IP::Address::IPv6.new("FF00::BEEF::DEAD")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "double wildcard w/ trailer")
-
-    begin
-      IP::Address::IPv6.new("HF00::0001")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "invalid hexidecimal")
-    
-    begin
-      IP::Address::IPv6.new("1.2.3.4::0001")
-      a = false
-    rescue IP::AddressException => e
-      a = true
-    end
-
-    assert(a, "invalid IPv4 in IPv6")
-
-  end
-
-  def test_accessors
-    ip = IP::Address::IPv6.new("F00F::DEAD:BEEF")
-
-    assert(ip[0] == 61455 && ip.octet(0) == 61455, "#octet is integer representation, #[] is #octet")
-    assert(ip.octet_as_hex(0) == "F00F", "octet converts to hex properly")
-    assert(ip.ip_address == "F00F::DEAD:BEEF", '#ip_address preserves original address')
-  end
-
-  def test_address
-    ip = IP::Address::IPv6.new("F00F::DEAD:BEEF")
-    assert(ip.short_address == "F00F::DEAD:BEEF", 'wildcard left - #short_address returns a compressed version')
-    assert(ip.long_address == "F00F:0:0:0:0:0:DEAD:BEEF", 'wildcard left - #long_address returns the right thing')
-
-    ip = IP::Address::IPv6.new("F00F:DEAD::BEEF")
-    assert(ip.short_address == "F00F:DEAD::BEEF", 'wildcard right - #short_address returns a compressed version')
-    assert(ip.long_address == "F00F:DEAD:0:0:0:0:0:BEEF", 'wildcard right - #long_address returns the right thing')
-
-    ip = IP::Address::IPv6.new("F00F:DEAD:0:0:0:0:0:BEEF")
-    assert(ip.short_address == "F00F:DEAD::BEEF", 'no wildcard - #short_address returns a compressed version')
-    assert(ip.long_address == "F00F:DEAD:0:0:0:0:0:BEEF", 'no wildcard - #long_address returns the right thing')
-
-    ip = IP::Address::IPv6.new("F00F::DEAD:BEEF:0:0")
-    assert(ip.short_address == "F00F:0:0:0:DEAD:BEEF::", '#short_address returns a compressed version with wildcard @ right')
-  end
-
-end
-
-
-class IPv4AddressTest < Test::Unit::TestCase
-  def name
-    return "IP::Address::IPv4 tests"
-  end
-
-  def test_init
-    ip = nil
-    begin
-      ip = IP::Address::IPv4.new(Hash.new)
-    rescue IP::AddressException => e
-      assert(true, "init test #1")
-    end
-
-    assert(false, "init test #2") if ip
-
-    ip = nil
-
-    begin
-      ip = IP::Address::IPv4.new("asdf")
-    rescue IP::AddressException => e
-      assert(true, "init test #2")
-    end
-
-    assert(false, "init test #2") if ip
-    ip = nil
-
-    begin
-      ip = IP::Address::IPv4.new("0.0.0")
-    rescue IP::AddressException => e
-      assert(true, "init test #3")
-    end
-
-    assert(false, "init test #3") if ip
-    ip = nil
-    
-    begin
-      ip = IP::Address::IPv4.new("256.255.255.255")
-    rescue IP::AddressException => e
-      assert(true, "init test #4")
-    end
-
-    assert(false, "init test #4") if ip
-
-    ip = nil
-    begin
-      ip = IP::Address::IPv4.new("255.255.255.255aaaa")
-    rescue IP::AddressException => e
-      assert(true, "init test #5")
-    end
-
-    assert(false, "init test #5") if ip
-
-    ip = nil
-    begin
-      ip = IP::Address::IPv4.new("255.255.255.")
-    rescue IP::AddressException => e
-      assert(true, "init test #6")
-    end
-
-    assert(false, "init test #6") if ip
-
-  end
-  
-  def test_accessor
-    ip = IP::Address::IPv4.new("10.1.2.3")
-    assert(ip.ip_address == "10.1.2.3", "accessor test #1")
-    assert(ip.octets[0] == 10, "accessor test #2")
-    assert(ip.octets[3] == 3, "accessor test #3")
-    assert(ip.octets[4] == nil, "accessor test #4")
-    
-    assert(ip.octet(1) == ip[1] && ip[1] == 1, "accessor test #5")
-
-    oct = nil
-
-    begin
-      oct = ip[4]
-    rescue IP::BoundaryException => e
-      assert(true, "accessor test #6")
-    end
-    
-    assert(false, "accessor test #6") if oct
-  end
-
-end
-
-class UtilTest < Test::Unit::TestCase
-  def name
-    return "IP::Address::Util tests"
-  end
-  
-  def test_pack_unpack
-    address = "10.0.0.1"
-    assert(IP::Address::Util.unpack(IP::Address::Util.pack(IP::Address::IPv4.new(address))).ip_address == address, "pack/unpack test")
-  end
-  
-  def test_short_netmask
-    ip = IP::Address::IPv4.new("255.255.255.255")
-    assert(IP::Address::Util.short_netmask(ip) == 32, "Short Netmask Test #1")
-    ip = IP::Address::IPv4.new("255.255.255.248")
-    assert(IP::Address::Util.short_netmask(ip) == 29, "Short Netmask Test #2")
-  end
-
-  def test_long_netmask
-    assert(IP::Address::Util.long_netmask_ipv4(32).ip_address == "255.255.255.255", "Long Netmask Test #1")
-    assert(IP::Address::Util.long_netmask_ipv4(29).ip_address == "255.255.255.248", "Long Netmask Test #2")
-  end
-
-end