netaddr 2.0.3 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 89ce300b6a351757d48c569e132c3e1346f7b09a
-  data.tar.gz: 5f11179793ee8a0d5a42758524b7aa49f71392cc
+SHA256:
+  metadata.gz: 13e871a188dbf2b94f5c57fe638c5dac249792134a8eece5386fbc36d1ea88d6
+  data.tar.gz: 14e02af771158f3003e49181ed49fe7e2fa8d201991215bda51fc2a48b15a96a
 SHA512:
-  metadata.gz: 36acfbba061405495f4e4d08c271f6be19c9810de6c5a44f78a2ebf407cf24637dac6b50277c82cc6048e36d00785e143aa37170e0101d40638b36f77e575c5a
-  data.tar.gz: c9baee3f002fb16def0f60f8e9304b44015739f0a5f844b1413f8b20d2d80c9bc73678654f81906ef14255f9928b64a3153eba120e387f4044bd558e5d6f5df3
+  metadata.gz: 2c1baeafeba2d571e007da5ed16276c3fadccb9be542ea47922878ba2e9889e8912145482db9b3c10f2aad3a7a19005ad0499005f71f893bb2db1e7806db1ed2
+  data.tar.gz: 3a287b3d7cb1f87cc46e50fefc54952c80e2ff43581492328a27091605db7937cde768d5003d9eeda201ee5e1b353de86e4602bf093bea497bac3403612f6e0f

data/lib/ipv4.rb

@@ -19,7 +19,7 @@ module NetAddr
 		# parse will create an IPv4 from its string representation (ie. "192.168.1.1").
 		# Throws ValidationError on error.
 		def IPv4.parse(ip)
-			ip.strip!
+			ip = ip.strip
 			i = Util.parse_IPv4(ip)
 			return IPv4.new(i)
 		end
@@ -77,6 +77,11 @@ module NetAddr
 			Util.int_to_IPv4(@addr)
 		end
 		
+		# version returns "4" for IPv4
+		def version()
+			return 4
+		end
+		
 	end # end class IPv4
 	
 end # end module

data/lib/ipv4net.rb

@@ -23,7 +23,7 @@ module NetAddr
 		# parse will create an IPv4Net from its string representation. Will default to a /32 netmask if not specified.
 		# Throws ValidationError on error.
 		def IPv4Net.parse(net)
-			net.strip!
+			net = net.strip
 			m32 = nil
 			if (net.include?("/")) # cidr format
 				addr,mask = net.split("/")
@@ -220,6 +220,11 @@ module NetAddr
 			return @base.to_s + @m32.to_s
 		end
 		
+		# version returns "4" for IPv4
+		def version()
+			return 4
+		end
+		
 		
 		protected
 

data/lib/ipv6.rb

@@ -19,7 +19,7 @@ module NetAddr
 		# parse will create an IPv6 from its string representation (ie. "1::").
 		# Throws ValidationError on error.
 		def IPv6.parse(ip)
-			ip.strip!
+			ip = ip.strip
 			i = Util.parse_IPv6(ip)
 			return IPv6.new(i)
 		end
@@ -40,6 +40,31 @@ module NetAddr
 			return 0
 		end
 		
+		# ipv4 generates an IPv4 from an IPv6 address. The IPv4 address is generated based on the mechanism described by RFC 6052.
+		# The argument pl (prefix length) should be one of: 32, 40, 48, 56, 64, or 96. Default is 96 unless one of the supported values is provided.
+		def ipv4(pl=96)
+			if (pl == 32)
+				i = (@addr >> 64) # get bits 32-63 into position
+				return IPv4.new(i & NetAddr::F32)
+			elsif (pl == 40)
+				i = (@addr >> 48) & 0xff # get the last 8 bits into position
+				i2 = (@addr & 0xffffff0000000000000000) >> 56 # get first 24 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 48)
+				i = (@addr >> 40) & 0xffff # get the last 16 bits into position
+				i2 = (@addr & 0xffff0000000000000000) >> 48 # get first 16 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 56)
+				i = (@addr >> 32) & 0xffffff # get the last 24 bits into position
+				i2 = (@addr & 0xff0000000000000000) >> 40 # get first 8 bits into position
+				return IPv4.new(i | i2)
+			elsif (pl == 64)
+				i = (@addr >> 24) # get the 32 bits into position
+				return IPv4.new(i & NetAddr::F32)
+			end
+			return IPv4.new(@addr & NetAddr::F32)
+		end
+		
 		# long returns the IPv6 as a string in long (uncompressed) format
 		def long()
 			words = []
