ip 0.1.1 → 0.2.0

data/lib/ip/range.rb

@@ -0,0 +1,54 @@
+#
+# IP::Range - Calculates a range of IP addresses, and returns an
+# Array of IP::Address objects.
+#
+# Usage::
+#
+# IP::Range['10.0.0.1', '10.0.0.2'] => IP::Address objects between
+# 10.0.0.1 and 10.0.0.2 (inclusive)
+#
+# IP::Range can also take two IP::Address objects.
+#
+# Will throw a IP::AddressException if for some reason addresses
+# cannot be parsed.
+#
+
+class IP::Range
+  
+  #
+  # See the documentation for IP::Range for more information on this
+  # method.
+  #
+  
+  def self.[](addr1, addr2)
+    raw1, raw2 = [nil, nil]
+    tmpip = nil
+    
+    if addr1.kind_of? String
+      addr1 = IP::Address::Util.string_to_ip(addr1)
+    elsif ! addr1.kind_of? IP::Address
+      raise IP::AddressException.new("IP Address is not type String or IP::Address")
+    end
+    
+    if addr2.kind_of? String
+      addr2 = IP::Address::Util.string_to_ip(addr2)
+    elsif ! addr2.kind_of? IP::Address
+      raise IP::AddressException.new("IP Address is not type String or IP::Address")
+    end
+
+    if addr2.class.name != addr1.class.name
+      raise IP::AddressException.new("First and Second IP in range are not of the same type")
+    end
+    
+    raw1 = addr1.pack
+    raw2 = addr2.pack
+
+    range = []
+    
+    # use the class we were given to force certain results, instead
+    # of relying on the fairly inaccurate unpack facility.
+    range = (raw1..raw2).collect { |x| addr1.class.new(x) }
+
+    return range
+  end
+end

data/lib/ip/util.rb

@@ -0,0 +1,144 @@
+#
+# General utility functions used by other IP classes.
+#
+
+module IP::Address::Util
+  #
+  # Pack an object into a long integer used for calculation. Returns a
+  # 'FixNum' type. Can take both IP::Address::IPv4 and
+  # IP::Address::IPv6 objects.
+  #
+  
+  def pack(ip)
+    return ip.pack
+  end
+  
+  module_function :pack
+  
+  #
+  # This routine takes an array of integers which are intended to be
+  # an IP address, and joins them into a single integer used for easy
+  # calculation.
+  #
+  # IPv4 and IPv6 objects are packed into the same size, a 128-bit
+  # integer. This is done for easier processing within the library.
+  #
+  
+  def raw_pack(array)
+    ret = 0
+    myip = array.reverse
+    8.times { |x| ret = ret | myip[x] << 16*x }
+    return ret
+  end
+  
+  module_function :raw_pack
+  
+  #
+  # Take an 'Integer' type and return an IP::Address object.
+  #
+  # This routine will 'guess' at what version of IP addressing you
+  # want, returning the oldest type possible (IPv4 addresses will
+  # return IP::Address::IPv4 objects).
+  #
+  # In almost all cases, you'll want to use the type-specific
+  # routines, which merely involve passing an Integer to the
+  # constructor for each class.
+  #
+  def unpack(ip)
+    ret = raw_unpack(ip)
+    
+    # any IPv6 address should meet this criteria.
+    if ret[2..8].any? { |x| x > 0 }
+      return IP::Address::IPv6.new(ip)
+    end
+    
+    return IP::Address::IPv4.new(ip)
+  end
+  
+  module_function :unpack
+ 
+  #
+  # Take a 'FixNum' and return it's in-place octet
+  # representation. This is mostly a helper method for the unpack
+  # routines.
+  #
+  
+  def raw_unpack(ip)
+    ret = []
+    8.times { |x| ret.push((ip >> 16*x) & 0xFFFF) }
+    return ret
+  end
+  
+  module_function :raw_unpack
+  
+  #
+  # Returns a short subnet mask - works for all IP::Address objects.
+  #
+  # ex:
+  # short_netmask(IP::Address::IPv4.new("255.255.255.255")) => 32
+  # short_netmask(IP::Address::IPv6.new("2001:0DB8:0000:CD30:0000:0000:0000:0000")) => 60
+  #
+  
+  def short_netmask(ip)
+    #
+    # This method handles 128-bit integers better for both types of
+    # addresses, even though it is a bit slower.
+    #
+    # TODO: there really is probably a better way to do this.
+    #
+ 
+    s = ip.pack.to_s(2)
+
+    pad = 0
+
+    case ip.class.object_id
+    when IP::Address::IPv6.object_id
+      pad = 128
+    when IP::Address::IPv4.object_id
+      pad = 32
+    end
+
+    s = ("0" * (pad - s.length)) + s
+
+    return s.rindex("1") + 1
+  end
+  
+  module_function :short_netmask
+  
+  def long_netmask(short)
+    warn "This function is deprecated, please use IP::Address::Util.long_netmask_ipv4 instead."
+    return long_netmask_ipv4(short)
+  end
+  
+  module_function :long_netmask
+  
+  #
+  # Given a CIDR-notation "short" netmask, returns a IP::Address object containing
+  # the equivalent "long" netmask.
+  #
+  # ex:
+  # long_netmask(32) => IP::Address object of "255.255.255.255"
+  # long_netmask(28) => IP::Address object of "255.255.255.240"
+  #
+  
+  def long_netmask_ipv4(short)
+    raw = (0xFFFFFFFF << (32 - short)) & 0xFFFFFFFF
+    return IP::Address::Util.unpack(raw)
+  end
+  
+  module_function :long_netmask_ipv4
+  
+  #
+  # This takes a string which supposedly contains an IP address, and
+  # tries to figure out if it is a IPv6 or IPv4 address. Returns a
+  # constructed object of the proper type.
+  #
+
+  def string_to_ip(s)
+    return IP::Address::IPv6.new(s) if s.match(/:/)
+    return IP::Address::IPv4.new(s)
+  end
+
+  module_function :string_to_ip
+
+end

