netaddr 1.1.0 → 1.2.0

data/lib/validation_shortcuts.rb

@@ -0,0 +1,219 @@
+module NetAddr
+private
+
+#==============================================================================#
+# validate_args()
+#==============================================================================#
+
+# validate options hash 
+#
+def validate_args(to_validate,known_args)
+    to_validate.each do |x|
+        raise ArgumentError, "Unrecognized argument #{x}. Valid arguments are " +
+                             "#{known_args.join(',')}" if (!known_args.include?(x))
+    end
+end 
+module_function :validate_args
+
+#==============================================================================#
+# validate_ip_int()
+#==============================================================================#
+
+def validate_ip_int(ip,version)
+    version = 4 if (!version && ip < 2**32)
+    if (version == 4)
+        raise ValidationError, "#{ip} is invalid for IPv4 (Integer is out of bounds)." if ( (ip < 0) || (ip > 2**32-1) )
+    else
+        raise ValidationError, "#{ip} is invalid for both IPv4 and IPv6 (Integer is out of bounds)." if ( (ip < 0) || (ip > 2**128-1) )
+        version = 6
+    end
+    return(version)
+end
+module_function :validate_ip_int
+
+#==============================================================================#
+# validate_ip_str()
+#==============================================================================#
+
+def validate_ip_str(ip,version)
+    # check validity of charaters
+    if (ip =~ /[^0-9a-fA-F\.:]/)
+        raise ValidationError, "#{ip} is invalid (contains invalid characters)."
+    end
+
+    if (version == 4)
+        octets = ip.split('.')
+        raise ValidationError, "#{ip} is invalid (IPv4 requires (4) octets)." if (octets.length != 4)
+
+        # are octets in range 0..255?
+        octets.each do |octet|
+            raise ValidationError, "#{ip} is invalid (IPv4 dotted-decimal format " +
+                                   "should not contain non-numeric characters)." if (octet =~ /[\D]/ || octet == '')
+            octet = octet.to_i()
+            if ( (octet < 0) || (octet >= 256) )
+                raise ValidationError, "#{ip} is invalid (IPv4 octets should be between 0 and 255)."
+            end
+        end
+
+    else
+            # make sure we only have at most (2) colons in a row, and then only
+            # (1) instance of that
+            if ( (ip =~ /:{3,}/) || (ip.split("::").length > 2) )
+                raise ValidationError, "#{ip} is invalid (IPv6 field separators (:) are bad)."
+            end
+
+            # set flags
+            shorthand = false
+            if (ip =~ /\./)
+                dotted_dec = true 
+            else
+                dotted_dec = false
+            end
+
+            # split up by ':'
+            fields = []
+            if (ip =~ /::/)
+                shorthand = true
+                ip.split('::').each do |x|
+                    fields.concat( x.split(':') )
+                end
+            else
+               fields.concat( ip.split(':') ) 
+            end
+
+            # make sure we have the correct number of fields
+            if (shorthand)
+                if ( (dotted_dec && fields.length > 6) || (!dotted_dec && fields.length > 7) )
+                    raise ValidationError, "#{ip} is invalid (IPv6 shorthand notation has " +
+                                           "incorrect number of fields)." 
+                end
+            else
+                if ( (dotted_dec && fields.length != 7 ) || (!dotted_dec && fields.length != 8) )
+                    raise ValidationError, "#{ip} is invalid (IPv6 address has " +
+                                           "incorrect number of fields)." 
+                end
+            end
+
+            # if dotted_dec then validate the last field
+            if (dotted_dec)
+                dotted = fields.pop()
+                octets = dotted.split('.')
+                raise ValidationError, "#{ip} is invalid (Legacy IPv4 portion of IPv6 " +
+                                       "address should contain (4) octets)." if (octets.length != 4)
+                octets.each do |x|
+                    raise ValidationError, "#{ip} is invalid (egacy IPv4 portion of IPv6 " +
+                                           "address should not contain non-numeric characters)." if (x =~ /[^0-9]/ )
+                    x = x.to_i
+                    if ( (x < 0) || (x >= 256) )
+                        raise ValidationError, "#{ip} is invalid (Octets of a legacy IPv4 portion of IPv6 " +
+                                               "address should be between 0 and 255)."
+                    end
+                end
+            end
+
+            # validate hex fields
+            fields.each do |x|
+                if (x =~ /[^0-9a-fA-F]/)
+                    raise ValidationError, "#{ip} is invalid (IPv6 address contains invalid hex characters)."
+                else
+                    x = x.to_i(16)
+                    if ( (x < 0) || (x >= 2**16) )
+                        raise ValidationError, "#{ip} is invalid (Fields of an IPv6 address " +
+                                               "should be between 0x0 and 0xFFFF)."
+                    end
+                end
+            end
+
+    end
+    return(true)
+end
+module_function :validate_ip_str
+
+#==============================================================================#
+# validate_netmask_int()
+#==============================================================================#
+def validate_netmask_int(netmask,version,packed=false)
+    address_len = 32
+    address_len = 128 if (version == 6)
+
+    if (!packed)
+        if (netmask > address_len || netmask < 0 )
+            raise ValidationError, "Netmask, #{netmask}, is out of bounds for IPv#{version}." 
+        end
+    else
+        if (netmask >= 2**address_len || netmask < 0 )
+            raise ValidationError, "Packed netmask, #{netmask}, is out of bounds for IPv#{version}."
+        end
+    end
+    return(true)
+end
+module_function :validate_netmask_int
+
+#==============================================================================#
+# validate_netmask_str()
+#==============================================================================#
+def validate_netmask_str(netmask,version)
+    address_len = 32
+    address_len = 128 if (version == 6)
+
+    if(netmask =~ /\./) # extended netmask
+        all_f = 2**32-1
+        packed_netmask = 0
+
+        # validate & pack extended mask
+        begin
+            packed_netmask = pack_ip_addr(netmask, :Version => 4)
+        rescue Exception => error
+          raise ValidationError, "#{netmask} is improperly formed: #{error}"
+        end
+
+        # cycle through the bits of hostmask and compare
+        # with packed_mask. when we hit the firt '1' within
+        # packed_mask (our netmask boundary), xor hostmask and
+        # packed_mask. the result should be all 1's. this whole
+        # process is in place to make sure that we dont have
+        # and crazy masks such as 255.254.255.0
+        hostmask = 1
+         32.times do 
+            check = packed_netmask & hostmask
+            if ( check != 0)
+                hostmask = hostmask >> 1
+                unless ( (packed_netmask ^ hostmask) == all_f)
+                    raise ValidationError, "#{netmask} contains '1' bits within the host portion of the netmask." 
+                end
+                break
+            else
+                hostmask = hostmask << 1
+                hostmask = hostmask | 1
+            end
+        end
+
+    else # cidr format
+        # remove '/' if present
+        if (netmask =~ /^\// )
+            netmask[0] = " "
+            netmask.lstrip!
+        end
+
+        # check if we have any non numeric characters
+        if (netmask =~ /\D/)
+            raise ValidationError, "#{netmask} contains invalid characters."
+        end
+
+        netmask = netmask.to_i
+        if (netmask > address_len || netmask < 0 )
+            raise ValidationError, "Netmask, #{netmask}, is out of bounds for IPv#{version}." 
+        end
+
+    end
+    return(true)
+end
+module_function :validate_netmask_str
+
+
+
+end # module NetAddr
+
+__END__
+
+

data/tests/cidr_test.rb

@@ -9,6 +9,7 @@ class TestCIDR < Test::Unit::TestCase
 
     def test_create
         assert_raise(ArgumentError) {NetAddr::CIDR.create('192.168.1.0/24', :test => true)}
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('0.0.0.0/0')}
         assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.0/24')}
         assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.0/24') }
         assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.0 255.255.255.0')}