@@ -100,8 +125,9 @@ module NetAddr
 				end
 			end
 			
-			# compress if we've found a series of 0 words in a row
-			if (finalStart != -1)
+			# compress if we've found a series of zero fields in a row.
+      # per https://tools.ietf.org/html/rfc5952#section-4.2.2 we must not compress just a single 16-bit zero field.
+			if (finalLen > 1)
 				head = hexStr[0,finalStart].join(":")
 				tailStart = finalStart + finalLen 
 				tail = hexStr[tailStart..7].join(":")
@@ -110,6 +136,11 @@ module NetAddr
 			return hexStr.join(":")
 		end
 		
+		# version returns "6" for IPv6
+		def version()
+			return 6
+		end
+		
 	end # end class IPv6
 	
 end # end module

data/lib/ipv6net.rb

@@ -28,7 +28,7 @@ module NetAddr
 		# Throws ValidationError on error.
 		def IPv6Net.parse(net)
 			m128 = nil
-			net.strip!
+			net = net.strip
 			if (net.include?("/")) # cidr format
 				addr,mask = net.split("/")
 				m128 = Mask128.parse(mask)
@@ -224,6 +224,11 @@ module NetAddr
 			return @base.to_s + @m128.to_s
 		end
 		
+		# version returns "6" for IPv6
+		def version()
+			return 6
+		end
+		
 		
 		protected
 

data/lib/mask128.rb

@@ -26,11 +26,13 @@ module NetAddr
 		#
 		# Throws ValidationError on error.
 		def Mask128.parse(mask)
-			mask.strip!
+			mask = mask.strip
 			if (mask.start_with?("/")) # cidr format
 				mask = mask[1..-1] # remove "/"
 			end
-			return Mask128.new(mask.to_i)
+			return Mask128.new(Integer(mask))
+		rescue ArgumentError
+			raise ValidationError, "#{mask} is not valid integer."
 		end
 		
 		#cmp compares equality with another Mask128. Return:

data/lib/mask32.rb

@@ -26,11 +26,17 @@ module NetAddr
 		#
 		#	Throws ValidationError on error.
 		def Mask32.parse(mask)
-			mask.strip!
+			mask = mask.strip
 			if (mask.start_with?("/")) # cidr format
-				return Mask32.new(mask[1..-1].to_i) # remove "/"
-			elsif (!mask.include?("."))
-				return Mask32.new(mask.to_i)
+				mask = mask[1..-1] # remove "/"
+			end
+
+			if (!mask.include?("."))
+				begin
+					return Mask32.new(Integer(mask))
+				rescue ArgumentError
+					raise ValidationError, "#{mask} is not valid integer."
+				end
 			end
 			
 			# for extended netmask
@@ -62,7 +68,7 @@ module NetAddr
 		
 		# extended returns the Mask32 in extended format (eg. x.x.x.x)
 		def extended()
-			Util.intToMask32(@mask)
+			Util.int_to_IPv4(@mask)
 		end
 		
 		#cmp compares equality with another Mask32. Return:

data/lib/netaddr.rb

@@ -37,6 +37,24 @@ module NetAddr
 	end
 	module_function :ipv4_prefix_len
 	
+	## parse_ip parses a string into an IPv4 or IPv6
+	def parse_ip(ip)
+		if (ip.include?(":"))
+			return IPv6.parse(ip)
+		end
+		return IPv4.parse(ip)
+	end
+	module_function :parse_ip
+	
+	## parse_net parses a string into an IPv4Net or IPv6Net
+	def parse_net(net)
+		if (net.include?(":"))
+			return IPv6Net.parse(net)
+		end
+		return IPv4Net.parse(net)
+	end
+	module_function :parse_net
+	
 	# sort_IPv4 sorts a list of IPv4 objects in ascending order.
 	# It will return a new list with any non IPv4 objects removed.
 	def sort_IPv4(list)

data/lib/util.rb

@@ -23,35 +23,33 @@ module NetAddr
 	
 	# discard_subnets returns a copy of the IPv4NetList with any entries which are subnets of other entries removed.
 	def Util.discard_subnets(list)