data/test/ip.rb

@@ -7,8 +7,9 @@ class CIDRTest < Test::Unit::TestCase
     return "IP::CIDR tests"
   end
 
-  def test_init
+  def test_init_generic
     a = nil
+
     begin
       IP::CIDR.new(Hash.new)
       a = false
@@ -16,52 +17,112 @@ class CIDRTest < Test::Unit::TestCase
       a = true
     end
 
-    assert(a, "data types test #1")
+    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("10.0.0.1")
+      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")
     
-    assert(a, "data types test #2")
+    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/")
+      IP::CIDR.new("10.0.0.1")
       a = false
     rescue IP::AddressException => e
       a = true
     end
     
-    assert(a, "data types test #3")
+    assert(a, "ipv4 data validation test #1")
     
     begin
-      IP::CIDR.new("10.0.0.1/asdf/32")
+      IP::CIDR.new("10.0.0.1/")
       a = false
     rescue IP::AddressException => e
       a = true
     end
-
-    assert(a, "data type test #4")
+    
+    assert(a, "ipv4 data validation test #2")
     
     begin
-      IP::CIDR.new("10.0.0.1/foomatic_wootmaster")
+      IP::CIDR.new("10.0.0.1/asdf/32")
       a = false
     rescue IP::AddressException => e
       a = true
     end
 
-    assert(a, "data types test #5")
-
+    assert(a, "ipv4 data validation test #3")
+    
     begin
-      IP::CIDR.new("foomatic_wootmaster/32")
+      IP::CIDR.new("10.0.0.1/foomatic_wootmaster")
       a = false
     rescue IP::AddressException => e
       a = true
     end
-    
-    assert(a, "data types test #6")
+
+    assert(a, "ipv4 data validation test #4")
 
     begin
       IP::CIDR.new("10.0.0.1/255")
@@ -70,54 +131,94 @@ class CIDRTest < Test::Unit::TestCase
       a = true
     end
 
-    assert(a, "data types test #7")
+    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", "data integrity test #1")
-    assert(cidr.mask == 32, "data integrity test #2")
-    assert(cidr.cidr == "10.0.0.1/32", "data integrity test #3")
+    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", "data integrity test #4")
-    assert(cidr.mask == 32, "data integrity test #5")
-    assert(cidr.cidr == "10.0.0.1/255.255.255.255", "data integrity test #6")
+    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
-    cidr = IP::CIDR.new("10.0.0.1/32")
-    assert(cidr.short_netmask == 32, "netmask test #1")
-    assert(cidr.long_netmask.ip_address == "255.255.255.255", "netmask test #2")
+    a = nil
     
-    cidr = IP::CIDR.new("10.0.0.1/255.255.255.241")
-    assert(cidr.short_netmask == 29, "netmask test #3")
-    assert(cidr.long_netmask.ip_address == "255.255.255.248", "netmask test #4")
+    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", "first/last test #1")
-    assert(cidr.last_ip.ip_address == "10.0.0.255", "first/last test #2")
+    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, "range test #1")
-    assert(cidr.range.find_all { |x| x.ip_address == "10.0.1.0" }.length == 0, "range test #2")
+    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), "overlaps test #1")
+    assert(cidr.overlaps?(cidr2), "ipv4 overlaps test #1")
 
     cidr2 = IP::CIDR.new("10.0.0.1/16")
 
-    assert(cidr2.overlaps?(cidr), "overlaps test #2")
-    assert(cidr.overlaps?(cidr2), "overlaps test #3")
+    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
@@ -125,7 +226,75 @@ class RangeTest < Test::Unit::TestCase
     return "IP::Range tests"
   end
 
-  def test_range
+  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"]
@@ -134,37 +303,205 @@ class RangeTest < Test::Unit::TestCase
       a = false
     end
     