@@ -16,13 +17,14 @@ class TestCIDR < Test::Unit::TestCase
         assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1    ') }
         assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::/64') }
         assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1/24 255.255.0.0')}
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('::/0')}
         assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1/64')}
         assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1/64')}
         assert_nothing_raised(Exception){NetAddr::CIDR.create(0x0a0a0a0a, :PackedNetmask => 0xffffffff)}
-        assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1', :WildcardMask => ['0.0.7.255', :inversed]) }
-        assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1', :WildcardMask => [0x000007ff, :inversed]) }
-        assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1', :WildcardMask => ['0000:ffff::ffff', :inversed])}
-        assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1', :WildcardMask => [0xffff, :inversed])}
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1', :WildcardMask => ['0.0.7.255', true]) }
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('192.168.1.1', :WildcardMask => [0x000007ff, true]) }
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1', :WildcardMask => ['0000:ffff::ffff', true])}
+        assert_nothing_raised(Exception){NetAddr::CIDR.create('fec0::1', :WildcardMask => [0xffff, true])}
         
         assert_kind_of(NetAddr::CIDRv4, NetAddr::CIDR.create('192.168.1.1 255.255.0.0'))
         assert_kind_of(NetAddr::CIDRv4, NetAddr::CIDR.create('192.168.1.1/24 255.255.0.0'))