-		unrelated = []
-		supernets = []
+		keepers = []
 		last = list[list.length-1]
+		keep_last = true
 		list.each do |net|
 			rel = last.rel(net)
-			if (!rel)
-				unrelated.push(net)
-			elsif (rel == -1) # last is subnet of net
-				supernets.push(net)
+			if (!rel) # keep unrelated nets
+				keepers.push(net)
+			elsif (rel == -1) # keep supernets, but do not keep last
+				keepers.push(net)
+				keep_last = false
 			end
 		end
 		
-		cleaned = []
-		if (supernets.length > 0)
-			cleaned = discard_subnets(supernets)
-		else
-			cleaned.push(last)
+		# recursively clean up keepers
+		if (keepers.length > 0)
+			keepers = discard_subnets(keepers)
 		end
-		
-		if (unrelated.length > 0)
-			cleaned.concat( discard_subnets(unrelated) )
+		if keep_last
+			keepers.unshift(last)
 		end
-		return cleaned
+		return keepers
 	end
 	
 	# fill returns a copy of the given Array, stripped of any networks which are not subnets of ipnet
 	# and with any missing gaps filled in.
 	def Util.fill(ipnet,list)
-		# sort & git rid of non subnets
+		# sort & get rid of non subnets
 		subs = []
 		discard_subnets(list).each do |sub|
 			r = ipnet.rel(sub)
@@ -69,21 +67,14 @@ module NetAddr
 				filled = backfill(subs[0],base)
 			end
 			
-			# fill gaps
-			sib = ipnet.next_sib()
-			ceil = NetAddr::F32
-			if (sib != nil)
-				ceil = sib.network.addr
-			end
-			
+			# fill gaps between subnets
 			0.upto(subs.length-1) do |i|
 				sub = subs[i]
-				filled.push(sub)
-				limit = ceil
 				if (i+1 < subs.length)
-					limit = subs[i+1].network.addr
+					filled.concat( fwdfill(sub,ipnet,subs[i+1]) )
+				else
+					filled.concat( fwdfill(sub,ipnet,nil) )
 				end
-				filled.concat( fwdfill(sub,limit) )
 			end
 		end
 		return filled
@@ -133,18 +124,80 @@ module NetAddr
 		return filtered
 	end
 	
-	# fwdfill returns subnets between given IPv4Net/IPv6Nett and the limit address.
-	# limit should be > ipnet. will create subnets up to limit.
-	def Util.fwdfill(ipnet,limit)
-		nets = []
+	# fwdfill returns subnets between given IPv4Net/IPv6Nett and the limit address. limit should be > ipnet.
+	def Util.fwdfill(ipnet,supernet,limit)
+		nets = [ipnet]
 		cur = ipnet
-		while true do
-			net = cur.next
-			if (net == nil || net.network.addr >= limit)
-				break
+		if (limit != nil) # if limit, then fill gaps between net and limit
+			while true do
+				nextSub = cur.next()
+				# ensure we've not exceed the total address space
+				if (nextSub == nil)
+					break
+				end
+				# ensure we've not exceeded the address space of supernet
+				if (supernet.rel(nextSub) == nil)
+					break
+				end
+				# ensure we've not hit limit
+				if (nextSub.network.addr == limit.network.addr)
+					break
+				end
+				
+				# check relationship to limit
+				if (nextSub.rel(limit) != nil) # if related, then nextSub must be a supernet of limit. we need to shrink it.
+					prefixLen = nextSub.netmask.prefix_len
+					while true do
+						prefixLen += 1
+						if (nextSub.kind_of?(IPv4Net))
+							nextSub = IPv4Net.new(nextSub.network, Mask32.new(prefixLen))
+						else
+							nextSub = IPv6Net.new(nextSub.network, Mask128.new(prefixLen))
+						end
+						if (nextSub.rel(limit) == nil) # stop when we no longer overlap with limit
+							break
+						end
+					end
+				else # otherwise, if unrelated then grow until we hit the limit
+					prefixLen = nextSub.netmask.prefix_len
+					mask = nextSub.netmask.mask
+					while true do
+						prefixLen -= 1
+						if (prefixLen == supernet.netmask.prefix_len) # break if we've hit the supernet boundary
+							break
+						end
+						mask = mask << 1
+						if (nextSub.network.addr|mask != mask) # break when bit boundary crossed (there are '1' bits in the host portion)
+							break
+						end
+						if (nextSub.kind_of?(IPv4Net))
+							grown = IPv4Net.new(nextSub.network, Mask32.new(prefixLen))
+						else
+							grown = IPv6Net.new(nextSub.network, Mask128.new(prefixLen))
+						end
+						if (grown.rel(limit) != nil) # if we've overlapped with limit in any way, then break
+							break
+						end
+						nextSub = grown
+					end
+				end
+				nets.push(nextSub)
+				cur = nextSub
+			end
+		else # if no limit, then get next largest sibs until we've exceeded supernet
+			while true do
+				nextSub = cur.next()
+				# ensure we've not exceed the total address space
+				if (nextSub == nil)
+					break
+				end
+				# ensure we've not exceeded the address space of supernet
+				if (supernet.rel(nextSub) == nil)
+					break
+				end
+				nets.push(nextSub)
+				cur = nextSub
 			end
