test_ipaddress.py 93 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222
  1. # Copyright 2007 Google Inc.
  2. # Licensed to PSF under a Contributor Agreement.
  3. """Unittest for ipaddress module."""
  4. from __future__ import unicode_literals
  5. import contextlib
  6. import operator
  7. import pickle
  8. import re
  9. import sys
  10. import unittest
  11. import weakref
  12. import ipaddress
  13. # Compatibility function
  14. import binascii
  15. try:
  16. _compat_bytes_fromhex = bytes.fromhex
  17. except AttributeError:
  18. def _compat_bytes_fromhex(s):
  19. return binascii.unhexlify(s)
  20. _compat_str = ipaddress._compat_str
  21. class BaseTestCase(unittest.TestCase):
  22. # One big change in ipaddress over the original ipaddr module is
  23. # error reporting that tries to assume users *don't know the rules*
  24. # for what constitutes an RFC compliant IP address
  25. # Ensuring these errors are emitted correctly in all relevant cases
  26. # meant moving to a more systematic test structure that allows the
  27. # test structure to map more directly to the module structure
  28. # Note that if the constructors are refactored so that addresses with
  29. # multiple problems get classified differently, that's OK - just
  30. # move the affected examples to the newly appropriate test case.
  31. # There is some duplication between the original relatively ad hoc
  32. # test suite and the new systematic tests. While some redundancy in
  33. # testing is considered preferable to accidentally deleting a valid
  34. # test, the original test suite will likely be reduced over time as
  35. # redundant tests are identified.
  36. @property
  37. def factory(self):
  38. raise NotImplementedError
  39. @contextlib.contextmanager
  40. def assertCleanError(self, exc_type, details, *args):
  41. """
  42. Ensure exception does not display a context by default
  43. Wraps unittest.TestCase.assertRaisesRegex
  44. """
  45. if args:
  46. details = details % args
  47. cm = self.assertRaisesRegex(exc_type, details)
  48. with cm as exc:
  49. yield exc
  50. # Commented out - this is not easily possible in 2.x
  51. # # Ensure we produce clean tracebacks on failure
  52. # if exc.exception.__context__ is not None:
  53. # self.assertTrue(exc.exception.__suppress_context__)
  54. def assertAddressError(self, details, *args):
  55. """Ensure a clean AddressValueError"""
  56. return self.assertCleanError(ipaddress.AddressValueError,
  57. details, *args)
  58. def assertNetmaskError(self, details, *args):
  59. """Ensure a clean NetmaskValueError"""
  60. return self.assertCleanError(ipaddress.NetmaskValueError,
  61. details, *args)
  62. def assertInstancesEqual(self, lhs, rhs):
  63. """Check constructor arguments produce equivalent instances"""
  64. self.assertEqual(self.factory(lhs), self.factory(rhs))
  65. class CommonTestMixin:
  66. def test_empty_address(self):
  67. with self.assertAddressError("Address cannot be empty"):
  68. self.factory("")
  69. def test_floats_rejected(self):
  70. with self.assertAddressError(re.escape(repr("1.0"))):
  71. self.factory(1.0)
  72. def test_not_an_index_issue15559(self):
  73. # Implementing __index__ makes for a very nasty interaction with the
  74. # bytes constructor. Thus, we disallow implicit use as an integer
  75. self.assertRaises(TypeError, operator.index, self.factory(1))
  76. self.assertRaises(TypeError, hex, self.factory(1))
  77. # Commented out: bytes semantics are different in 2.x
  78. # self.assertRaises(TypeError, bytes, self.factory(1))
  79. def pickle_test(self, addr):
  80. for proto in range(pickle.HIGHEST_PROTOCOL + 1):
  81. with self.subTest(proto=proto):
  82. x = self.factory(addr)
  83. y = pickle.loads(pickle.dumps(x, proto))
  84. self.assertEqual(y, x)
  85. class CommonTestMixin_v4(CommonTestMixin):
  86. def test_leading_zeros(self):
  87. self.assertInstancesEqual("000.000.000.000", "0.0.0.0")
  88. self.assertInstancesEqual("192.168.000.001", "192.168.0.1")
  89. def test_int(self):
  90. self.assertInstancesEqual(0, "0.0.0.0")
  91. self.assertInstancesEqual(3232235521, "192.168.0.1")
  92. def test_packed(self):
  93. self.assertInstancesEqual(
  94. _compat_bytes_fromhex("00000000"), "0.0.0.0")
  95. self.assertInstancesEqual(
  96. _compat_bytes_fromhex("c0a80001"), "192.168.0.1")
  97. def test_negative_ints_rejected(self):
  98. msg = "-1 (< 0) is not permitted as an IPv4 address"
  99. with self.assertAddressError(re.escape(msg)):
  100. self.factory(-1)
  101. def test_large_ints_rejected(self):
  102. msg = "%d (>= 2**32) is not permitted as an IPv4 address"
  103. with self.assertAddressError(re.escape(msg % (2 ** 32))):
  104. self.factory(2 ** 32)
  105. def test_bad_packed_length(self):
  106. def assertBadLength(length):
  107. addr = b'\0' * length
  108. msg = "%r (len %d != 4) is not permitted as an IPv4 address"
  109. with self.assertAddressError(re.escape(msg % (addr, length))):
  110. self.factory(addr)
  111. assertBadLength(3)
  112. assertBadLength(5)
  113. class CommonTestMixin_v6(CommonTestMixin):
  114. def test_leading_zeros(self):
  115. self.assertInstancesEqual("0000::0000", "::")
  116. self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1")
  117. def test_int(self):
  118. self.assertInstancesEqual(0, "::")
  119. self.assertInstancesEqual(3232235521, "::c0a8:1")
  120. def test_packed(self):
  121. addr = b'\0'*12 + _compat_bytes_fromhex("00000000")
  122. self.assertInstancesEqual(addr, "::")
  123. addr = b'\0'*12 + _compat_bytes_fromhex("c0a80001")
  124. self.assertInstancesEqual(addr, "::c0a8:1")
  125. addr = _compat_bytes_fromhex("c0a80001") + b'\0'*12
  126. self.assertInstancesEqual(addr, "c0a8:1::")
  127. def test_negative_ints_rejected(self):
  128. msg = "-1 (< 0) is not permitted as an IPv6 address"
  129. with self.assertAddressError(re.escape(msg)):
  130. self.factory(-1)
  131. def test_large_ints_rejected(self):
  132. msg = "%d (>= 2**128) is not permitted as an IPv6 address"
  133. with self.assertAddressError(re.escape(msg % 2 ** 128)):
  134. self.factory(2 ** 128)
  135. def test_bad_packed_length(self):
  136. def assertBadLength(length):
  137. addr = b'\0' * length
  138. msg = "%r (len %d != 16) is not permitted as an IPv6 address"
  139. with self.assertAddressError(re.escape(msg % (addr, length))):
  140. self.factory(addr)
  141. self.factory(addr)
  142. assertBadLength(15)
  143. assertBadLength(17)
  144. class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4):
  145. factory = ipaddress.IPv4Address
  146. def test_network_passed_as_address(self):
  147. addr = "127.0.0.1/24"
  148. with self.assertAddressError("Unexpected '/' in %r", addr):
  149. ipaddress.IPv4Address(addr)
  150. def test_bad_address_split(self):
  151. def assertBadSplit(addr):
  152. with self.assertAddressError("Expected 4 octets in %r", addr):
  153. ipaddress.IPv4Address(addr)
  154. assertBadSplit("127.0.1")
  155. assertBadSplit("42.42.42.42.42")
  156. assertBadSplit("42.42.42")
  157. assertBadSplit("42.42")
  158. assertBadSplit("42")
  159. assertBadSplit("42..42.42.42")
  160. assertBadSplit("42.42.42.42.")
  161. assertBadSplit("42.42.42.42...")
  162. assertBadSplit(".42.42.42.42")
  163. assertBadSplit("...42.42.42.42")
  164. assertBadSplit("016.016.016")
  165. assertBadSplit("016.016")
  166. assertBadSplit("016")
  167. assertBadSplit("000")
  168. assertBadSplit("0x0a.0x0a.0x0a")
  169. assertBadSplit("0x0a.0x0a")
  170. assertBadSplit("0x0a")
  171. assertBadSplit(".")
  172. assertBadSplit("bogus")
  173. assertBadSplit("bogus.com")
  174. assertBadSplit("1000")
  175. assertBadSplit("1000000000000000")
  176. assertBadSplit("192.168.0.1.com")
  177. def test_empty_octet(self):
  178. def assertBadOctet(addr):
  179. with self.assertAddressError("Empty octet not permitted in %r",
  180. addr):
  181. ipaddress.IPv4Address(addr)
  182. assertBadOctet("42..42.42")
  183. assertBadOctet("...")
  184. def test_invalid_characters(self):
  185. def assertBadOctet(addr, octet):
  186. msg = "Only decimal digits permitted in %r in %r" % (octet, addr)
  187. with self.assertAddressError(re.escape(msg)):
  188. ipaddress.IPv4Address(addr)
  189. assertBadOctet("0x0a.0x0a.0x0a.0x0a", "0x0a")
  190. assertBadOctet("0xa.0x0a.0x0a.0x0a", "0xa")
  191. assertBadOctet("42.42.42.-0", "-0")
  192. assertBadOctet("42.42.42.+0", "+0")
  193. assertBadOctet("42.42.42.-42", "-42")
  194. assertBadOctet("+1.+2.+3.4", "+1")
  195. assertBadOctet("1.2.3.4e0", "4e0")
  196. assertBadOctet("1.2.3.4::", "4::")
  197. assertBadOctet("1.a.2.3", "a")
  198. def test_octal_decimal_ambiguity(self):
  199. def assertBadOctet(addr, octet):
  200. msg = "Ambiguous (octal/decimal) value in %r not permitted in %r"
  201. with self.assertAddressError(re.escape(msg % (octet, addr))):
  202. ipaddress.IPv4Address(addr)
  203. assertBadOctet("016.016.016.016", "016")
  204. assertBadOctet("001.000.008.016", "008")
  205. def test_octet_length(self):
  206. def assertBadOctet(addr, octet):
  207. msg = "At most 3 characters permitted in %r in %r"
  208. with self.assertAddressError(re.escape(msg % (octet, addr))):
  209. ipaddress.IPv4Address(addr)
  210. assertBadOctet("0000.000.000.000", "0000")
  211. assertBadOctet("12345.67899.-54321.-98765", "12345")
  212. def test_octet_limit(self):
  213. def assertBadOctet(addr, octet):
  214. msg = "Octet %d (> 255) not permitted in %r" % (octet, addr)
  215. with self.assertAddressError(re.escape(msg)):
  216. ipaddress.IPv4Address(addr)
  217. assertBadOctet("257.0.0.0", 257)
  218. assertBadOctet("192.168.0.999", 999)
  219. def test_pickle(self):
  220. self.pickle_test('192.0.2.1')
  221. def test_weakref(self):
  222. weakref.ref(self.factory('192.0.2.1'))
  223. def test_bytes_message(self):
  224. with self.assertAddressError(r'bytes'):
  225. ipaddress.IPv4Address(b'192.0.2.1')
  226. with self.assertAddressError(r'bytes'):
  227. ipaddress.ip_address(b'192.0.2.1')
  228. class AddressTestCase_v6(BaseTestCase, CommonTestMixin_v6):
  229. factory = ipaddress.IPv6Address
  230. def test_network_passed_as_address(self):
  231. addr = "::1/24"
  232. with self.assertAddressError("Unexpected '/' in %r", addr):
  233. ipaddress.IPv6Address(addr)
  234. def test_bad_address_split_v6_not_enough_parts(self):
  235. def assertBadSplit(addr):
  236. msg = "At least 3 parts expected in %r"
  237. with self.assertAddressError(msg, addr):
  238. ipaddress.IPv6Address(addr)
  239. assertBadSplit(":")
  240. assertBadSplit(":1")
  241. assertBadSplit("FEDC:9878")
  242. def test_bad_address_split_v6_too_many_colons(self):
  243. def assertBadSplit(addr):
  244. msg = "At most 8 colons permitted in %r"
  245. with self.assertAddressError(msg, addr):
  246. ipaddress.IPv6Address(addr)
  247. assertBadSplit("9:8:7:6:5:4:3::2:1")
  248. assertBadSplit("10:9:8:7:6:5:4:3:2:1")
  249. assertBadSplit("::8:7:6:5:4:3:2:1")
  250. assertBadSplit("8:7:6:5:4:3:2:1::")
  251. # A trailing IPv4 address is two parts
  252. assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42")
  253. def test_bad_address_split_v6_too_many_parts(self):
  254. def assertBadSplit(addr):
  255. msg = "Exactly 8 parts expected without '::' in %r"
  256. with self.assertAddressError(msg, addr):
  257. ipaddress.IPv6Address(addr)
  258. assertBadSplit("3ffe:0:0:0:0:0:0:0:1")
  259. assertBadSplit("9:8:7:6:5:4:3:2:1")
  260. assertBadSplit("7:6:5:4:3:2:1")
  261. # A trailing IPv4 address is two parts
  262. assertBadSplit("9:8:7:6:5:4:3:42.42.42.42")
  263. assertBadSplit("7:6:5:4:3:42.42.42.42")
  264. def test_bad_address_split_v6_too_many_parts_with_double_colon(self):
  265. def assertBadSplit(addr):
  266. msg = "Expected at most 7 other parts with '::' in %r"
  267. with self.assertAddressError(msg, addr):
  268. ipaddress.IPv6Address(addr)
  269. assertBadSplit("1:2:3:4::5:6:7:8")
  270. def test_bad_address_split_v6_repeated_double_colon(self):
  271. def assertBadSplit(addr):
  272. msg = "At most one '::' permitted in %r"
  273. with self.assertAddressError(msg, addr):
  274. ipaddress.IPv6Address(addr)
  275. assertBadSplit("3ffe::1::1")
  276. assertBadSplit("1::2::3::4:5")
  277. assertBadSplit("2001::db:::1")
  278. assertBadSplit("3ffe::1::")
  279. assertBadSplit("::3ffe::1")
  280. assertBadSplit(":3ffe::1::1")
  281. assertBadSplit("3ffe::1::1:")
  282. assertBadSplit(":3ffe::1::1:")
  283. assertBadSplit(":::")
  284. assertBadSplit('2001:db8:::1')
  285. def test_bad_address_split_v6_leading_colon(self):
  286. def assertBadSplit(addr):
  287. msg = "Leading ':' only permitted as part of '::' in %r"
  288. with self.assertAddressError(msg, addr):
  289. ipaddress.IPv6Address(addr)
  290. assertBadSplit(":2001:db8::1")
  291. assertBadSplit(":1:2:3:4:5:6:7")
  292. assertBadSplit(":1:2:3:4:5:6:")
  293. assertBadSplit(":6:5:4:3:2:1::")
  294. def test_bad_address_split_v6_trailing_colon(self):
  295. def assertBadSplit(addr):
  296. msg = "Trailing ':' only permitted as part of '::' in %r"
  297. with self.assertAddressError(msg, addr):
  298. ipaddress.IPv6Address(addr)
  299. assertBadSplit("2001:db8::1:")
  300. assertBadSplit("1:2:3:4:5:6:7:")
  301. assertBadSplit("::1.2.3.4:")
  302. assertBadSplit("::7:6:5:4:3:2:")
  303. def test_bad_v4_part_in(self):
  304. def assertBadAddressPart(addr, v4_error):
  305. with self.assertAddressError("%s in %r", v4_error, addr):
  306. ipaddress.IPv6Address(addr)
  307. assertBadAddressPart("3ffe::1.net", "Expected 4 octets in u?'1.net'")
  308. assertBadAddressPart("3ffe::127.0.1",
  309. "Expected 4 octets in u?'127.0.1'")
  310. assertBadAddressPart("::1.2.3",
  311. "Expected 4 octets in u?'1.2.3'")
  312. assertBadAddressPart("::1.2.3.4.5",
  313. "Expected 4 octets in u?'1.2.3.4.5'")
  314. assertBadAddressPart("3ffe::1.1.1.net",
  315. "Only decimal digits permitted in u?'net' "
  316. "in u?'1.1.1.net'")
  317. def test_invalid_characters(self):
  318. def assertBadPart(addr, part):
  319. msg = "Only hex digits permitted in %r in %r" % (part, addr)
  320. with self.assertAddressError(re.escape(msg)):
  321. ipaddress.IPv6Address(addr)
  322. assertBadPart("3ffe::goog", "goog")
  323. assertBadPart("3ffe::-0", "-0")
  324. assertBadPart("3ffe::+0", "+0")
  325. assertBadPart("3ffe::-1", "-1")
  326. assertBadPart("1.2.3.4::", "1.2.3.4")
  327. assertBadPart('1234:axy::b', "axy")
  328. def test_part_length(self):
  329. def assertBadPart(addr, part):
  330. msg = "At most 4 characters permitted in %r in %r"
  331. with self.assertAddressError(msg, part, addr):
  332. ipaddress.IPv6Address(addr)
  333. assertBadPart("::00000", "00000")
  334. assertBadPart("3ffe::10000", "10000")
  335. assertBadPart("02001:db8::", "02001")
  336. assertBadPart('2001:888888::1', "888888")
  337. def test_pickle(self):
  338. self.pickle_test('2001:db8::')
  339. def test_weakref(self):
  340. weakref.ref(self.factory('2001:db8::'))
  341. def test_bytes_message(self):
  342. with self.assertAddressError(r'bytes'):
  343. ipaddress.IPv6Address(b'::123')
  344. with self.assertAddressError(r'bytes'):
  345. ipaddress.ip_address(b'::123')
  346. class NetmaskTestMixin_v4(CommonTestMixin_v4):
  347. """Input validation on interfaces and networks is very similar"""
  348. def test_split_netmask(self):
  349. addr = "1.2.3.4/32/24"
  350. with self.assertAddressError("Only one '/' permitted in %r" % addr):
  351. self.factory(addr)
  352. def test_address_errors(self):
  353. def assertBadAddress(addr, details):
  354. with self.assertAddressError(details):
  355. self.factory(addr)
  356. assertBadAddress("/", "Address cannot be empty")
  357. assertBadAddress("/8", "Address cannot be empty")
  358. assertBadAddress("bogus", "Expected 4 octets")
  359. assertBadAddress("google.com", "Expected 4 octets")
  360. assertBadAddress("10/8", "Expected 4 octets")
  361. assertBadAddress("::1.2.3.4", "Only decimal digits")
  362. assertBadAddress("1.2.3.256", re.escape("256 (> 255)"))
  363. def test_valid_netmask(self):
  364. self.assertEqual(_compat_str(self.factory('192.0.2.0/255.255.255.0')),
  365. '192.0.2.0/24')
  366. for i in range(0, 33):
  367. # Generate and re-parse the CIDR format (trivial).
  368. net_str = '0.0.0.0/%d' % i
  369. net = self.factory(net_str)
  370. self.assertEqual(_compat_str(net), net_str)
  371. # Generate and re-parse the expanded netmask.
  372. self.assertEqual(
  373. _compat_str(self.factory('0.0.0.0/%s' % net.netmask)), net_str)
  374. # Zero prefix is treated as decimal.
  375. self.assertEqual(
  376. _compat_str(self.factory('0.0.0.0/0%d' % i)),
  377. net_str)
  378. # Generate and re-parse the expanded hostmask. The ambiguous
  379. # cases (/0 and /32) are treated as netmasks.
  380. if i in (32, 0):
  381. net_str = '0.0.0.0/%d' % (32 - i)
  382. self.assertEqual(
  383. _compat_str(self.factory('0.0.0.0/%s' % net.hostmask)),
  384. net_str)
  385. def test_netmask_errors(self):
  386. def assertBadNetmask(addr, netmask):
  387. msg = "%r is not a valid netmask" % netmask
  388. with self.assertNetmaskError(re.escape(msg)):
  389. self.factory("%s/%s" % (addr, netmask))
  390. assertBadNetmask("1.2.3.4", "")
  391. assertBadNetmask("1.2.3.4", "-1")
  392. assertBadNetmask("1.2.3.4", "+1")
  393. assertBadNetmask("1.2.3.4", " 1 ")
  394. assertBadNetmask("1.2.3.4", "0x1")
  395. assertBadNetmask("1.2.3.4", "33")
  396. assertBadNetmask("1.2.3.4", "254.254.255.256")
  397. assertBadNetmask("1.2.3.4", "1.a.2.3")
  398. assertBadNetmask("1.1.1.1", "254.xyz.2.3")
  399. assertBadNetmask("1.1.1.1", "240.255.0.0")
  400. assertBadNetmask("1.1.1.1", "255.254.128.0")
  401. assertBadNetmask("1.1.1.1", "0.1.127.255")
  402. assertBadNetmask("1.1.1.1", "pudding")
  403. assertBadNetmask("1.1.1.1", "::")
  404. def test_pickle(self):
  405. self.pickle_test('192.0.2.0/27')
  406. self.pickle_test('192.0.2.0/31') # IPV4LENGTH - 1
  407. self.pickle_test('192.0.2.0') # IPV4LENGTH
  408. class InterfaceTestCase_v4(BaseTestCase, NetmaskTestMixin_v4):
  409. factory = ipaddress.IPv4Interface
  410. class NetworkTestCase_v4(BaseTestCase, NetmaskTestMixin_v4):
  411. factory = ipaddress.IPv4Network
  412. def test_subnet_of(self):
  413. # containee left of container
  414. self.assertFalse(
  415. self.factory('10.0.0.0/30').subnet_of(
  416. self.factory('10.0.1.0/24')))
  417. # containee inside container
  418. self.assertTrue(
  419. self.factory('10.0.0.0/30').subnet_of(
  420. self.factory('10.0.0.0/24')))
  421. # containee right of container
  422. self.assertFalse(
  423. self.factory('10.0.0.0/30').subnet_of(
  424. self.factory('10.0.1.0/24')))
  425. # containee larger than container
  426. self.assertFalse(
  427. self.factory('10.0.1.0/24').subnet_of(
  428. self.factory('10.0.0.0/30')))
  429. def test_supernet_of(self):
  430. # containee left of container
  431. self.assertFalse(
  432. self.factory('10.0.0.0/30').supernet_of(
  433. self.factory('10.0.1.0/24')))
  434. # containee inside container
  435. self.assertFalse(
  436. self.factory('10.0.0.0/30').supernet_of(
  437. self.factory('10.0.0.0/24')))
  438. # containee right of container
  439. self.assertFalse(
  440. self.factory('10.0.0.0/30').supernet_of(
  441. self.factory('10.0.1.0/24')))
  442. # containee larger than container
  443. self.assertTrue(
  444. self.factory('10.0.0.0/24').supernet_of(
  445. self.factory('10.0.0.0/30')))
  446. def test_subnet_of_mixed_types(self):
  447. with self.assertRaises(TypeError):
  448. ipaddress.IPv4Network('10.0.0.0/30').supernet_of(
  449. ipaddress.IPv6Network('::1/128'))
  450. with self.assertRaises(TypeError):
  451. ipaddress.IPv6Network('::1/128').supernet_of(
  452. ipaddress.IPv4Network('10.0.0.0/30'))
  453. with self.assertRaises(TypeError):
  454. ipaddress.IPv4Network('10.0.0.0/30').subnet_of(
  455. ipaddress.IPv6Network('::1/128'))
  456. with self.assertRaises(TypeError):
  457. ipaddress.IPv6Network('::1/128').subnet_of(
  458. ipaddress.IPv4Network('10.0.0.0/30'))
  459. class NetmaskTestMixin_v6(CommonTestMixin_v6):
  460. """Input validation on interfaces and networks is very similar"""
  461. def test_split_netmask(self):
  462. addr = "cafe:cafe::/128/190"
  463. with self.assertAddressError("Only one '/' permitted in %r" % addr):
  464. self.factory(addr)
  465. def test_address_errors(self):
  466. def assertBadAddress(addr, details):
  467. with self.assertAddressError(details):
  468. self.factory(addr)
  469. assertBadAddress("/", "Address cannot be empty")
  470. assertBadAddress("/8", "Address cannot be empty")
  471. assertBadAddress("google.com", "At least 3 parts")
  472. assertBadAddress("1.2.3.4", "At least 3 parts")
  473. assertBadAddress("10/8", "At least 3 parts")
  474. assertBadAddress("1234:axy::b", "Only hex digits")
  475. def test_valid_netmask(self):
  476. # We only support CIDR for IPv6, because expanded netmasks are not
  477. # standard notation.
  478. self.assertEqual(
  479. _compat_str(self.factory('2001:db8::/32')),
  480. '2001:db8::/32')
  481. for i in range(0, 129):
  482. # Generate and re-parse the CIDR format (trivial).
  483. net_str = '::/%d' % i
  484. self.assertEqual(_compat_str(self.factory(net_str)), net_str)
  485. # Zero prefix is treated as decimal.
  486. self.assertEqual(_compat_str(self.factory('::/0%d' % i)), net_str)
  487. def test_netmask_errors(self):
  488. def assertBadNetmask(addr, netmask):
  489. msg = "%r is not a valid netmask" % netmask
  490. with self.assertNetmaskError(re.escape(msg)):
  491. self.factory("%s/%s" % (addr, netmask))
  492. assertBadNetmask("::1", "")
  493. assertBadNetmask("::1", "::1")
  494. assertBadNetmask("::1", "1::")
  495. assertBadNetmask("::1", "-1")
  496. assertBadNetmask("::1", "+1")
  497. assertBadNetmask("::1", " 1 ")
  498. assertBadNetmask("::1", "0x1")
  499. assertBadNetmask("::1", "129")
  500. assertBadNetmask("::1", "1.2.3.4")
  501. assertBadNetmask("::1", "pudding")
  502. assertBadNetmask("::", "::")
  503. def test_pickle(self):
  504. self.pickle_test('2001:db8::1000/124')
  505. self.pickle_test('2001:db8::1000/127') # IPV6LENGTH - 1
  506. self.pickle_test('2001:db8::1000') # IPV6LENGTH
  507. class InterfaceTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
  508. factory = ipaddress.IPv6Interface
  509. class NetworkTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
  510. factory = ipaddress.IPv6Network
  511. def test_subnet_of(self):
  512. # containee left of container
  513. self.assertFalse(
  514. self.factory('2000:999::/56').subnet_of(
  515. self.factory('2000:aaa::/48')))
  516. # containee inside container
  517. self.assertTrue(
  518. self.factory('2000:aaa::/56').subnet_of(
  519. self.factory('2000:aaa::/48')))
  520. # containee right of container
  521. self.assertFalse(
  522. self.factory('2000:bbb::/56').subnet_of(
  523. self.factory('2000:aaa::/48')))
  524. # containee larger than container
  525. self.assertFalse(
  526. self.factory('2000:aaa::/48').subnet_of(
  527. self.factory('2000:aaa::/56')))
  528. def test_supernet_of(self):
  529. # containee left of container
  530. self.assertFalse(
  531. self.factory('2000:999::/56').supernet_of(
  532. self.factory('2000:aaa::/48')))
  533. # containee inside container
  534. self.assertFalse(
  535. self.factory('2000:aaa::/56').supernet_of(
  536. self.factory('2000:aaa::/48')))
  537. # containee right of container
  538. self.assertFalse(
  539. self.factory('2000:bbb::/56').supernet_of(
  540. self.factory('2000:aaa::/48')))
  541. # containee larger than container
  542. self.assertTrue(
  543. self.factory('2000:aaa::/48').supernet_of(
  544. self.factory('2000:aaa::/56')))
  545. class FactoryFunctionErrors(BaseTestCase):
  546. def assertFactoryError(self, factory, kind):
  547. """Ensure a clean ValueError with the expected message"""
  548. addr = "camelot"
  549. msg = '%r does not appear to be an IPv4 or IPv6 %s'
  550. with self.assertCleanError(ValueError, msg, addr, kind):
  551. factory(addr)
  552. def test_ip_address(self):
  553. self.assertFactoryError(ipaddress.ip_address, "address")
  554. def test_ip_interface(self):
  555. self.assertFactoryError(ipaddress.ip_interface, "interface")
  556. def test_ip_network(self):
  557. self.assertFactoryError(ipaddress.ip_network, "network")
  558. class LargestObject(ipaddress._TotalOrderingMixin):
  559. def __eq__(self, other):
  560. return isinstance(other, LargestObject)
  561. def __lt__(self, other):
  562. return False
  563. class SmallestObject(ipaddress._TotalOrderingMixin):
  564. def __eq__(self, other):
  565. return isinstance(other, SmallestObject)
  566. def __lt__(self, other):
  567. return True
  568. class ComparisonTests(unittest.TestCase):
  569. v4addr = ipaddress.IPv4Address(1)
  570. v4net = ipaddress.IPv4Network(1)
  571. v4intf = ipaddress.IPv4Interface(1)
  572. v6addr = ipaddress.IPv6Address(1)
  573. v6net = ipaddress.IPv6Network(1)
  574. v6intf = ipaddress.IPv6Interface(1)
  575. v4_addresses = [v4addr, v4intf]
  576. v4_objects = v4_addresses + [v4net]
  577. v6_addresses = [v6addr, v6intf]
  578. v6_objects = v6_addresses + [v6net]
  579. objects = v4_objects + v6_objects
  580. v4addr2 = ipaddress.IPv4Address(2)
  581. v4net2 = ipaddress.IPv4Network(2)
  582. v4intf2 = ipaddress.IPv4Interface(2)
  583. v6addr2 = ipaddress.IPv6Address(2)
  584. v6net2 = ipaddress.IPv6Network(2)
  585. v6intf2 = ipaddress.IPv6Interface(2)
  586. def test_foreign_type_equality(self):
  587. # __eq__ should never raise TypeError directly
  588. other = object()
  589. for obj in self.objects:
  590. self.assertNotEqual(obj, other)
  591. self.assertFalse(obj == other)
  592. self.assertEqual(obj.__eq__(other), NotImplemented)
  593. self.assertEqual(obj.__ne__(other), NotImplemented)
  594. def test_mixed_type_equality(self):
  595. # Ensure none of the internal objects accidentally
  596. # expose the right set of attributes to become "equal"
  597. for lhs in self.objects:
  598. for rhs in self.objects:
  599. if lhs is rhs:
  600. continue
  601. self.assertNotEqual(lhs, rhs)
  602. def test_same_type_equality(self):
  603. for obj in self.objects:
  604. self.assertEqual(obj, obj)
  605. self.assertTrue(obj <= obj)
  606. self.assertTrue(obj >= obj)
  607. def test_same_type_ordering(self):
  608. for lhs, rhs in (
  609. (self.v4addr, self.v4addr2),
  610. (self.v4net, self.v4net2),
  611. (self.v4intf, self.v4intf2),
  612. (self.v6addr, self.v6addr2),
  613. (self.v6net, self.v6net2),
  614. (self.v6intf, self.v6intf2),
  615. ):
  616. self.assertNotEqual(lhs, rhs)
  617. self.assertTrue(lhs < rhs)
  618. self.assertTrue(lhs <= rhs)
  619. self.assertTrue(rhs > lhs)
  620. self.assertTrue(rhs >= lhs)
  621. self.assertFalse(lhs > rhs)
  622. self.assertFalse(rhs < lhs)
  623. self.assertFalse(lhs >= rhs)
  624. self.assertFalse(rhs <= lhs)
  625. def test_containment(self):
  626. for obj in self.v4_addresses:
  627. self.assertIn(obj, self.v4net)
  628. for obj in self.v6_addresses:
  629. self.assertIn(obj, self.v6net)
  630. for obj in self.v4_objects + [self.v6net]:
  631. self.assertNotIn(obj, self.v6net)
  632. for obj in self.v6_objects + [self.v4net]:
  633. self.assertNotIn(obj, self.v4net)
  634. def test_mixed_type_ordering(self):
  635. for lhs in self.objects:
  636. for rhs in self.objects:
  637. if isinstance(lhs, type(rhs)) or isinstance(rhs, type(lhs)):
  638. continue
  639. self.assertRaises(TypeError, lambda: lhs < rhs)
  640. self.assertRaises(TypeError, lambda: lhs > rhs)
  641. self.assertRaises(TypeError, lambda: lhs <= rhs)
  642. self.assertRaises(TypeError, lambda: lhs >= rhs)
  643. def test_foreign_type_ordering(self):
  644. # In Python 2.x, the semantics are much less convenient, so skip all of
  645. # these tests there.
  646. if sys.version_info < (3, 0):
  647. return
  648. other = object()
  649. smallest = SmallestObject()
  650. largest = LargestObject()
  651. for obj in self.objects:
  652. with self.assertRaises(TypeError):
  653. obj < other
  654. with self.assertRaises(TypeError):
  655. obj > other
  656. with self.assertRaises(TypeError):
  657. obj <= other
  658. with self.assertRaises(TypeError):
  659. obj >= other
  660. self.assertTrue(obj < largest)
  661. self.assertFalse(obj > largest)
  662. self.assertTrue(obj <= largest)
  663. self.assertFalse(obj >= largest)
  664. self.assertFalse(obj < smallest)
  665. self.assertTrue(obj > smallest)
  666. self.assertFalse(obj <= smallest)
  667. self.assertTrue(obj >= smallest)
  668. def test_mixed_type_key(self):
  669. # with get_mixed_type_key, you can sort addresses and network.
  670. v4_ordered = [self.v4addr, self.v4net, self.v4intf]
  671. v6_ordered = [self.v6addr, self.v6net, self.v6intf]
  672. self.assertEqual(v4_ordered,
  673. sorted(self.v4_objects,
  674. key=ipaddress.get_mixed_type_key))
  675. self.assertEqual(v6_ordered,
  676. sorted(self.v6_objects,
  677. key=ipaddress.get_mixed_type_key))
  678. self.assertEqual(v4_ordered + v6_ordered,
  679. sorted(self.objects,
  680. key=ipaddress.get_mixed_type_key))
  681. self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object))
  682. def test_incompatible_versions(self):
  683. # These should always raise TypeError
  684. v4addr = ipaddress.ip_address('1.1.1.1')
  685. v4net = ipaddress.ip_network('1.1.1.1')
  686. v6addr = ipaddress.ip_address('::1')
  687. v6net = ipaddress.ip_network('::1')
  688. self.assertRaises(TypeError, v4addr.__lt__, v6addr)
  689. self.assertRaises(TypeError, v4addr.__gt__, v6addr)
  690. self.assertRaises(TypeError, v4net.__lt__, v6net)
  691. self.assertRaises(TypeError, v4net.__gt__, v6net)
  692. self.assertRaises(TypeError, v6addr.__lt__, v4addr)
  693. self.assertRaises(TypeError, v6addr.__gt__, v4addr)
  694. self.assertRaises(TypeError, v6net.__lt__, v4net)
  695. self.assertRaises(TypeError, v6net.__gt__, v4net)
  696. class IpaddrUnitTest(unittest.TestCase):
  697. def setUp(self):
  698. self.ipv4_address = ipaddress.IPv4Address('1.2.3.4')
  699. self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24')
  700. self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24')
  701. self.ipv6_address = ipaddress.IPv6Interface(
  702. '2001:658:22a:cafe:200:0:0:1')
  703. self.ipv6_interface = ipaddress.IPv6Interface(
  704. '2001:658:22a:cafe:200:0:0:1/64')
  705. self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
  706. def testRepr(self):
  707. self.assertTrue(re.match("IPv4Interface\(u?'1.2.3.4/32'\)",
  708. repr(ipaddress.IPv4Interface('1.2.3.4'))))
  709. self.assertTrue(re.match("IPv6Interface\(u?'::1/128'\)",
  710. repr(ipaddress.IPv6Interface('::1'))))
  711. # issue #16531: constructing IPv4Network from an (address, mask) tuple
  712. def testIPv4Tuple(self):
  713. # /32
  714. ip = ipaddress.IPv4Address('192.0.2.1')
  715. net = ipaddress.IPv4Network('192.0.2.1/32')
  716. self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 32)), net)
  717. self.assertEqual(ipaddress.IPv4Network((ip, 32)), net)
  718. self.assertEqual(ipaddress.IPv4Network((3221225985, 32)), net)
  719. self.assertEqual(ipaddress.IPv4Network(('192.0.2.1',
  720. '255.255.255.255')), net)
  721. self.assertEqual(ipaddress.IPv4Network((ip,
  722. '255.255.255.255')), net)
  723. self.assertEqual(ipaddress.IPv4Network((3221225985,
  724. '255.255.255.255')), net)
  725. # strict=True and host bits set
  726. self.assertRaises(ValueError, ipaddress.IPv4Network, ('192.0.2.1', 24))
  727. self.assertRaises(ValueError, ipaddress.IPv4Network, (ip, 24))
  728. self.assertRaises(ValueError, ipaddress.IPv4Network, (3221225985, 24))
  729. self.assertRaises(
  730. ValueError, ipaddress.IPv4Network, ('192.0.2.1', '255.255.255.0'))
  731. self.assertRaises(
  732. ValueError, ipaddress.IPv4Network, (ip, '255.255.255.0'))
  733. self.assertRaises(
  734. ValueError, ipaddress.IPv4Network, (3221225985, '255.255.255.0'))
  735. # strict=False and host bits set
  736. net = ipaddress.IPv4Network('192.0.2.0/24')
  737. self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 24),
  738. strict=False), net)
  739. self.assertEqual(ipaddress.IPv4Network((ip, 24),
  740. strict=False), net)
  741. self.assertEqual(ipaddress.IPv4Network((3221225985, 24),
  742. strict=False), net)
  743. self.assertEqual(ipaddress.IPv4Network(('192.0.2.1',
  744. '255.255.255.0'),
  745. strict=False), net)
  746. self.assertEqual(ipaddress.IPv4Network((ip,
  747. '255.255.255.0'),
  748. strict=False), net)
  749. self.assertEqual(ipaddress.IPv4Network((3221225985,
  750. '255.255.255.0'),
  751. strict=False), net)
  752. # /24
  753. ip = ipaddress.IPv4Address('192.0.2.0')
  754. net = ipaddress.IPv4Network('192.0.2.0/24')
  755. self.assertEqual(ipaddress.IPv4Network(('192.0.2.0',
  756. '255.255.255.0')), net)
  757. self.assertEqual(ipaddress.IPv4Network((ip,
  758. '255.255.255.0')), net)
  759. self.assertEqual(ipaddress.IPv4Network((3221225984,
  760. '255.255.255.0')), net)
  761. self.assertEqual(ipaddress.IPv4Network(('192.0.2.0', 24)), net)
  762. self.assertEqual(ipaddress.IPv4Network((ip, 24)), net)
  763. self.assertEqual(ipaddress.IPv4Network((3221225984, 24)), net)
  764. self.assertEqual(ipaddress.IPv4Interface(('192.0.2.1', 24)),
  765. ipaddress.IPv4Interface('192.0.2.1/24'))
  766. self.assertEqual(ipaddress.IPv4Interface((3221225985, 24)),
  767. ipaddress.IPv4Interface('192.0.2.1/24'))
  768. # issue #16531: constructing IPv6Network from an (address, mask) tuple
  769. def testIPv6Tuple(self):
  770. # /128
  771. ip = ipaddress.IPv6Address('2001:db8::')
  772. net = ipaddress.IPv6Network('2001:db8::/128')
  773. self.assertEqual(
  774. ipaddress.IPv6Network(('2001:db8::', '128')),
  775. net)
  776. self.assertEqual(
  777. ipaddress.IPv6Network(
  778. (42540766411282592856903984951653826560, 128)),
  779. net)
  780. self.assertEqual(ipaddress.IPv6Network((ip, '128')),
  781. net)
  782. ip = ipaddress.IPv6Address('2001:db8::')
  783. net = ipaddress.IPv6Network('2001:db8::/96')
  784. self.assertEqual(
  785. ipaddress.IPv6Network(('2001:db8::', '96')),
  786. net)
  787. self.assertEqual(
  788. ipaddress.IPv6Network(
  789. (42540766411282592856903984951653826560, 96)),
  790. net)
  791. self.assertEqual(
  792. ipaddress.IPv6Network((ip, '96')),
  793. net)
  794. # strict=True and host bits set
  795. ip = ipaddress.IPv6Address('2001:db8::1')
  796. self.assertRaises(
  797. ValueError, ipaddress.IPv6Network, ('2001:db8::1', 96))
  798. self.assertRaises(
  799. ValueError, ipaddress.IPv6Network,
  800. (42540766411282592856903984951653826561, 96))
  801. self.assertRaises(ValueError, ipaddress.IPv6Network, (ip, 96))
  802. # strict=False and host bits set
  803. net = ipaddress.IPv6Network('2001:db8::/96')
  804. self.assertEqual(ipaddress.IPv6Network(('2001:db8::1', 96),
  805. strict=False),
  806. net)
  807. self.assertEqual(
  808. ipaddress.IPv6Network(
  809. (42540766411282592856903984951653826561, 96), strict=False),
  810. net)
  811. self.assertEqual(
  812. ipaddress.IPv6Network((ip, 96), strict=False),
  813. net)
  814. # /96
  815. self.assertEqual(ipaddress.IPv6Interface(('2001:db8::1', '96')),
  816. ipaddress.IPv6Interface('2001:db8::1/96'))
  817. self.assertEqual(
  818. ipaddress.IPv6Interface(
  819. (42540766411282592856903984951653826561, '96')),
  820. ipaddress.IPv6Interface('2001:db8::1/96'))
  821. # issue57
  822. def testAddressIntMath(self):
  823. self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255,
  824. ipaddress.IPv4Address('1.1.2.0'))
  825. self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256,
  826. ipaddress.IPv4Address('1.1.0.1'))
  827. self.assertEqual(ipaddress.IPv6Address('::1') + (2 ** 16 - 2),
  828. ipaddress.IPv6Address('::ffff'))
  829. self.assertEqual(ipaddress.IPv6Address('::ffff') - (2 ** 16 - 2),
  830. ipaddress.IPv6Address('::1'))
  831. def testInvalidIntToBytes(self):
  832. self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1)
  833. self.assertRaises(ValueError, ipaddress.v4_int_to_packed,
  834. 2 ** ipaddress.IPV4LENGTH)
  835. self.assertRaises(ValueError, ipaddress.v6_int_to_packed, -1)
  836. self.assertRaises(ValueError, ipaddress.v6_int_to_packed,
  837. 2 ** ipaddress.IPV6LENGTH)
  838. def testInternals(self):
  839. ip1 = ipaddress.IPv4Address('10.10.10.10')
  840. ip2 = ipaddress.IPv4Address('10.10.10.11')
  841. ip3 = ipaddress.IPv4Address('10.10.10.12')
  842. self.assertEqual(list(ipaddress._find_address_range([ip1])),
  843. [(ip1, ip1)])
  844. self.assertEqual(list(ipaddress._find_address_range([ip1, ip3])),
  845. [(ip1, ip1), (ip3, ip3)])
  846. self.assertEqual(list(ipaddress._find_address_range([ip1, ip2, ip3])),
  847. [(ip1, ip3)])
  848. self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128))
  849. self.assertTrue(
  850. re.match("IPv4Network\(u?'1.2.3.0/24'\)", repr(self.ipv4_network)))
  851. def testMissingAddressVersion(self):
  852. class Broken(ipaddress._BaseAddress):
  853. pass
  854. broken = Broken()
  855. with self.assertRaisesRegex(NotImplementedError, "Broken.*version"):
  856. broken.version
  857. def testMissingNetworkVersion(self):
  858. class Broken(ipaddress._BaseNetwork):
  859. pass
  860. broken = Broken('127.0.0.1')
  861. with self.assertRaisesRegex(NotImplementedError, "Broken.*version"):
  862. broken.version
  863. def testMissingAddressClass(self):
  864. class Broken(ipaddress._BaseNetwork):
  865. pass
  866. broken = Broken('127.0.0.1')
  867. with self.assertRaisesRegex(NotImplementedError, "Broken.*address"):
  868. broken._address_class
  869. def testGetNetwork(self):
  870. self.assertEqual(int(self.ipv4_network.network_address), 16909056)
  871. self.assertEqual(
  872. _compat_str(self.ipv4_network.network_address),
  873. '1.2.3.0')
  874. self.assertEqual(int(self.ipv6_network.network_address),
  875. 42540616829182469433403647294022090752)
  876. self.assertEqual(_compat_str(self.ipv6_network.network_address),
  877. '2001:658:22a:cafe::')
  878. self.assertEqual(_compat_str(self.ipv6_network.hostmask),
  879. '::ffff:ffff:ffff:ffff')
  880. def testIpFromInt(self):
  881. self.assertEqual(self.ipv4_interface._ip,
  882. ipaddress.IPv4Interface(16909060)._ip)
  883. ipv4 = ipaddress.ip_network('1.2.3.4')
  884. ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1')
  885. self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4.network_address)))
  886. self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6.network_address)))
  887. v6_int = 42540616829182469433547762482097946625
  888. self.assertEqual(self.ipv6_interface._ip,
  889. ipaddress.IPv6Interface(v6_int)._ip)
  890. self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version,
  891. 4)
  892. self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version,
  893. 6)
  894. def testIpFromPacked(self):
  895. address = ipaddress.ip_address
  896. self.assertEqual(self.ipv4_interface._ip,
  897. ipaddress.ip_interface(b'\x01\x02\x03\x04')._ip)
  898. self.assertEqual(address('255.254.253.252'),
  899. address(b'\xff\xfe\xfd\xfc'))
  900. self.assertEqual(
  901. self.ipv6_interface.ip,
  902. ipaddress.ip_interface(
  903. b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
  904. b'\x02\x00\x00\x00\x00\x00\x00\x01').ip)
  905. self.assertEqual(
  906. address('ffff:2:3:4:ffff::'),
  907. address(b'\xff\xff\x00\x02\x00\x03\x00\x04' +
  908. b'\xff\xff' + b'\x00' * 6))
  909. self.assertEqual(address('::'),
  910. address(b'\x00' * 16))
  911. def testGetIp(self):
  912. self.assertEqual(int(self.ipv4_interface.ip), 16909060)
  913. self.assertEqual(_compat_str(self.ipv4_interface.ip), '1.2.3.4')
  914. self.assertEqual(int(self.ipv6_interface.ip),
  915. 42540616829182469433547762482097946625)
  916. self.assertEqual(_compat_str(self.ipv6_interface.ip),
  917. '2001:658:22a:cafe:200::1')
  918. def testGetNetmask(self):
  919. self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
  920. self.assertEqual(
  921. _compat_str(self.ipv4_network.netmask),
  922. '255.255.255.0')
  923. self.assertEqual(int(self.ipv6_network.netmask),
  924. 340282366920938463444927863358058659840)
  925. self.assertEqual(self.ipv6_network.prefixlen, 64)
  926. def testZeroNetmask(self):
  927. ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
  928. self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
  929. self.assertEqual(ipv4_zero_netmask._prefix_from_prefix_string('0'), 0)
  930. # Removed all _is_valid_netmask tests - the method was unused upstream
  931. ipv6_zero_netmask = ipaddress.IPv6Interface('::1/0')
  932. self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
  933. self.assertEqual(ipv6_zero_netmask._prefix_from_prefix_string('0'), 0)
  934. def testIPv4NetAndHostmasks(self):
  935. net = self.ipv4_network
  936. # Removed all _is_valid_netmask tests - the method was unused upstream
  937. self.assertFalse(net._is_hostmask('invalid'))
  938. self.assertTrue(net._is_hostmask('128.255.255.255'))
  939. self.assertFalse(net._is_hostmask('255.255.255.255'))
  940. self.assertFalse(net._is_hostmask('1.2.3.4'))
  941. net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255')
  942. self.assertEqual(net.prefixlen, 24)
  943. def testGetBroadcast(self):
  944. self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
  945. self.assertEqual(
  946. _compat_str(self.ipv4_network.broadcast_address),
  947. '1.2.3.255')
  948. self.assertEqual(int(self.ipv6_network.broadcast_address),
  949. 42540616829182469451850391367731642367)
  950. self.assertEqual(_compat_str(self.ipv6_network.broadcast_address),
  951. '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
  952. def testGetPrefixlen(self):
  953. self.assertEqual(self.ipv4_interface.network.prefixlen, 24)
  954. self.assertEqual(self.ipv6_interface.network.prefixlen, 64)
  955. def testGetSupernet(self):
  956. self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
  957. self.assertEqual(
  958. _compat_str(self.ipv4_network.supernet().network_address),
  959. '1.2.2.0')
  960. self.assertEqual(
  961. ipaddress.IPv4Interface('0.0.0.0/0').network.supernet(),
  962. ipaddress.IPv4Network('0.0.0.0/0'))
  963. self.assertEqual(self.ipv6_network.supernet().prefixlen, 63)
  964. self.assertEqual(
  965. _compat_str(self.ipv6_network.supernet().network_address),
  966. '2001:658:22a:cafe::')
  967. self.assertEqual(
  968. ipaddress.IPv6Interface('::0/0').network.supernet(),
  969. ipaddress.IPv6Network('::0/0'))
  970. def testGetSupernet3(self):
  971. self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
  972. self.assertEqual(
  973. _compat_str(self.ipv4_network.supernet(3).network_address),
  974. '1.2.0.0')
  975. self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
  976. self.assertEqual(
  977. _compat_str(self.ipv6_network.supernet(3).network_address),
  978. '2001:658:22a:caf8::')
  979. def testGetSupernet4(self):
  980. self.assertRaises(ValueError, self.ipv4_network.supernet,
  981. prefixlen_diff=2, new_prefix=1)
  982. self.assertRaises(ValueError, self.ipv4_network.supernet,
  983. new_prefix=25)
  984. self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2),
  985. self.ipv4_network.supernet(new_prefix=22))
  986. self.assertRaises(ValueError, self.ipv6_network.supernet,
  987. prefixlen_diff=2, new_prefix=1)
  988. self.assertRaises(ValueError, self.ipv6_network.supernet,
  989. new_prefix=65)
  990. self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
  991. self.ipv6_network.supernet(new_prefix=62))
  992. def testHosts(self):
  993. hosts = list(self.ipv4_network.hosts())
  994. self.assertEqual(254, len(hosts))
  995. self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0])
  996. self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1])
  997. # special case where only 1 bit is left for address
  998. self.assertEqual([ipaddress.IPv4Address('2.0.0.0'),
  999. ipaddress.IPv4Address('2.0.0.1')],
  1000. list(ipaddress.ip_network('2.0.0.0/31').hosts()))
  1001. def testFancySubnetting(self):
  1002. self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),
  1003. sorted(self.ipv4_network.subnets(new_prefix=27)))
  1004. self.assertRaises(ValueError, list,
  1005. self.ipv4_network.subnets(new_prefix=23))
  1006. self.assertRaises(ValueError, list,
  1007. self.ipv4_network.subnets(prefixlen_diff=3,
  1008. new_prefix=27))
  1009. self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)),
  1010. sorted(self.ipv6_network.subnets(new_prefix=68)))
  1011. self.assertRaises(ValueError, list,
  1012. self.ipv6_network.subnets(new_prefix=63))
  1013. self.assertRaises(ValueError, list,
  1014. self.ipv6_network.subnets(prefixlen_diff=4,
  1015. new_prefix=68))
  1016. def testGetSubnets(self):
  1017. self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
  1018. self.assertEqual(
  1019. _compat_str(list(self.ipv4_network.subnets())[0].network_address),
  1020. '1.2.3.0')
  1021. self.assertEqual(
  1022. _compat_str(list(self.ipv4_network.subnets())[1].network_address),
  1023. '1.2.3.128')
  1024. self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
  1025. def testGetSubnetForSingle32(self):
  1026. ip = ipaddress.IPv4Network('1.2.3.4/32')
  1027. subnets1 = [_compat_str(x) for x in ip.subnets()]
  1028. subnets2 = [_compat_str(x) for x in ip.subnets(2)]
  1029. self.assertEqual(subnets1, ['1.2.3.4/32'])
  1030. self.assertEqual(subnets1, subnets2)
  1031. def testGetSubnetForSingle128(self):
  1032. ip = ipaddress.IPv6Network('::1/128')
  1033. subnets1 = [_compat_str(x) for x in ip.subnets()]
  1034. subnets2 = [_compat_str(x) for x in ip.subnets(2)]
  1035. self.assertEqual(subnets1, ['::1/128'])
  1036. self.assertEqual(subnets1, subnets2)
  1037. def testSubnet2(self):
  1038. ips = [str(x) for x in self.ipv4_network.subnets(2)]
  1039. self.assertEqual(
  1040. ips,
  1041. ['1.2.3.0/26', '1.2.3.64/26', '1.2.3.128/26', '1.2.3.192/26'])
  1042. ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)]
  1043. self.assertEqual(
  1044. ipsv6,
  1045. ['2001:658:22a:cafe::/66',
  1046. '2001:658:22a:cafe:4000::/66',
  1047. '2001:658:22a:cafe:8000::/66',
  1048. '2001:658:22a:cafe:c000::/66'])
  1049. def testGetSubnets3(self):
  1050. subnets = [str(x) for x in self.ipv4_network.subnets(8)]
  1051. self.assertEqual(
  1052. subnets[:3],
  1053. ['1.2.3.0/32', '1.2.3.1/32', '1.2.3.2/32'])
  1054. self.assertEqual(
  1055. subnets[-3:],
  1056. ['1.2.3.253/32', '1.2.3.254/32', '1.2.3.255/32'])
  1057. self.assertEqual(len(subnets), 256)
  1058. ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120')
  1059. subnets = [str(x) for x in ipv6_network.subnets(8)]
  1060. self.assertEqual(
  1061. subnets[:3],
  1062. ['2001:658:22a:cafe::/128',
  1063. '2001:658:22a:cafe::1/128',
  1064. '2001:658:22a:cafe::2/128'])
  1065. self.assertEqual(
  1066. subnets[-3:],
  1067. ['2001:658:22a:cafe::fd/128',
  1068. '2001:658:22a:cafe::fe/128',
  1069. '2001:658:22a:cafe::ff/128'])
  1070. self.assertEqual(len(subnets), 256)
  1071. def testSubnetFailsForLargeCidrDiff(self):
  1072. self.assertRaises(ValueError, list,
  1073. self.ipv4_interface.network.subnets(9))
  1074. self.assertRaises(ValueError, list,
  1075. self.ipv4_network.subnets(9))
  1076. self.assertRaises(ValueError, list,
  1077. self.ipv6_interface.network.subnets(65))
  1078. self.assertRaises(ValueError, list,
  1079. self.ipv6_network.subnets(65))
  1080. def testSupernetFailsForLargeCidrDiff(self):
  1081. self.assertRaises(ValueError,
  1082. self.ipv4_interface.network.supernet, 25)
  1083. self.assertRaises(ValueError,
  1084. self.ipv6_interface.network.supernet, 65)
  1085. def testSubnetFailsForNegativeCidrDiff(self):
  1086. self.assertRaises(ValueError, list,
  1087. self.ipv4_interface.network.subnets(-1))
  1088. self.assertRaises(ValueError, list,
  1089. self.ipv4_network.subnets(-1))
  1090. self.assertRaises(ValueError, list,
  1091. self.ipv6_interface.network.subnets(-1))
  1092. self.assertRaises(ValueError, list,
  1093. self.ipv6_network.subnets(-1))
  1094. def testGetNum_Addresses(self):
  1095. self.assertEqual(self.ipv4_network.num_addresses, 256)
  1096. self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses,
  1097. 128)
  1098. self.assertEqual(self.ipv4_network.supernet().num_addresses, 512)
  1099. self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616)
  1100. self.assertEqual(list(self.ipv6_network.subnets())[0].num_addresses,
  1101. 9223372036854775808)
  1102. self.assertEqual(self.ipv6_network.supernet().num_addresses,
  1103. 36893488147419103232)
  1104. def testContains(self):
  1105. self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in
  1106. self.ipv4_network)
  1107. self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in
  1108. self.ipv4_network)
  1109. # We can test addresses and string as well.
  1110. addr1 = ipaddress.IPv4Address('1.2.3.37')
  1111. self.assertTrue(addr1 in self.ipv4_network)
  1112. # issue 61, bad network comparison on like-ip'd network objects
  1113. # with identical broadcast addresses.
  1114. self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__(
  1115. ipaddress.IPv4Network('1.0.0.0/15')))
  1116. def testNth(self):
  1117. self.assertEqual(_compat_str(self.ipv4_network[5]), '1.2.3.5')
  1118. self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256)
  1119. self.assertEqual(_compat_str(self.ipv6_network[5]),
  1120. '2001:658:22a:cafe::5')
  1121. self.assertRaises(IndexError, self.ipv6_network.__getitem__, 1 << 64)
  1122. def testGetitem(self):
  1123. # http://code.google.com/p/ipaddr-py/issues/detail?id=15
  1124. addr = ipaddress.IPv4Network('172.31.255.128/255.255.255.240')
  1125. self.assertEqual(28, addr.prefixlen)
  1126. addr_list = list(addr)
  1127. self.assertEqual('172.31.255.128', str(addr_list[0]))
  1128. self.assertEqual('172.31.255.128', str(addr[0]))
  1129. self.assertEqual('172.31.255.143', str(addr_list[-1]))
  1130. self.assertEqual('172.31.255.143', str(addr[-1]))
  1131. self.assertEqual(addr_list[-1], addr[-1])
  1132. def testEqual(self):
  1133. self.assertTrue(self.ipv4_interface ==
  1134. ipaddress.IPv4Interface('1.2.3.4/24'))
  1135. self.assertFalse(self.ipv4_interface ==
  1136. ipaddress.IPv4Interface('1.2.3.4/23'))
  1137. self.assertFalse(self.ipv4_interface ==
  1138. ipaddress.IPv6Interface('::1.2.3.4/24'))
  1139. self.assertFalse(self.ipv4_interface == '')
  1140. self.assertFalse(self.ipv4_interface == [])
  1141. self.assertFalse(self.ipv4_interface == 2)
  1142. self.assertTrue(
  1143. self.ipv6_interface ==
  1144. ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
  1145. self.assertFalse(
  1146. self.ipv6_interface ==
  1147. ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
  1148. self.assertFalse(self.ipv6_interface ==
  1149. ipaddress.IPv4Interface('1.2.3.4/23'))
  1150. self.assertFalse(self.ipv6_interface == '')
  1151. self.assertFalse(self.ipv6_interface == [])
  1152. self.assertFalse(self.ipv6_interface == 2)
  1153. def testNotEqual(self):
  1154. self.assertFalse(self.ipv4_interface !=
  1155. ipaddress.IPv4Interface('1.2.3.4/24'))
  1156. self.assertTrue(self.ipv4_interface !=
  1157. ipaddress.IPv4Interface('1.2.3.4/23'))
  1158. self.assertTrue(self.ipv4_interface !=
  1159. ipaddress.IPv6Interface('::1.2.3.4/24'))
  1160. self.assertTrue(self.ipv4_interface != '')
  1161. self.assertTrue(self.ipv4_interface != [])
  1162. self.assertTrue(self.ipv4_interface != 2)
  1163. self.assertTrue(self.ipv4_address !=
  1164. ipaddress.IPv4Address('1.2.3.5'))
  1165. self.assertTrue(self.ipv4_address != '')
  1166. self.assertTrue(self.ipv4_address != [])
  1167. self.assertTrue(self.ipv4_address != 2)
  1168. self.assertFalse(
  1169. self.ipv6_interface !=
  1170. ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
  1171. self.assertTrue(
  1172. self.ipv6_interface !=
  1173. ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
  1174. self.assertTrue(self.ipv6_interface !=
  1175. ipaddress.IPv4Interface('1.2.3.4/23'))
  1176. self.assertTrue(self.ipv6_interface != '')
  1177. self.assertTrue(self.ipv6_interface != [])
  1178. self.assertTrue(self.ipv6_interface != 2)
  1179. self.assertTrue(self.ipv6_address !=
  1180. ipaddress.IPv4Address('1.2.3.4'))
  1181. self.assertTrue(self.ipv6_address != '')
  1182. self.assertTrue(self.ipv6_address != [])
  1183. self.assertTrue(self.ipv6_address != 2)
  1184. def testSlash32Constructor(self):
  1185. self.assertEqual(
  1186. _compat_str(ipaddress.IPv4Interface('1.2.3.4/255.255.255.255')),
  1187. '1.2.3.4/32')
  1188. def testSlash128Constructor(self):
  1189. self.assertEqual(
  1190. _compat_str(ipaddress.IPv6Interface('::1/128')),
  1191. '::1/128')
  1192. def testSlash0Constructor(self):
  1193. self.assertEqual(
  1194. _compat_str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
  1195. '1.2.3.4/0')
  1196. def testCollapsing(self):
  1197. # test only IP addresses including some duplicates
  1198. ip1 = ipaddress.IPv4Address('1.1.1.0')
  1199. ip2 = ipaddress.IPv4Address('1.1.1.1')
  1200. ip3 = ipaddress.IPv4Address('1.1.1.2')
  1201. ip4 = ipaddress.IPv4Address('1.1.1.3')
  1202. ip5 = ipaddress.IPv4Address('1.1.1.4')
  1203. ip6 = ipaddress.IPv4Address('1.1.1.0')
  1204. # check that addresses are subsumed properly.
  1205. collapsed = ipaddress.collapse_addresses(
  1206. [ip1, ip2, ip3, ip4, ip5, ip6])
  1207. self.assertEqual(
  1208. list(collapsed),
  1209. [ipaddress.IPv4Network('1.1.1.0/30'),
  1210. ipaddress.IPv4Network('1.1.1.4/32')])
  1211. # test a mix of IP addresses and networks including some duplicates
  1212. ip1 = ipaddress.IPv4Address('1.1.1.0')
  1213. ip2 = ipaddress.IPv4Address('1.1.1.1')
  1214. ip3 = ipaddress.IPv4Address('1.1.1.2')
  1215. ip4 = ipaddress.IPv4Address('1.1.1.3')
  1216. # check that addreses are subsumed properly.
  1217. collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3, ip4])
  1218. self.assertEqual(list(collapsed),
  1219. [ipaddress.IPv4Network('1.1.1.0/30')])
  1220. # test only IP networks
  1221. ip1 = ipaddress.IPv4Network('1.1.0.0/24')
  1222. ip2 = ipaddress.IPv4Network('1.1.1.0/24')
  1223. ip3 = ipaddress.IPv4Network('1.1.2.0/24')
  1224. ip4 = ipaddress.IPv4Network('1.1.3.0/24')
  1225. ip5 = ipaddress.IPv4Network('1.1.4.0/24')
  1226. # stored in no particular order b/c we want CollapseAddr to call
  1227. # [].sort
  1228. ip6 = ipaddress.IPv4Network('1.1.0.0/22')
  1229. # check that addreses are subsumed properly.
  1230. collapsed = ipaddress.collapse_addresses(
  1231. [ip1, ip2, ip3, ip4, ip5, ip6])
  1232. self.assertEqual(list(collapsed),
  1233. [ipaddress.IPv4Network('1.1.0.0/22'),
  1234. ipaddress.IPv4Network('1.1.4.0/24')])
  1235. # test that two addresses are supernet'ed properly
  1236. collapsed = ipaddress.collapse_addresses([ip1, ip2])
  1237. self.assertEqual(list(collapsed),
  1238. [ipaddress.IPv4Network('1.1.0.0/23')])
  1239. # test same IP networks
  1240. ip_same1 = ip_same2 = ipaddress.IPv4Network('1.1.1.1/32')
  1241. self.assertEqual(
  1242. list(ipaddress.collapse_addresses([ip_same1, ip_same2])),
  1243. [ip_same1])
  1244. # test same IP addresses
  1245. ip_same1 = ip_same2 = ipaddress.IPv4Address('1.1.1.1')
  1246. self.assertEqual(
  1247. list(ipaddress.collapse_addresses([ip_same1, ip_same2])),
  1248. [ipaddress.ip_network('1.1.1.1/32')])
  1249. ip1 = ipaddress.IPv6Network('2001::/100')
  1250. ip2 = ipaddress.IPv6Network('2001::/120')
  1251. ip3 = ipaddress.IPv6Network('2001::/96')
  1252. # test that ipv6 addresses are subsumed properly.
  1253. collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3])
  1254. self.assertEqual(list(collapsed), [ip3])
  1255. # the toejam test
  1256. addr_tuples = [
  1257. (ipaddress.ip_address('1.1.1.1'),
  1258. ipaddress.ip_address('::1')),
  1259. (ipaddress.IPv4Network('1.1.0.0/24'),
  1260. ipaddress.IPv6Network('2001::/120')),
  1261. (ipaddress.IPv4Network('1.1.0.0/32'),
  1262. ipaddress.IPv6Network('2001::/128')),
  1263. ]
  1264. for ip1, ip2 in addr_tuples:
  1265. self.assertRaises(TypeError, ipaddress.collapse_addresses,
  1266. [ip1, ip2])
  1267. def testSummarizing(self):
  1268. summarize = ipaddress.summarize_address_range
  1269. ip1 = ipaddress.ip_address('1.1.1.0')
  1270. ip2 = ipaddress.ip_address('1.1.1.255')
  1271. # summarize works only for IPv4 & IPv6
  1272. class IPv7Address(ipaddress.IPv6Address):
  1273. @property
  1274. def version(self):
  1275. return 7
  1276. ip_invalid1 = IPv7Address('::1')
  1277. ip_invalid2 = IPv7Address('::1')
  1278. self.assertRaises(ValueError, list,
  1279. summarize(ip_invalid1, ip_invalid2))
  1280. # test that a summary over ip4 & ip6 fails
  1281. self.assertRaises(TypeError, list,
  1282. summarize(ip1, ipaddress.IPv6Address('::1')))
  1283. # test a /24 is summarized properly
  1284. self.assertEqual(list(summarize(ip1, ip2))[0],
  1285. ipaddress.ip_network('1.1.1.0/24'))
  1286. # test an IPv4 range that isn't on a network byte boundary
  1287. ip2 = ipaddress.ip_address('1.1.1.8')
  1288. self.assertEqual(list(summarize(ip1, ip2)),
  1289. [ipaddress.ip_network('1.1.1.0/29'),
  1290. ipaddress.ip_network('1.1.1.8')])
  1291. # all!
  1292. ip1 = ipaddress.IPv4Address(0)
  1293. ip2 = ipaddress.IPv4Address(ipaddress.IPv4Address._ALL_ONES)
  1294. self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')],
  1295. list(summarize(ip1, ip2)))
  1296. ip1 = ipaddress.ip_address('1::')
  1297. ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
  1298. # test an IPv6 is summarized properly
  1299. self.assertEqual(list(summarize(ip1, ip2))[0],
  1300. ipaddress.ip_network('1::/16'))
  1301. # test an IPv6 range that isn't on a network byte boundary
  1302. ip2 = ipaddress.ip_address('2::')
  1303. self.assertEqual(list(summarize(ip1, ip2)),
  1304. [ipaddress.ip_network('1::/16'),
  1305. ipaddress.ip_network('2::/128')])
  1306. # test exception raised when first is greater than last
  1307. self.assertRaises(ValueError, list,
  1308. summarize(ipaddress.ip_address('1.1.1.0'),
  1309. ipaddress.ip_address('1.1.0.0')))
  1310. # test exception raised when first and last aren't IP addresses
  1311. self.assertRaises(TypeError, list,
  1312. summarize(ipaddress.ip_network('1.1.1.0'),
  1313. ipaddress.ip_network('1.1.0.0')))
  1314. self.assertRaises(TypeError, list,
  1315. summarize(ipaddress.ip_network('1.1.1.0'),
  1316. ipaddress.ip_network('1.1.0.0')))
  1317. # test exception raised when first and last are not same version
  1318. self.assertRaises(TypeError, list,
  1319. summarize(ipaddress.ip_address('::'),
  1320. ipaddress.ip_network('1.1.0.0')))
  1321. def testAddressComparison(self):
  1322. self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
  1323. ipaddress.ip_address('1.1.1.1'))
  1324. self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
  1325. ipaddress.ip_address('1.1.1.2'))
  1326. self.assertTrue(ipaddress.ip_address('::1') <=
  1327. ipaddress.ip_address('::1'))
  1328. self.assertTrue(ipaddress.ip_address('::1') <=
  1329. ipaddress.ip_address('::2'))
  1330. def testInterfaceComparison(self):
  1331. self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') ==
  1332. ipaddress.ip_interface('1.1.1.1/24'))
  1333. self.assertTrue(ipaddress.ip_interface('1.1.1.1/16') <
  1334. ipaddress.ip_interface('1.1.1.1/24'))
  1335. self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') <
  1336. ipaddress.ip_interface('1.1.1.2/24'))
  1337. self.assertTrue(ipaddress.ip_interface('1.1.1.2/16') <
  1338. ipaddress.ip_interface('1.1.1.1/24'))
  1339. self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') >
  1340. ipaddress.ip_interface('1.1.1.1/16'))
  1341. self.assertTrue(ipaddress.ip_interface('1.1.1.2/24') >
  1342. ipaddress.ip_interface('1.1.1.1/24'))
  1343. self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') >
  1344. ipaddress.ip_interface('1.1.1.2/16'))
  1345. self.assertTrue(ipaddress.ip_interface('::1/64') ==
  1346. ipaddress.ip_interface('::1/64'))
  1347. self.assertTrue(ipaddress.ip_interface('::1/64') <
  1348. ipaddress.ip_interface('::1/80'))
  1349. self.assertTrue(ipaddress.ip_interface('::1/64') <
  1350. ipaddress.ip_interface('::2/64'))
  1351. self.assertTrue(ipaddress.ip_interface('::2/48') <
  1352. ipaddress.ip_interface('::1/64'))
  1353. self.assertTrue(ipaddress.ip_interface('::1/80') >
  1354. ipaddress.ip_interface('::1/64'))
  1355. self.assertTrue(ipaddress.ip_interface('::2/64') >
  1356. ipaddress.ip_interface('::1/64'))
  1357. self.assertTrue(ipaddress.ip_interface('::1/64') >
  1358. ipaddress.ip_interface('::2/48'))
  1359. def testNetworkComparison(self):
  1360. # ip1 and ip2 have the same network address
  1361. ip1 = ipaddress.IPv4Network('1.1.1.0/24')
  1362. ip2 = ipaddress.IPv4Network('1.1.1.0/32')
  1363. ip3 = ipaddress.IPv4Network('1.1.2.0/24')
  1364. self.assertTrue(ip1 < ip3)
  1365. self.assertTrue(ip3 > ip2)
  1366. self.assertEqual(ip1.compare_networks(ip1), 0)
  1367. # if addresses are the same, sort by netmask
  1368. self.assertEqual(ip1.compare_networks(ip2), -1)
  1369. self.assertEqual(ip2.compare_networks(ip1), 1)
  1370. self.assertEqual(ip1.compare_networks(ip3), -1)
  1371. self.assertEqual(ip3.compare_networks(ip1), 1)
  1372. self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
  1373. ip1 = ipaddress.IPv6Network('2001:2000::/96')
  1374. ip2 = ipaddress.IPv6Network('2001:2001::/96')
  1375. ip3 = ipaddress.IPv6Network('2001:ffff:2000::/96')
  1376. self.assertTrue(ip1 < ip3)
  1377. self.assertTrue(ip3 > ip2)
  1378. self.assertEqual(ip1.compare_networks(ip3), -1)
  1379. self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
  1380. # Test comparing different protocols.
  1381. # Should always raise a TypeError.
  1382. self.assertRaises(TypeError,
  1383. self.ipv4_network.compare_networks,
  1384. self.ipv6_network)
  1385. ipv6 = ipaddress.IPv6Interface('::/0')
  1386. ipv4 = ipaddress.IPv4Interface('0.0.0.0/0')
  1387. self.assertRaises(TypeError, ipv4.__lt__, ipv6)
  1388. self.assertRaises(TypeError, ipv4.__gt__, ipv6)
  1389. self.assertRaises(TypeError, ipv6.__lt__, ipv4)
  1390. self.assertRaises(TypeError, ipv6.__gt__, ipv4)
  1391. # Regression test for issue 19.
  1392. ip1 = ipaddress.ip_network('10.1.2.128/25')
  1393. self.assertFalse(ip1 < ip1)
  1394. self.assertFalse(ip1 > ip1)
  1395. ip2 = ipaddress.ip_network('10.1.3.0/24')
  1396. self.assertTrue(ip1 < ip2)
  1397. self.assertFalse(ip2 < ip1)
  1398. self.assertFalse(ip1 > ip2)
  1399. self.assertTrue(ip2 > ip1)
  1400. ip3 = ipaddress.ip_network('10.1.3.0/25')
  1401. self.assertTrue(ip2 < ip3)
  1402. self.assertFalse(ip3 < ip2)
  1403. self.assertFalse(ip2 > ip3)
  1404. self.assertTrue(ip3 > ip2)
  1405. # Regression test for issue 28.
  1406. ip1 = ipaddress.ip_network('10.10.10.0/31')
  1407. ip2 = ipaddress.ip_network('10.10.10.0')
  1408. ip3 = ipaddress.ip_network('10.10.10.2/31')
  1409. ip4 = ipaddress.ip_network('10.10.10.2')
  1410. sorted = [ip1, ip2, ip3, ip4]
  1411. unsorted = [ip2, ip4, ip1, ip3]
  1412. unsorted.sort()
  1413. self.assertEqual(sorted, unsorted)
  1414. unsorted = [ip4, ip1, ip3, ip2]
  1415. unsorted.sort()
  1416. self.assertEqual(sorted, unsorted)
  1417. self.assertRaises(TypeError, ip1.__lt__,
  1418. ipaddress.ip_address('10.10.10.0'))
  1419. self.assertRaises(TypeError, ip2.__lt__,
  1420. ipaddress.ip_address('10.10.10.0'))
  1421. # <=, >=
  1422. self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
  1423. ipaddress.ip_network('1.1.1.1'))
  1424. self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
  1425. ipaddress.ip_network('1.1.1.2'))
  1426. self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
  1427. ipaddress.ip_network('1.1.1.1'))
  1428. self.assertTrue(ipaddress.ip_network('::1') <=
  1429. ipaddress.ip_network('::1'))
  1430. self.assertTrue(ipaddress.ip_network('::1') <=
  1431. ipaddress.ip_network('::2'))
  1432. self.assertFalse(ipaddress.ip_network('::2') <=
  1433. ipaddress.ip_network('::1'))
  1434. def testStrictNetworks(self):
  1435. self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
  1436. self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
  1437. def testOverlaps(self):
  1438. other = ipaddress.IPv4Network('1.2.3.0/30')
  1439. other2 = ipaddress.IPv4Network('1.2.2.0/24')
  1440. other3 = ipaddress.IPv4Network('1.2.2.64/26')
  1441. self.assertTrue(self.ipv4_network.overlaps(other))
  1442. self.assertFalse(self.ipv4_network.overlaps(other2))
  1443. self.assertTrue(other2.overlaps(other3))
  1444. def testEmbeddedIpv4(self):
  1445. ipv4_string = '192.168.0.1'
  1446. ipv4 = ipaddress.IPv4Interface(ipv4_string)
  1447. v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
  1448. self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
  1449. v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
  1450. self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
  1451. self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
  1452. '2001:1.1.1.1:1.1.1.1')
  1453. # Issue 67: IPv6 with embedded IPv4 address not recognized.
  1454. def testIPv6AddressTooLarge(self):
  1455. # RFC4291 2.5.5.2
  1456. self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
  1457. ipaddress.ip_address('::FFFF:c000:201'))
  1458. # RFC4291 2.2 (part 3) x::d.d.d.d
  1459. self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
  1460. ipaddress.ip_address('FFFF::c000:201'))
  1461. def testIPVersion(self):
  1462. self.assertEqual(self.ipv4_address.version, 4)
  1463. self.assertEqual(self.ipv6_address.version, 6)
  1464. def testMaxPrefixLength(self):
  1465. self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
  1466. self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
  1467. def testPacked(self):
  1468. self.assertEqual(self.ipv4_address.packed,
  1469. b'\x01\x02\x03\x04')
  1470. self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
  1471. b'\xff\xfe\xfd\xfc')
  1472. self.assertEqual(self.ipv6_address.packed,
  1473. b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
  1474. b'\x02\x00\x00\x00\x00\x00\x00\x01')
  1475. self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
  1476. b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff' +
  1477. b'\x00' * 6)
  1478. self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
  1479. b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8)
  1480. def testIpType(self):
  1481. ipv4net = ipaddress.ip_network('1.2.3.4')
  1482. ipv4addr = ipaddress.ip_address('1.2.3.4')
  1483. ipv6net = ipaddress.ip_network('::1.2.3.4')
  1484. ipv6addr = ipaddress.ip_address('::1.2.3.4')
  1485. self.assertEqual(ipaddress.IPv4Network, type(ipv4net))
  1486. self.assertEqual(ipaddress.IPv4Address, type(ipv4addr))
  1487. self.assertEqual(ipaddress.IPv6Network, type(ipv6net))
  1488. self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
  1489. def testReservedIpv4(self):
  1490. # test networks
  1491. self.assertEqual(True, ipaddress.ip_interface(
  1492. '224.1.1.1/31').is_multicast)
  1493. self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
  1494. self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved)
  1495. self.assertEqual(True, ipaddress.ip_interface(
  1496. '192.168.1.1/17').is_private)
  1497. self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
  1498. self.assertEqual(True, ipaddress.ip_network(
  1499. '10.255.255.255').is_private)
  1500. self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
  1501. self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved)
  1502. self.assertEqual(True, ipaddress.ip_network(
  1503. '172.31.255.255').is_private)
  1504. self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
  1505. self.assertEqual(True,
  1506. ipaddress.ip_network('169.254.1.0/24').is_link_local)
  1507. self.assertEqual(
  1508. True,
  1509. ipaddress.ip_interface('169.254.100.200/24').is_link_local)
  1510. self.assertEqual(
  1511. False,
  1512. ipaddress.ip_interface('169.255.100.200/24').is_link_local)
  1513. self.assertEqual(
  1514. True,
  1515. ipaddress.ip_network('127.100.200.254/32').is_loopback)
  1516. self.assertEqual(True, ipaddress.ip_network(
  1517. '127.42.0.0/16').is_loopback)
  1518. self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
  1519. self.assertEqual(False,
  1520. ipaddress.ip_network('100.64.0.0/10').is_private)
  1521. self.assertEqual(
  1522. False, ipaddress.ip_network('100.64.0.0/10').is_global)
  1523. self.assertEqual(True,
  1524. ipaddress.ip_network('192.0.2.128/25').is_private)
  1525. self.assertEqual(True,
  1526. ipaddress.ip_network('192.0.3.0/24').is_global)
  1527. # test addresses
  1528. self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified)
  1529. self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
  1530. self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
  1531. self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved)
  1532. self.assertEqual(False,
  1533. ipaddress.ip_address('239.255.255.255').is_reserved)
  1534. self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
  1535. self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
  1536. self.assertEqual(True, ipaddress.ip_address(
  1537. '10.255.255.255').is_private)
  1538. self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
  1539. self.assertEqual(True, ipaddress.ip_address(
  1540. '172.31.255.255').is_private)
  1541. self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
  1542. self.assertEqual(True,
  1543. ipaddress.ip_address('169.254.100.200').is_link_local)
  1544. self.assertEqual(False,
  1545. ipaddress.ip_address('169.255.100.200').is_link_local)
  1546. self.assertTrue(ipaddress.ip_address('192.0.7.1').is_global)
  1547. self.assertFalse(ipaddress.ip_address('203.0.113.1').is_global)
  1548. self.assertEqual(True,
  1549. ipaddress.ip_address('127.100.200.254').is_loopback)
  1550. self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
  1551. self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
  1552. self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
  1553. def testReservedIpv6(self):
  1554. self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
  1555. self.assertEqual(True, ipaddress.ip_network(2 ** 128 - 1).is_multicast)
  1556. self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
  1557. self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
  1558. self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
  1559. self.assertEqual(True, ipaddress.ip_network(
  1560. 'feff:ffff:ffff:ffff::').is_site_local)
  1561. self.assertEqual(False, ipaddress.ip_network(
  1562. 'fbf:ffff::').is_site_local)
  1563. self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
  1564. self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
  1565. self.assertEqual(True, ipaddress.ip_network(
  1566. 'fc00:ffff:ffff:ffff::').is_private)
  1567. self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
  1568. self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
  1569. self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
  1570. self.assertEqual(True, ipaddress.ip_network(
  1571. 'febf:ffff::').is_link_local)
  1572. self.assertEqual(False, ipaddress.ip_network(
  1573. 'fe7f:ffff::').is_link_local)
  1574. self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
  1575. self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
  1576. self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback)
  1577. self.assertEqual(False, ipaddress.ip_network('::').is_loopback)
  1578. self.assertEqual(False, ipaddress.ip_network('::2').is_loopback)
  1579. self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified)
  1580. self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified)
  1581. self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified)
  1582. self.assertEqual(True,
  1583. ipaddress.ip_network('2001::1/128').is_private)
  1584. self.assertEqual(True,
  1585. ipaddress.ip_network('200::1/128').is_global)
  1586. # test addresses
  1587. self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
  1588. self.assertEqual(True, ipaddress.ip_address(2 ** 128 - 1).is_multicast)
  1589. self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
  1590. self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
  1591. self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
  1592. self.assertEqual(True, ipaddress.ip_address(
  1593. 'feff:ffff:ffff:ffff::').is_site_local)
  1594. self.assertEqual(False, ipaddress.ip_address(
  1595. 'fbf:ffff::').is_site_local)
  1596. self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
  1597. self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
  1598. self.assertEqual(True, ipaddress.ip_address(
  1599. 'fc00:ffff:ffff:ffff::').is_private)
  1600. self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
  1601. self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
  1602. self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
  1603. self.assertEqual(True, ipaddress.ip_address(
  1604. 'febf:ffff::').is_link_local)
  1605. self.assertEqual(False, ipaddress.ip_address(
  1606. 'fe7f:ffff::').is_link_local)
  1607. self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
  1608. self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
  1609. self.assertEqual(True, ipaddress.ip_address('::1').is_loopback)
  1610. self.assertEqual(False, ipaddress.ip_address('::2').is_loopback)
  1611. self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
  1612. self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
  1613. # some generic IETF reserved addresses
  1614. self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
  1615. self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
  1616. def testIpv4Mapped(self):
  1617. self.assertEqual(
  1618. ipaddress.ip_address('::ffff:192.168.1.1').ipv4_mapped,
  1619. ipaddress.ip_address('192.168.1.1'))
  1620. self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
  1621. self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
  1622. ipaddress.ip_address('192.168.1.1'))
  1623. def testAddrExclude(self):
  1624. addr1 = ipaddress.ip_network('10.1.1.0/24')
  1625. addr2 = ipaddress.ip_network('10.1.1.0/26')
  1626. addr3 = ipaddress.ip_network('10.2.1.0/24')
  1627. addr4 = ipaddress.ip_address('10.1.1.0')
  1628. addr5 = ipaddress.ip_network('2001:db8::0/32')
  1629. addr6 = ipaddress.ip_network('10.1.1.5/32')
  1630. self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
  1631. [ipaddress.ip_network('10.1.1.64/26'),
  1632. ipaddress.ip_network('10.1.1.128/25')])
  1633. self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
  1634. self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
  1635. self.assertRaises(TypeError, list, addr1.address_exclude(addr5))
  1636. self.assertEqual(list(addr1.address_exclude(addr1)), [])
  1637. self.assertEqual(sorted(list(addr1.address_exclude(addr6))),
  1638. [ipaddress.ip_network('10.1.1.0/30'),
  1639. ipaddress.ip_network('10.1.1.4/32'),
  1640. ipaddress.ip_network('10.1.1.6/31'),
  1641. ipaddress.ip_network('10.1.1.8/29'),
  1642. ipaddress.ip_network('10.1.1.16/28'),
  1643. ipaddress.ip_network('10.1.1.32/27'),
  1644. ipaddress.ip_network('10.1.1.64/26'),
  1645. ipaddress.ip_network('10.1.1.128/25')])
  1646. def testHash(self):
  1647. self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')),
  1648. hash(ipaddress.ip_interface('10.1.1.0/24')))
  1649. self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
  1650. hash(ipaddress.ip_network('10.1.1.0/24')))
  1651. self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
  1652. hash(ipaddress.ip_address('10.1.1.0')))
  1653. # i70
  1654. self.assertEqual(
  1655. hash(ipaddress.ip_address('1.2.3.4')),
  1656. hash(ipaddress.ip_address(
  1657. int(ipaddress.ip_address('1.2.3.4')._ip))))
  1658. ip1 = ipaddress.ip_address('10.1.1.0')
  1659. ip2 = ipaddress.ip_address('1::')
  1660. dummy = {}
  1661. dummy[self.ipv4_address] = None
  1662. dummy[self.ipv6_address] = None
  1663. dummy[ip1] = None
  1664. dummy[ip2] = None
  1665. self.assertTrue(self.ipv4_address in dummy)
  1666. self.assertTrue(ip2 in dummy)
  1667. def testIPBases(self):
  1668. net = self.ipv4_network
  1669. self.assertEqual('1.2.3.0/24', net.compressed)
  1670. net = self.ipv6_network
  1671. self.assertRaises(ValueError, net._string_from_ip_int, 2 ** 128 + 1)
  1672. def testIPv6NetworkHelpers(self):
  1673. net = self.ipv6_network
  1674. self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen)
  1675. self.assertEqual('2001:658:22a:cafe::/ffff:ffff:ffff:ffff::',
  1676. net.with_netmask)
  1677. self.assertEqual('2001:658:22a:cafe::/::ffff:ffff:ffff:ffff',
  1678. net.with_hostmask)
  1679. self.assertEqual('2001:658:22a:cafe::/64', str(net))
  1680. def testIPv4NetworkHelpers(self):
  1681. net = self.ipv4_network
  1682. self.assertEqual('1.2.3.0/24', net.with_prefixlen)
  1683. self.assertEqual('1.2.3.0/255.255.255.0', net.with_netmask)
  1684. self.assertEqual('1.2.3.0/0.0.0.255', net.with_hostmask)
  1685. self.assertEqual('1.2.3.0/24', str(net))
  1686. def testCopyConstructor(self):
  1687. addr1 = ipaddress.ip_network('10.1.1.0/24')
  1688. addr2 = ipaddress.ip_network(addr1)
  1689. addr3 = ipaddress.ip_interface('2001:658:22a:cafe:200::1/64')
  1690. addr4 = ipaddress.ip_interface(addr3)
  1691. addr5 = ipaddress.IPv4Address('1.1.1.1')
  1692. addr6 = ipaddress.IPv6Address('2001:658:22a:cafe:200::1')
  1693. self.assertEqual(addr1, addr2)
  1694. self.assertEqual(addr3, addr4)
  1695. self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
  1696. self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
  1697. def testCompressIPv6Address(self):
  1698. test_addresses = {
  1699. '1:2:3:4:5:6:7:8': '1:2:3:4:5:6:7:8/128',
  1700. '2001:0:0:4:0:0:0:8': '2001:0:0:4::8/128',
  1701. '2001:0:0:4:5:6:7:8': '2001::4:5:6:7:8/128',
  1702. '2001:0:3:4:5:6:7:8': '2001:0:3:4:5:6:7:8/128',
  1703. '0:0:3:0:0:0:0:ffff': '0:0:3::ffff/128',
  1704. '0:0:0:4:0:0:0:ffff': '::4:0:0:0:ffff/128',
  1705. '0:0:0:0:5:0:0:ffff': '::5:0:0:ffff/128',
  1706. '1:0:0:4:0:0:7:8': '1::4:0:0:7:8/128',
  1707. '0:0:0:0:0:0:0:0': '::/128',
  1708. '0:0:0:0:0:0:0:0/0': '::/0',
  1709. '0:0:0:0:0:0:0:1': '::1/128',
  1710. '2001:0658:022a:cafe:0000:0000:0000:0000/66':
  1711. '2001:658:22a:cafe::/66',
  1712. '::1.2.3.4': '::102:304/128',
  1713. '1:2:3:4:5:ffff:1.2.3.4': '1:2:3:4:5:ffff:102:304/128',
  1714. '::7:6:5:4:3:2:1': '0:7:6:5:4:3:2:1/128',
  1715. '::7:6:5:4:3:2:0': '0:7:6:5:4:3:2:0/128',
  1716. '7:6:5:4:3:2:1::': '7:6:5:4:3:2:1:0/128',
  1717. '0:6:5:4:3:2:1::': '0:6:5:4:3:2:1:0/128',
  1718. }
  1719. for uncompressed, compressed in list(test_addresses.items()):
  1720. self.assertEqual(compressed, str(ipaddress.IPv6Interface(
  1721. uncompressed)))
  1722. def testExplodeShortHandIpStr(self):
  1723. addr1 = ipaddress.IPv6Interface('2001::1')
  1724. addr2 = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
  1725. addr3 = ipaddress.IPv6Network('2001::/96')
  1726. addr4 = ipaddress.IPv4Address('192.168.178.1')
  1727. self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
  1728. addr1.exploded)
  1729. self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
  1730. ipaddress.IPv6Interface('::1/128').exploded)
  1731. # issue 77
  1732. self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
  1733. addr2.exploded)
  1734. self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
  1735. addr3.exploded)
  1736. self.assertEqual('192.168.178.1', addr4.exploded)
  1737. def testReversePointer(self):
  1738. addr1 = ipaddress.IPv4Address('127.0.0.1')
  1739. addr2 = ipaddress.IPv6Address('2001:db8::1')
  1740. self.assertEqual('1.0.0.127.in-addr.arpa', addr1.reverse_pointer)
  1741. self.assertEqual('1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.' +
  1742. 'b.d.0.1.0.0.2.ip6.arpa',
  1743. addr2.reverse_pointer)
  1744. def testIntRepresentation(self):
  1745. self.assertEqual(16909060, int(self.ipv4_address))
  1746. self.assertEqual(42540616829182469433547762482097946625,
  1747. int(self.ipv6_address))
  1748. def testForceVersion(self):
  1749. self.assertEqual(ipaddress.ip_network(1).version, 4)
  1750. self.assertEqual(ipaddress.IPv6Network(1).version, 6)
  1751. def testWithStar(self):
  1752. self.assertEqual(self.ipv4_interface.with_prefixlen, "1.2.3.4/24")
  1753. self.assertEqual(self.ipv4_interface.with_netmask,
  1754. "1.2.3.4/255.255.255.0")
  1755. self.assertEqual(self.ipv4_interface.with_hostmask,
  1756. "1.2.3.4/0.0.0.255")
  1757. self.assertEqual(self.ipv6_interface.with_prefixlen,
  1758. '2001:658:22a:cafe:200::1/64')
  1759. self.assertEqual(self.ipv6_interface.with_netmask,
  1760. '2001:658:22a:cafe:200::1/ffff:ffff:ffff:ffff::')
  1761. # this probably don't make much sense, but it's included for
  1762. # compatibility with ipv4
  1763. self.assertEqual(self.ipv6_interface.with_hostmask,
  1764. '2001:658:22a:cafe:200::1/::ffff:ffff:ffff:ffff')
  1765. def testNetworkElementCaching(self):
  1766. # V4 - make sure we're empty
  1767. self.assertFalse('network_address' in self.ipv4_network._cache)
  1768. self.assertFalse('broadcast_address' in self.ipv4_network._cache)
  1769. self.assertFalse('hostmask' in self.ipv4_network._cache)
  1770. # V4 - populate and test
  1771. self.assertEqual(self.ipv4_network.network_address,
  1772. ipaddress.IPv4Address('1.2.3.0'))
  1773. self.assertEqual(self.ipv4_network.broadcast_address,
  1774. ipaddress.IPv4Address('1.2.3.255'))
  1775. self.assertEqual(self.ipv4_network.hostmask,
  1776. ipaddress.IPv4Address('0.0.0.255'))
  1777. # V4 - check we're cached
  1778. self.assertTrue('broadcast_address' in self.ipv4_network._cache)
  1779. self.assertTrue('hostmask' in self.ipv4_network._cache)
  1780. # V6 - make sure we're empty
  1781. self.assertFalse('broadcast_address' in self.ipv6_network._cache)
  1782. self.assertFalse('hostmask' in self.ipv6_network._cache)
  1783. # V6 - populate and test
  1784. self.assertEqual(self.ipv6_network.network_address,
  1785. ipaddress.IPv6Address('2001:658:22a:cafe::'))
  1786. self.assertEqual(self.ipv6_interface.network.network_address,
  1787. ipaddress.IPv6Address('2001:658:22a:cafe::'))
  1788. self.assertEqual(
  1789. self.ipv6_network.broadcast_address,
  1790. ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
  1791. self.assertEqual(self.ipv6_network.hostmask,
  1792. ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
  1793. self.assertEqual(
  1794. self.ipv6_interface.network.broadcast_address,
  1795. ipaddress.IPv6Address('2001:658:22a:cafe:ffff:ffff:ffff:ffff'))
  1796. self.assertEqual(self.ipv6_interface.network.hostmask,
  1797. ipaddress.IPv6Address('::ffff:ffff:ffff:ffff'))
  1798. # V6 - check we're cached
  1799. self.assertTrue('broadcast_address' in self.ipv6_network._cache)
  1800. self.assertTrue('hostmask' in self.ipv6_network._cache)
  1801. self.assertTrue(
  1802. 'broadcast_address' in self.ipv6_interface.network._cache)
  1803. self.assertTrue('hostmask' in self.ipv6_interface.network._cache)
  1804. def testTeredo(self):
  1805. # stolen from wikipedia
  1806. server = ipaddress.IPv4Address('65.54.227.120')
  1807. client = ipaddress.IPv4Address('192.0.2.45')
  1808. teredo_addr = '2001:0000:4136:e378:8000:63bf:3fff:fdd2'
  1809. self.assertEqual((server, client),
  1810. ipaddress.ip_address(teredo_addr).teredo)
  1811. bad_addr = '2000::4136:e378:8000:63bf:3fff:fdd2'
  1812. self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
  1813. bad_addr = '2001:0001:4136:e378:8000:63bf:3fff:fdd2'
  1814. self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
  1815. # i77
  1816. teredo_addr = ipaddress.IPv6Address('2001:0:5ef5:79fd:0:59d:a0e5:ba1')
  1817. self.assertEqual((ipaddress.IPv4Address('94.245.121.253'),
  1818. ipaddress.IPv4Address('95.26.244.94')),
  1819. teredo_addr.teredo)
  1820. def testsixtofour(self):
  1821. sixtofouraddr = ipaddress.ip_address('2002:ac1d:2d64::1')
  1822. bad_addr = ipaddress.ip_address('2000:ac1d:2d64::1')
  1823. self.assertEqual(ipaddress.IPv4Address('172.29.45.100'),
  1824. sixtofouraddr.sixtofour)
  1825. self.assertFalse(bad_addr.sixtofour)
  1826. # Monkey-patch test runner
  1827. if not hasattr(BaseTestCase, 'assertRaisesRegex'):
  1828. class _AssertRaisesRegex(object):
  1829. def __init__(self, expected_exception, expected_regex):
  1830. self.expected = expected_exception
  1831. self.expected_regex = re.compile(expected_regex)
  1832. def __enter__(self):
  1833. return self
  1834. def __exit__(self, exc_type, exc_value, tb):
  1835. if exc_type is None:
  1836. try:
  1837. exc_name = self.expected.__name__
  1838. except AttributeError:
  1839. exc_name = str(self.expected)
  1840. if self.obj_name:
  1841. self._raiseFailure("{} not raised by {}".format(
  1842. exc_name, self.obj_name))
  1843. else:
  1844. self._raiseFailure("{} not raised".format(exc_name))
  1845. if not issubclass(exc_type, self.expected):
  1846. # let unexpected exceptions pass through
  1847. return False
  1848. self.exception = exc_value
  1849. if self.expected_regex is None:
  1850. return True
  1851. expected_regex = self.expected_regex
  1852. if not expected_regex.search(str(exc_value)):
  1853. raise AssertionError('"{}" does not match "{}"'.format(
  1854. expected_regex.pattern, str(exc_value)))
  1855. return True
  1856. BaseTestCase.assertRaisesRegex = _AssertRaisesRegex
  1857. IpaddrUnitTest.assertRaisesRegex = _AssertRaisesRegex
  1858. if not hasattr(BaseTestCase, 'assertIn'):
  1859. def _assertIn(self, o, iterable):
  1860. self.assertTrue(o in iterable)
  1861. def _assertNotIn(self, o, iterable):
  1862. self.assertFalse(o in iterable)
  1863. BaseTestCase.assertIn = _assertIn
  1864. BaseTestCase.assertNotIn = _assertNotIn
  1865. IpaddrUnitTest.assertIn = _assertIn
  1866. IpaddrUnitTest.assertNotIn = _assertNotIn
  1867. ComparisonTests.assertIn = _assertIn
  1868. ComparisonTests.assertNotIn = _assertNotIn
  1869. if not hasattr(BaseTestCase, 'subTest'):
  1870. class _SubTest(object):
  1871. def __init__(*a, **kw):
  1872. pass
  1873. def __enter__(*a):
  1874. pass
  1875. def __exit__(*a):
  1876. pass
  1877. BaseTestCase.subTest = _SubTest
  1878. # Test for https://github.com/phihag/ipaddress/pull/6
  1879. class Python2RangeTest(unittest.TestCase):
  1880. def test_network_hosts(self):
  1881. net = ipaddress.ip_network('::/0')
  1882. next(net.hosts()) # This should not throw OverflowError
  1883. def test_network_iter(self):
  1884. net = ipaddress.ip_network('::/0')
  1885. next(iter(net)) # This should not throw OverflowError
  1886. class CompatTest(unittest.TestCase):
  1887. def test_bit_length(self):
  1888. self.assertEqual(ipaddress._compat_bit_length(0), 0)
  1889. self.assertEqual(ipaddress._compat_bit_length(1), 1)
  1890. self.assertEqual(ipaddress._compat_bit_length(2), 2)
  1891. self.assertEqual(ipaddress._compat_bit_length(3), 2)
  1892. self.assertEqual(ipaddress._compat_bit_length(4), 3)
  1893. class SingleIssuesTest(unittest.TestCase):
  1894. # https://github.com/phihag/ipaddress/issues/14
  1895. def test_issue_14(self):
  1896. self.assertTrue(ipaddress.ip_address('127.0.0.1').is_private)
  1897. def test_issue_18(self):
  1898. net1 = ipaddress.ip_network("192.0.2.0/24")
  1899. net2 = ipaddress.ip_network("192.0.2.112/29")
  1900. self.assertFalse(net1.subnet_of(net2))
  1901. self.assertTrue(net1.supernet_of(net2))
  1902. self.assertTrue(net2.subnet_of(net1))
  1903. self.assertFalse(net2.supernet_of(net1))
  1904. if __name__ == '__main__':
  1905. unittest.main()