@@ -31,67 +33,29 @@ class TestCIDR < Test::Unit::TestCase
         assert_kind_of(NetAddr::CIDRv4, NetAddr::CIDR.create('10.10.10.10/32', :PackedNetmask => 0xffffff00))
         
         assert_raise(ArgumentError){ NetAddr::CIDR.create(:Version => 4) }
-        assert_raise(NetAddr::ValidationError){ NetAddr::CIDR.create('192.168.1.1', :WildcardMask => ['0000:ffff::ffff', :inversed]) }
-        assert_raise(NetAddr::ValidationError){ NetAddr::CIDR.create('fec0::1', :WildcardMask => ['0.0.7.255', :inversed]) }
-    end
-    
-    def test_new
-        assert_raise(ArgumentError) {NetAddr::CIDRv4.new('192.168.1.0/24', :test => true)}
-        assert_raise(ArgumentError) {NetAddr::CIDRv6.new('fec0::1/64', :test => true)}
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.0/24')}
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.0/24') }
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.0 255.255.255.0')}
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.1') }
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.1    ') }        
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new('192.168.1.1/24 255.255.0.0')}        
-        assert_nothing_raised(Exception){NetAddr::CIDRv4.new(0x0a0a0a0a, :PackedNetmask => 0xffffffff)}
-        assert_nothing_raised(Exception){NetAddr::CIDRv6.new('fec0::1/64')}
-        assert_nothing_raised(Exception){NetAddr::CIDRv6.new('fec0::1/64')}
-        assert_nothing_raised(Exception){NetAddr::CIDRv6.new('fec0::/64') }
-        
-        cidr = NetAddr::CIDRv4.new('192.168.1.1 255.255.0.0')
+        assert_raise(NetAddr::ValidationError){ NetAddr::CIDR.create('192.168.1.1', :WildcardMask => ['0000:ffff::ffff', true]) }
+        assert_raise(NetAddr::ValidationError){ NetAddr::CIDR.create('fec0::1', :WildcardMask => ['0.0.7.255', true]) }
+        
+        cidr = NetAddr::CIDRv4.create('192.168.1.1 255.255.0.0')
         assert_equal(16, cidr.bits )
 
         
-        cidr = NetAddr::CIDRv4.new('192.168.1.1/24 255.255.0.0')
+        cidr = NetAddr::CIDRv4.create('192.168.1.1/24 255.255.0.0')
         assert_equal(24, cidr.bits )
 
         