-			nets.push(net)
-			cur = net
 		end
 		return nets
 	end
@@ -166,8 +219,7 @@ module NetAddr
 			raise ValidationError, "#{ip} contains invalid characters."
 		end
 		
-		ip.strip!
-		octets = ip.split('.')
+		octets = ip.strip.split('.')
 		if (octets.length != 4)
 			raise ValidationError, "IPv4 requires (4) octets."
 		end
@@ -188,14 +240,24 @@ module NetAddr
 	# parse_IPv6 parses an IPv6 address String into an Integer
 	def Util.parse_IPv6(ip)
 	# check that only valid characters are present
-		if (ip =~ /[^0-9a-fA-F\:]/)
+		if (ip =~ /[^0-9a-fA-F\:.]/)
 			raise ValidationError, "#{ip} contains invalid characters."
 		end
 		
-		ip.strip!
+		ip = ip.strip
 		if (ip == "::")
 			return 0 # zero address
 		end
+		ipv4Int = nil
+		if (ip.include?(".")) # check for ipv4 embedded addresses
+			words = ip.split(":")
+			begin
+				ipv4Int = Util.parse_IPv4(words.last)
+			rescue
+				raise ValidationError, "IPv4-embedded IPv6 address is invalid."
+			end
+			ip = ip.sub(words.last,"0:0") # temporarily remove the ipv4 portion
+		end
 		words = []
 		if (ip.include?("::")) # short format
 			if (ip =~ /:{3,}/) # make sure only i dont have ":::"
@@ -231,7 +293,6 @@ module NetAddr
 				raise ValidationError, "#{ip} is too short."
 			end
 		end
-		
 		ipInt = 0
 		i = 8
 		words.each do |word|
@@ -239,7 +300,9 @@ module NetAddr
 			word = word.to_i(16) << (16*i)
 			ipInt = ipInt | word
 		end
-		
+		if ipv4Int # re-add ipv4 portion if present
+			ipInt = ipInt | ipv4Int
+		end
 		return ipInt
 	end
 		

data/test/ipv4net_test.rb

@@ -52,6 +52,7 @@ class TestIPv4Net < Test::Unit::TestCase
 	end
 
 	def test_fill
+		# filter supernet. remove subnets of subnets. basic fwd fill.
 		parent = NetAddr::IPv4Net.parse("10.0.0.0/24")
 		nets = []
 		["10.0.0.0/24", "10.0.0.0/8", "10.0.0.8/30", "10.0.0.16/30", "10.0.0.16/28"].each do |net|
@@ -64,6 +65,7 @@ class TestIPv4Net < Test::Unit::TestCase
 			i += 1
 		end
 		
+		# basic backfill
 		parent = NetAddr::IPv4Net.parse("128.0.0.0/1")
 		nets = []
 		["192.0.0.0/2"].each do |net|
@@ -76,6 +78,7 @@ class TestIPv4Net < Test::Unit::TestCase
 			i += 1
 		end
 		
+		# basic fwd fill with non-contiguous subnets
 		parent = NetAddr::IPv4Net.parse("1.0.0.0/25")
 		nets = []
 		["1.0.0.0/30", "1.0.0.64/26"].each do |net|