-    assert(a, "data types test #1")
+    assert(a, "ipv4 data types test #1")
     
     begin
-      IP::Range[IP::Address.new("10.0.0.1"), IP::Address.new("10.0.0.2")]
+      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, "data types test #2")
+    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, "range check #1")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.10" }.length == 1, "range check #2")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.7" }.length == 1, "range check #3")
-    assert(range.find_all { |x| x.ip_address == "10.0.0.11" }.length == 0, "range check #4")
+    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 AddressTest < Test::Unit::TestCase
+
+class IPv4AddressTest < Test::Unit::TestCase
   def name
-    return "IP::Address tests"
+    return "IP::Address::IPv4 tests"
   end
 
   def test_init
     ip = nil
     begin
-      ip = IP::Address.new(Hash.new)
+      ip = IP::Address::IPv4.new(Hash.new)
     rescue IP::AddressException => e
       assert(true, "init test #1")
     end
@@ -174,7 +511,7 @@ class AddressTest < Test::Unit::TestCase
     ip = nil
 
     begin
-      ip = IP::Address.new("asdf")
+      ip = IP::Address::IPv4.new("asdf")
     rescue IP::AddressException => e
       assert(true, "init test #2")
     end
@@ -183,7 +520,7 @@ class AddressTest < Test::Unit::TestCase
     ip = nil
 
     begin
-      ip = IP::Address.new("0.0.0")
+      ip = IP::Address::IPv4.new("0.0.0")
     rescue IP::AddressException => e
       assert(true, "init test #3")
     end
@@ -192,7 +529,7 @@ class AddressTest < Test::Unit::TestCase
     ip = nil
     
     begin
-      ip = IP::Address.new("256.255.255.255")
+      ip = IP::Address::IPv4.new("256.255.255.255")
     rescue IP::AddressException => e
       assert(true, "init test #4")
     end
@@ -201,7 +538,7 @@ class AddressTest < Test::Unit::TestCase
 
     ip = nil
     begin
-      ip = IP::Address.new("255.255.255.255aaaa")
+      ip = IP::Address::IPv4.new("255.255.255.255aaaa")
     rescue IP::AddressException => e
       assert(true, "init test #5")
     end
@@ -210,7 +547,7 @@ class AddressTest < Test::Unit::TestCase
 
     ip = nil
     begin
-      ip = IP::Address.new("255.255.255.")
+      ip = IP::Address::IPv4.new("255.255.255.")
     rescue IP::AddressException => e
       assert(true, "init test #6")
     end
@@ -220,7 +557,7 @@ class AddressTest < Test::Unit::TestCase
   end
   
   def test_accessor
-    ip = IP::Address.new("10.1.2.3")
+    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")
@@ -248,46 +585,19 @@ class UtilTest < Test::Unit::TestCase
   
   def test_pack_unpack
     address = "10.0.0.1"
-    assert(IP::Address::Util.unpack(IP::Address::Util.pack(IP::Address.new(address))).ip_address == address, "pack/unpack test")
+    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.new("255.255.255.255")
+    ip = IP::Address::IPv4.new("255.255.255.255")
     assert(IP::Address::Util.short_netmask(ip) == 32, "Short Netmask Test #1")
-    ip = IP::Address.new("255.255.255.241")
+    ip = IP::Address::IPv4.new("255.255.255.248")
     assert(IP::Address::Util.short_netmask(ip) == 29, "Short Netmask Test #2")
-    
-    nm = nil
-
-    begin
-      nm = IP::Address::Util.short_netmask(IP::Address.new("255.255.0.255"))
-    rescue IP::BoundaryException => e
-      assert(true, "Short Netmask BoundaryException Check #1")
-    end
-
-    assert(false, "Short Netmask BoundaryException Check #1") if nm
-    
-    nm = nil
-
-    begin
-      nm = IP::Address::Util.short_netmask(IP::Address.new("255.255.240.255"))
-    rescue IP::BoundaryException => e
-      assert(true, "Short Netmask BoundaryException check #2")
-    end
-    
-    assert(false, "Short Netmask BoundaryException check #2") if nm
   end
 
   def test_long_netmask
-    assert(IP::Address::Util.long_netmask(32).ip_address == "255.255.255.255", "Long Netmask Test #1")
-    assert(IP::Address::Util.long_netmask(29).ip_address == "255.255.255.248", "Long Netmask Test #2")
-  end
-
-  def test_binary_vector
-    assert(IP::Address::Util.binary_vector(255).length == 8, "Binary Vector Test #1")
-    assert(IP::Address::Util.binary_vector(240).find_all { |x| x == 1 }.length == 4, "Binary Vector Test #2")
-    assert(IP::Address::Util.binary_vector(241).find_all { |x| x == 1 }.length == 5, "Binary Vector Test #3")
-    assert(IP::Address::Util.binary_vector(240)[0] == 1, "Binary Vector Test #4")
+    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