-        cidr = NetAddr::CIDRv4.new('10.10.10.10/32 255.255.255.0')
+        cidr = NetAddr::CIDRv4.create('10.10.10.10/32 255.255.255.0')
         assert_equal(32, cidr.bits )
 
         
-        cidr = NetAddr::CIDRv4.new('10.10.10.10/32', :PackedNetmask => 0xffffff00)
+        cidr = NetAddr::CIDRv4.create('10.10.10.10/32', :PackedNetmask => 0xffffff00)
         assert_equal(24, cidr.bits )
         
         cidr = NetAddr::CIDR.create('fec0::1/64')
         assert_equal(64, cidr.bits )
 
-        assert_raise(ArgumentError){ NetAddr::CIDRv4.new({}) }
-        assert_raise(ArgumentError){ NetAddr::CIDRv6.new({}) }
-        assert_raise(ArgumentError){ NetAddr::CIDRv6.new('fec0::1/64 255.255.255.0') }
-        assert_raise(NetAddr::ValidationError){ NetAddr::CIDRv4.new('192.168.1.0 a') }
-    end
-    
-    def test_matches?
-        cidr = NetAddr::CIDR.create('10.0.0.0/24')
-        assert(cidr.matches?('10.0.0.22'))
-        assert(!cidr.matches?('10.1.1.1'))
-        
-        cidr = NetAddr::CIDR.create('10.0.248.0')
-        cidr.wildcard_mask('255.248.255.0')
-        assert(cidr.matches?('10.1.248.0'))
-        assert(!cidr.matches?('10.8.248.0'))
-        
-        cidr = NetAddr::CIDR.create('10.0.248.0')
-        cidr.wildcard_mask('0.7.0.255', :inversed)
-        assert(cidr.matches?('10.1.248.0'))
-        assert(!cidr.matches?('10.8.248.0'))
-        
-        cidr = NetAddr::CIDR.create('fec0::1')
-        cidr.wildcard_mask('0000:ffff::ffff', :inversed)
-        assert(cidr.matches?('fec0:1::1'))
-        assert(!cidr.matches?('fec0:0:1::1'))
+        assert_raise(ArgumentError){ NetAddr::CIDRv4.create({}) }
+        assert_raise(NetAddr::ValidationError){ NetAddr::CIDRv4.create('192.168.1.0 a') }
     end
     
     def test_cmp
@@ -203,6 +167,39 @@ class TestCIDR < Test::Unit::TestCase
         
         assert_raise(NetAddr::VersionError) { cidr4.is_contained?(cidr6_2) }       
     end
+
+    def test_matches?
+        cidr = NetAddr::CIDR.create('10.0.0.0/24')
+        assert(cidr.matches?('10.0.0.22'))
+        assert(!cidr.matches?('10.1.1.1'))
+        
+        cidr = NetAddr::CIDR.create('10.0.248.0', :WildcardMask => ['255.248.255.0'])
+        assert(cidr.matches?('10.1.248.0'))
+        assert(!cidr.matches?('10.8.248.0'))
+        
+        cidr = NetAddr::CIDR.create('10.0.248.0')
+        cidr.set_wildcard_mask('0.7.0.255', true)
+        assert(cidr.matches?('10.1.248.0'))
+        assert(!cidr.matches?('10.8.248.0'))
+        
+        cidr = NetAddr::CIDR.create('127.0.0.0')
+        cidr.set_wildcard_mask('0.255.255.255', true)
+        assert(cidr.matches?('127.0.0.1'))
+        assert(!cidr.matches?('128.0.0.0'))
+        
+        cidr = NetAddr::CIDR.create('127.0.0.0', :WildcardMask => ['0.255.255.255', true])
+        assert(cidr.matches?('127.0.0.1'))
+        assert(!cidr.matches?('128.0.0.0'))
+        
+        cidr = NetAddr::CIDR.create('fec0::1')
+        cidr.set_wildcard_mask('0000:ffff::ffff', true)
+        assert(cidr.matches?('fec0:1::1'))
+        assert(!cidr.matches?('fec0:0:1::1'))
+        
+        cidr = NetAddr::CIDR.create('fec0::1', :WildcardMask => ['0000:ffff::ffff', true])
+        assert(cidr.matches?('fec0:1::1'))
+        assert(!cidr.matches?('fec0:0:1::1'))
+    end
     
     def test_mcast
         cidr4 = NetAddr::CIDR.create('224.0.0.1')