@@ -87,6 +90,32 @@ class TestIPv4Net < Test::Unit::TestCase
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
+    
+		# basic backfill. complex fwd fill that uses 'shrink' of the proposed 1.0.16.0/21 subnet
+    parent = NetAddr::IPv4Net.parse("1.0.0.0/19")
+		nets = []
+		["1.0.8.0/21", "1.0.20.0/24"].each do |net|
+			nets.push(NetAddr::IPv4Net.parse(net))
+		end
+		expect = ["1.0.0.0/21","1.0.8.0/21","1.0.16.0/22","1.0.20.0/24","1.0.21.0/24","1.0.22.0/23","1.0.24.0/21"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# list contains the supernet
+		parent = NetAddr::IPv4Net.parse("1.0.0.0/19")
+		nets = []
+		["1.0.0.0/19"].each do |net|
+			nets.push(NetAddr::IPv4Net.parse(net))
+		end
+		expect = []
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
 	end
 	
 	def test_len

data/test/ipv6_test.rb

@@ -39,6 +39,18 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal(0x00000001000200030004000500060007, NetAddr::IPv6.parse("::1:2:3:4:5:6:7").addr)
 		assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("fec0") }
 		assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("fec0:::1") }
+    
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b::0:0:0:0:192.0.2.33").addr)
+    assert_equal(0x0064ff9b0000000000000000c0000221, NetAddr::IPv6.parse("64:ff9b:0:0:0:0:192.0.2.33").addr)
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.2") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.2.33.0") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::192.0.256.33") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b:0:0:0:0:0:192.0.2.33") }
+    assert_raise(NetAddr::ValidationError){ NetAddr::IPv6.parse("64:ff9b::0:0:0:0:0:192.0.2.33") }
 	end
 	
 	def test_cmp
@@ -51,6 +63,32 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal(0, ip.cmp(ip4))
 	end
 	
+	def test_ipv4
+		ipv6 = NetAddr::IPv6.parse("64:ff9b::192.0.2.33")
+		ipv4 = ipv6.ipv4()
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:c000:221::")
+		ipv4 = ipv6.ipv4(32)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:1c0:2:21::")
+		ipv4 = ipv6.ipv4(40)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:c000:2:2100::")
+		ipv4 = ipv6.ipv4(48)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:3c0:0:221::")
+		ipv4 = ipv6.ipv4(56)
+		assert_equal("192.0.2.33", ipv4.to_s)
+		
+		ipv6 = NetAddr::IPv6.parse("2001:db8:122:344:c0:2:2100::")
+		ipv4 = ipv6.ipv4(64)
+		assert_equal("192.0.2.33", ipv4.to_s)
+	end
+	
 	def test_long
 		assert_equal("0000:0000:0000:0000:0000:0000:0000:0000", NetAddr::IPv6.parse("::").long)
 		assert_equal("fe80:0000:0000:0000:0000:0000:0000:0001", NetAddr::IPv6.parse("fe80::1").long)
@@ -83,6 +121,7 @@ class TestIPv6 < Test::Unit::TestCase
 		assert_equal("::1:0:0", NetAddr::IPv6.parse("0:0:0:0:0:1:0:0").to_s)
 		assert_equal("::1:0", NetAddr::IPv6.parse(":0:0:0:0:0:1:0").to_s)
 		assert_equal("::1", NetAddr::IPv6.parse("0:0:0:0:0:0:0:1").to_s)
+		assert_equal("1:0:1:1:1:1:1:1", NetAddr::IPv6.parse("1:0:1:1:1:1:1:1").to_s) # see RFC 5952 section 4.2.2
 		
 		assert_equal("1::1", NetAddr::IPv6.parse("1:0:0:0:0:0:0:1").to_s)
 		assert_equal("1:1::1", NetAddr::IPv6.parse("1:1:0:0:0:0:0:1").to_s)

data/test/ipv6net_test.rb

@@ -48,18 +48,33 @@ class TestIPv6Net < Test::Unit::TestCase
 	end
 
 	def test_fill
+		# filter supernet. remove subnets of subnets. basic fwd fill.
 		parent = NetAddr::IPv6Net.parse("ff00::/8")
 		nets = []
-		["ff08::/14", "fe00::/7", "ff20::/11", "ff20::/12"].each do |net|
+		["ff00::/8", "ff00::/9", "ff08::/14", "fe00::/7", "ff20::/11", "ff20::/12"].each do |net|
 			nets.push(NetAddr::IPv6Net.parse(net))
 		end