@@ -355,6 +352,13 @@ class TestCIDR < Test::Unit::TestCase
         cidr6 = NetAddr::CIDR.create('fec0::1/64')
         cidr6_2 = NetAddr::CIDR.create('fec0::/96')
 
+        assert(cidr4 == '192.168.1.0/24')
+        assert(cidr4 > '192.168.0.0/24')
+        assert(cidr4 < '192.168.2.0/24')
+        assert_equal(0, cidr4 <=> '192.168.1.0/24')
+        assert_equal(1, cidr4 <=> '192.168.0.0/24')
+        assert_equal(-1, cidr4 <=> '192.168.2.0/24')
+        
         assert_equal('1.168.192.in-addr.arpa.', cidr4.arpa() )
         assert_equal('0.0.0.0.0.0.0.0.0.0.0.0.0.c.e.f.ip6.arpa.', cidr6.arpa() )
         
@@ -425,24 +429,24 @@ class TestCIDR < Test::Unit::TestCase
     
     def test_wildcard_mask
         cidr = NetAddr::CIDR.create('10.1.0.0/24')
-        assert_equal('0.0.0.255', cidr.wildcard_mask(nil,:inversed))
+        assert_equal('0.0.0.255', cidr.wildcard_mask(true))
         assert_equal('255.255.255.0', cidr.wildcard_mask)
         
-        cidr.wildcard_mask('0.7.0.255', :inversed)
-        assert_equal('0.7.0.255', cidr.wildcard_mask(nil,:inversed))
+        cidr.set_wildcard_mask('0.7.0.255', true)
+        assert_equal('0.7.0.255', cidr.wildcard_mask(true))
         assert_equal('255.248.255.0', cidr.wildcard_mask())
-        cidr.wildcard_mask('255.248.255.0')
-        assert_equal('0.7.0.255', cidr.wildcard_mask(nil,:inversed))
+        cidr.set_wildcard_mask('255.248.255.0')
+        assert_equal('0.7.0.255', cidr.wildcard_mask(true))
         assert_equal('255.248.255.0', cidr.wildcard_mask())
-        cidr.wildcard_mask('0.0.0.0')
+        cidr.set_wildcard_mask('0.0.0.0')
         assert_equal('0.0.0.0', cidr.wildcard_mask)
-        assert_raise(NetAddr::ValidationError){ cidr.wildcard_mask('0000:ffff::ffff') }
+        assert_raise(NetAddr::ValidationError){ cidr.set_wildcard_mask('0000:ffff::ffff') }
         
         cidr = NetAddr::CIDR.create('fec0::1/64')
-        assert_equal('0000:0000:0000:0000:ffff:ffff:ffff:ffff', cidr.wildcard_mask(nil,:inversed))
-        cidr.wildcard_mask('0000:ffff::ffff', :inversed)
-        assert_equal('0000:ffff:0000:0000:0000:0000:0000:ffff', cidr.wildcard_mask(nil,:inversed))
-        assert_raise(NetAddr::ValidationError){ cidr.wildcard_mask('0.7.0.255', :inversed) }
+        assert_equal('0000:0000:0000:0000:ffff:ffff:ffff:ffff', cidr.wildcard_mask(true))
+        cidr.set_wildcard_mask('0000:ffff::ffff', true)
+        assert_equal('0000:ffff:0000:0000:0000:0000:0000:ffff', cidr.wildcard_mask(true))
+        assert_raise(NetAddr::ValidationError){ cidr.set_wildcard_mask('0.7.0.255', true) }
         
     end
 