-		expect = ["ff00::/13", "ff08::/14", "ff0c::/14", "ff10::/12", "ff20::/11", "ff40::/10", "ff80::/9"]
+		expect = ["ff00::/9", "ff80::/9"]
 		i = 0
 		parent.fill(nets).each do |net|
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
 		
+		# basic backfill
+		parent = NetAddr::IPv6Net.parse("8000::/1")
+		nets = []
+		["c000::/2"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = ["8000::/2","c000::/2"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# basic fwd fill with non-contiguous subnets
 		parent = NetAddr::IPv6Net.parse("ff00::/121")
 		nets = []
 		["ff00::/126", "ff00::/120"].each do |net|
@@ -71,6 +86,33 @@ class TestIPv6Net < Test::Unit::TestCase
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
+		
+		# basic backfill. complex fwd fill that uses 'shrink' of the proposed ffff:ffff:ffff:fff8::/62 subnet. designed to cross the /64 bit boundary.
+		parent = NetAddr::IPv6Net.parse("fff:ffff:ffff:fff0::/60")
+		nets = []
+		["ffff:ffff:ffff:fff4::/62", "ffff:ffff:ffff:fffb::/65"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = ["ffff:ffff:ffff:fff0::/62", "ffff:ffff:ffff:fff4::/62", "ffff:ffff:ffff:fff8::/63", "ffff:ffff:ffff:fffa::/64", "ffff:ffff:ffff:fffb::/65",
+			"ffff:ffff:ffff:fffb:8000::/65", "ffff:ffff:ffff:fffc::/62"]
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
+		
+		# list contains the supernet
+		parent = NetAddr::IPv6Net.parse("ffff::/16")
+		nets = []
+		["ffff::/16"].each do |net|
+			nets.push(NetAddr::IPv6Net.parse(net))
+		end
+		expect = []
+		i = 0
+		parent.fill(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
 	end
 	
 	def test_next

data/test/mask32_test.rb

@@ -34,6 +34,11 @@ class TestMask32 < Test::Unit::TestCase
 		assert_equal(0, m.cmp(m4))
 	end
 	
+	def test_extended
+		m32 = NetAddr::Mask32.new(24)
+		assert_equal("255.255.255.0", m32.extended)
+	end
+	
 	def test_len
 		m = NetAddr::Mask32.new(24)
 		assert_equal(256, m.len())

data/test/netaddr_test.rb

@@ -5,6 +5,17 @@ require 'test/unit'
 
 class TestNetAddr < Test::Unit::TestCase
 
+	def test_parse_ip
+		assert_equal("128.0.0.1", NetAddr.parse_ip("128.0.0.1").to_s)
+		assert_equal("1::1", NetAddr.parse_ip("1::1").to_s)
+	end
+	
+	def test_parse_net
+		assert_equal("128.0.0.1/32", NetAddr.parse_net("128.0.0.1/32").to_s)
+		assert_equal("1::/24", NetAddr.parse_net("1::1/24").to_s)
+		assert_equal("::ffff:aabb:ccdd/128", NetAddr.parse_net("::ffff:170.187.204.221/128").to_s)
+	end
+	
 	def test_ipv4_prefix_len
 		assert_equal(32,NetAddr.ipv4_prefix_len(1))
 		assert_equal(27,NetAddr.ipv4_prefix_len(30))
@@ -67,6 +78,17 @@ class TestNetAddr < Test::Unit::TestCase
 			assert_equal(expect[i],net.to_s)
 			i += 1
 		end
+		
+		nets = []
+		["10.0.0.0/26","10.0.0.64/26","10.0.0.0/24","10.0.0.192/26","10.0.0.128/26"].each do |net| # test out of order
+			nets.push(NetAddr::IPv4Net.parse(net))
+		end
+		expect = ["10.0.0.0/24"]
+		i = 0
+		NetAddr.summ_IPv4Net(nets).each do |net|
+			assert_equal(expect[i],net.to_s)
+			i += 1
+		end
 	end
 	
 	def test_sort_IPv6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: netaddr
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.6
 platform: ruby
 authors:
 - Dustin Spinhirne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -60,8 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: A Ruby library for performing calculations on IPv4 and IPv6 subnets.