data/tests/methods_test.rb

@@ -6,58 +6,35 @@ require 'test/unit'
 
 
 class TestMethods < Test::Unit::TestCase
-  
+
     def test_merge
-        cidr4 = [NetAddr::CIDR.create('192.168.1.0/24'),
-                 NetAddr::CIDR.create( '192.168.1.0/26'),
-                 NetAddr::CIDR.create('192.168.1.4/30'),
-                 NetAddr::CIDR.create('192.168.1.0/30'),
-                 NetAddr::CIDR.create('192.168.1.64/27'),
-                 NetAddr::CIDR.create('192.168.1.96/27'),
-                 NetAddr::CIDR.create('192.168.1.128/25'),
-                 NetAddr::CIDR.create('10.1.0.0/31'),
-                 NetAddr::CIDR.create('10.1.0.0/24'),
-                 NetAddr::CIDR.create('10.1.0.2/31'),
-                 NetAddr::CIDR.create('10.1.0.4/30'),
-                 NetAddr::CIDR.create('10.1.0.16/28'),
-                 NetAddr::CIDR.create('10.1.0.32/28'),
-                 NetAddr::CIDR.create('10.1.0.48/28'),
-                 NetAddr::CIDR.create('10.1.0.0/27'),
-                 NetAddr::CIDR.create('10.1.0.64/26'),
-                 NetAddr::CIDR.create('10.1.0.128/25'),
-                 NetAddr::CIDR.create('10.1.0.0/27'),
-                 NetAddr::CIDR.create('10.1.0.0/24')]
-        
-        cidr4_2 = ['10.0.0.0/9','10.1.0.0/9','10.1.0.0/24',
-                   '10.1.0.64/26','10.1.0.128/26','128.0.0.0/2',
-                   '129.0.0.0/2','1.1.1.0','1.1.1.1',
-                   '1.1.1.3','1.1.1.4','1.1.1.5',
-                   '1.1.1.6','1.1.1.7','192.168.1.0/27',
-                   '192.168.1.32/27','192.168.1.96/27','192.168.1.128/26',
-                   '192.168.1.192/26']       
-        
-        cidr4_3 = ['192.168.1.0/26', '192.168.1.64/26', '192.168.1.128/26', '192.168.1.192/26']
-        
-        cidr6 = [NetAddr::CIDR.create('fec0::/16'),
-                 NetAddr::CIDR.create('fec0::/17'),
-                 NetAddr::CIDR.create('fec0:8000::/18'),
-                 NetAddr::CIDR.create('fec0:c000::/18'),
-                 NetAddr::CIDR.create('fec0::/64'),
-                 NetAddr::CIDR.create('fec0::/66'),
-                 NetAddr::CIDR.create('fec0::8000:0:0:0/66'),
-                 NetAddr::CIDR.create('fec0::c000:0:0:0/66'),
-                 NetAddr::CIDR.create('fec0::/127'),
-                 NetAddr::CIDR.create('fec0::2/127')]
-        
-        assert_raise(ArgumentError) {NetAddr.merge(cidr4, :test => true)}
-        assert_equal(['10.1.0.0/24','10.1.0.0/29','10.1.0.16/28','192.168.1.0/24','192.168.1.0/29'], NetAddr.merge(cidr4))
-        assert_equal(['1.1.1.0/31','1.1.1.3/32','1.1.1.4/30','10.0.0.0/9','10.1.0.0/24','10.1.0.64/26',
-                      '10.1.0.128/26','128.0.0.0/2','192.168.1.0/26','192.168.1.96/27','192.168.1.128/25'], NetAddr.merge(cidr4_2))
-        assert_equal(['fec0::/16','fec0::/64','fec0::/66','fec0::/126','fec0::8000:0:0:0/65'], NetAddr.merge(cidr6, :Short => true))
-        assert_kind_of(NetAddr::CIDRv4, NetAddr.merge(cidr4_3, :Objectify => true)[0])
-        
         assert_raise(ArgumentError){ NetAddr.merge(1) }
         assert_raise(ArgumentError){ NetAddr.merge({}) }
+
+        subs = NetAddr::CIDR.create('10.0.0.0/24').subnet(:Bits => 26, :Objectify => true)
+        subs.concat( NetAddr::CIDR.create('10.1.0.0/24').subnet(:Bits => 29, :NumSubnets => 4, :Objectify => true) )
+        subs.delete_at(2)
+        subs.delete_at(7)
+        assert_equal(['10.0.0.0/25', '10.0.0.192/26', '10.1.0.0/27', '10.1.0.64/26', '10.1.0.128/25'], NetAddr.merge(subs) )
+
+        cidr = NetAddr::CIDR.create('fec0::/64')
+        subs = cidr.range(1, 8, :Objectify => true)
+        subs.concat([NetAddr::CIDR.create('192.168.0.0/27'), NetAddr::CIDR.create('192.168.0.32/27')])
+        assert_equal(['192.168.0.0/26', 'fec0::1/128', 'fec0::2/127', 'fec0::4/126', 'fec0::8/128',], NetAddr.merge(subs, :Short => true) )
+
+        subs = []
+        NetAddr.range('192.168.35.0','192.168.39.255', 
+                      :Inclusive => true, :Bitstep => 32).each {|x| subs.push(NetAddr::CIDR.create("#{x}/27")) }
+        assert_equal(['192.168.35.0/24', '192.168.36.0/22'], NetAddr.merge(subs) )
+
+        subs = NetAddr::CIDR.create('10.0.0.0/24').subnet(:Bits => 26, :Objectify => true)
+        subs.concat( subs.pop.subnet(:Bits => 27, :Objectify => true) )
+        subs.concat( subs.pop.subnet(:Bits => 28, :Objectify => true) )
+        subs[5].tag[:test] = true
+        merged = NetAddr.merge(subs, :Objectify => true)
+        assert_equal('10.0.0.0/24', merged[0].desc)
+        assert_equal('10.0.0.240/28', merged[0].tag[:Subnets][5].desc)
+        assert(merged[0].tag[:Subnets][5].tag[:test])
     end
     
     
@@ -133,6 +110,8 @@ class TestMethods < Test::Unit::TestCase
         
         assert_raise(ArgumentError){ NetAddr.range(:Limit => 1) }
         assert_raise(NetAddr::VersionError){ NetAddr.range(cidr4_1,cidr6_2) }
+        
+        assert_equal(256, NetAddr.range('192.168.0.0', '192.168.0.255', :Size => true, :Inclusive => true) )
     end
     
     
@@ -222,7 +201,8 @@ class TestMethods < Test::Unit::TestCase
         assert_raise(NetAddr::ValidationError){NetAddr.validate_eui('aabb.ccdd.eeff.12312') }
         assert_raise(NetAddr::ValidationError){NetAddr.validate_eui('aa-bb-c-dd-ee-ff') }
         assert_raise(NetAddr::ValidationError){NetAddr.validate_eui('aa:bb:cc:dd:e:ff') }
-        
+        assert_raise(NetAddr::ValidationError){NetAddr.validate_eui('aa:bb:cc:dd:ee:^^') }
+        assert_raise(NetAddr::ValidationError){NetAddr.validate_eui('aa:bb:cc:dd:ee:ZZ') }
         assert_raise(ArgumentError){ NetAddr.validate_eui(0xaabbccddeeff) }
         assert_raise(ArgumentError){ NetAddr.validate_eui() }        
     end
@@ -255,6 +235,7 @@ class TestMethods < Test::Unit::TestCase
         
         assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('') }
         assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('10.0') }
+        assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('10.0..0') }
         assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('192.168.1.256') }
         assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('192..168.1.1') }
         assert_raise(NetAddr::ValidationError){ NetAddr.validate_ip_addr('192.168.1a.255') }