Lines Matching refs:self
37 def factory(self):
41 def assertCleanError(self, exc_type, details, *args):
49 cm = self.assertRaisesRegex(exc_type, details)
54 self.assertTrue(exc.exception.__suppress_context__)
56 def assertAddressError(self, details, *args):
58 return self.assertCleanError(ipaddress.AddressValueError,
61 def assertNetmaskError(self, details, *args):
63 return self.assertCleanError(ipaddress.NetmaskValueError,
66 def assertInstancesEqual(self, lhs, rhs):
68 self.assertEqual(self.factory(lhs), self.factory(rhs))
73 def test_empty_address(self):
74 with self.assertAddressError("Address cannot be empty"):
75 self.factory("")
77 def test_floats_rejected(self):
78 with self.assertAddressError(re.escape(repr("1.0"))):
79 self.factory(1.0)
81 def test_not_an_index_issue15559(self):
84 self.assertRaises(TypeError, operator.index, self.factory(1))
85 self.assertRaises(TypeError, hex, self.factory(1))
86 self.assertRaises(TypeError, bytes, self.factory(1))
88 def pickle_test(self, addr):
90 with self.subTest(proto=proto):
91 x = self.factory(addr)
93 self.assertEqual(y, x)
98 def test_leading_zeros(self):
112 with self.subTest(address=address):
113 with self.assertAddressError(msg):
114 self.factory(address)
116 def test_int(self):
117 self.assertInstancesEqual(0, "0.0.0.0")
118 self.assertInstancesEqual(3232235521, "192.168.0.1")
120 def test_packed(self):
121 self.assertInstancesEqual(bytes.fromhex("00000000"), "0.0.0.0")
122 self.assertInstancesEqual(bytes.fromhex("c0a80001"), "192.168.0.1")
124 def test_negative_ints_rejected(self):
126 with self.assertAddressError(re.escape(msg)):
127 self.factory(-1)
129 def test_large_ints_rejected(self):
131 with self.assertAddressError(re.escape(msg % 2**32)):
132 self.factory(2**32)
134 def test_bad_packed_length(self):
138 with self.assertAddressError(re.escape(msg % (addr, length))):
139 self.factory(addr)
147 def test_leading_zeros(self):
148 self.assertInstancesEqual("0000::0000", "::")
149 self.assertInstancesEqual("000::c0a8:0001", "::c0a8:1")
151 def test_int(self):
152 self.assertInstancesEqual(0, "::")
153 self.assertInstancesEqual(3232235521, "::c0a8:1")
155 def test_packed(self):
157 self.assertInstancesEqual(addr, "::")
159 self.assertInstancesEqual(addr, "::c0a8:1")
161 self.assertInstancesEqual(addr, "c0a8:1::")
163 def test_negative_ints_rejected(self):
165 with self.assertAddressError(re.escape(msg)):
166 self.factory(-1)
168 def test_large_ints_rejected(self):
170 with self.assertAddressError(re.escape(msg % 2**128)):
171 self.factory(2**128)
173 def test_bad_packed_length(self):
177 with self.assertAddressError(re.escape(msg % (addr, length))):
178 self.factory(addr)
179 self.factory(addr)
184 def test_blank_scope_id(self):
186 with self.assertAddressError('Invalid IPv6 address: "%r"', address):
187 self.factory(address)
189 def test_invalid_scope_id_with_percent(self):
191 with self.assertAddressError('Invalid IPv6 address: "%r"', address):
192 self.factory(address)
197 def test_format(self):
220 self.assertEqual(txt, format(v4, fmt))
222 def test_network_passed_as_address(self):
224 with self.assertAddressError("Unexpected '/' in %r", addr):
227 def test_bad_address_split(self):
229 with self.assertAddressError("Expected 4 octets in %r", addr):
256 def test_empty_octet(self):
258 with self.assertAddressError("Empty octet not permitted in %r",
265 def test_invalid_characters(self):
268 with self.assertAddressError(re.escape(msg)):
281 def test_octet_length(self):
284 with self.assertAddressError(re.escape(msg % (octet, addr))):
290 def test_octet_limit(self):
293 with self.assertAddressError(re.escape(msg)):
299 def test_pickle(self):
300 self.pickle_test('192.0.2.1')
302 def test_weakref(self):
303 weakref.ref(self.factory('192.0.2.1'))
309 def test_format(self):
348 self.assertEqual(txt, format(v6, fmt))
350 def test_network_passed_as_address(self):
353 with self.assertAddressError(msg, addr):
358 def test_bad_address_split_v6_not_enough_parts(self):
361 with self.assertAddressError(msg, addr.split('%')[0]):
371 def test_bad_address_split_v6_too_many_colons(self):
374 with self.assertAddressError(msg, addr.split('%')[0]):
391 def test_bad_address_split_v6_too_many_parts(self):
394 with self.assertAddressError(msg, addr.split('%')[0]):
411 def test_bad_address_split_v6_too_many_parts_with_double_colon(self):
414 with self.assertAddressError(msg, addr.split('%')[0]):
420 def test_bad_address_split_v6_repeated_double_colon(self):
423 with self.assertAddressError(msg, addr.split('%')[0]):
448 def test_bad_address_split_v6_leading_colon(self):
451 with self.assertAddressError(msg, addr.split('%')[0]):
464 def test_bad_address_split_v6_trailing_colon(self):
467 with self.assertAddressError(msg, addr.split('%')[0]):
480 def test_bad_v4_part_in(self):
482 with self.assertAddressError("%s in %r", v4_error, addr.split('%')[0]):
507 def test_invalid_characters(self):
510 with self.assertAddressError(re.escape(msg)):
527 def test_part_length(self):
530 with self.assertAddressError(msg, part, addr.split('%')[0]):
543 def test_pickle(self):
544 self.pickle_test('2001:db8::')
546 def test_weakref(self):
547 weakref.ref(self.factory('2001:db8::'))
548 weakref.ref(self.factory('2001:db8::%scope'))
554 def test_no_mask(self):
556 net = self.factory(address)
557 self.assertEqual(str(net), '1.2.3.4/32')
558 self.assertEqual(str(net.netmask), '255.255.255.255')
559 self.assertEqual(str(net.hostmask), '0.0.0.0')
563 def test_split_netmask(self):
565 with self.assertAddressError("Only one '/' permitted in %r" % addr):
566 self.factory(addr)
568 def test_address_errors(self):
570 with self.assertAddressError(details):
571 self.factory(addr)
581 def test_valid_netmask(self):
582 self.assertEqual(str(self.factory(('192.0.2.0', 24))), '192.0.2.0/24')
583 self.assertEqual(str(self.factory(('192.0.2.0', '24'))), '192.0.2.0/24')
584 self.assertEqual(str(self.factory(('192.0.2.0', '255.255.255.0'))),
586 self.assertEqual(str(self.factory('192.0.2.0/255.255.255.0')),
591 net = self.factory(net_str)
592 self.assertEqual(str(net), net_str)
594 self.assertEqual(
595 str(self.factory('0.0.0.0/%s' % net.netmask)), net_str)
597 self.assertEqual(str(self.factory('0.0.0.0/0%d' % i)), net_str)
602 self.assertEqual(
603 str(self.factory('0.0.0.0/%s' % net.hostmask)), net_str)
605 def test_netmask_errors(self):
608 with self.assertNetmaskError(re.escape(msg)):
609 self.factory("%s/%s" % (addr, netmask))
626 def test_netmask_in_tuple_errors(self):
629 with self.assertNetmaskError(re.escape(msg)):
630 self.factory((addr, netmask))
634 def test_pickle(self):
635 self.pickle_test('192.0.2.0/27')
636 self.pickle_test('192.0.2.0/31') # IPV4LENGTH - 1
637 self.pickle_test('192.0.2.0') # IPV4LENGTH
647 def test_subnet_of(self):
649 self.assertFalse(
650 self.factory('10.0.0.0/30').subnet_of(
651 self.factory('10.0.1.0/24')))
653 self.assertTrue(
654 self.factory('10.0.0.0/30').subnet_of(
655 self.factory('10.0.0.0/24')))
657 self.assertFalse(
658 self.factory('10.0.0.0/30').subnet_of(
659 self.factory('10.0.1.0/24')))
661 self.assertFalse(
662 self.factory('10.0.1.0/24').subnet_of(
663 self.factory('10.0.0.0/30')))
665 def test_supernet_of(self):
667 self.assertFalse(
668 self.factory('10.0.0.0/30').supernet_of(
669 self.factory('10.0.1.0/24')))
671 self.assertFalse(
672 self.factory('10.0.0.0/30').supernet_of(
673 self.factory('10.0.0.0/24')))
675 self.assertFalse(
676 self.factory('10.0.0.0/30').supernet_of(
677 self.factory('10.0.1.0/24')))
679 self.assertTrue(
680 self.factory('10.0.0.0/24').supernet_of(
681 self.factory('10.0.0.0/30')))
683 def test_subnet_of_mixed_types(self):
684 with self.assertRaises(TypeError):
687 with self.assertRaises(TypeError):
690 with self.assertRaises(TypeError):
693 with self.assertRaises(TypeError):
701 def test_no_mask(self):
703 net = self.factory(address)
704 self.assertEqual(str(net), '::1/128')
705 self.assertEqual(str(net.netmask), 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
706 self.assertEqual(str(net.hostmask), '::')
710 scoped_net = self.factory('::1%scope')
711 self.assertEqual(str(scoped_net), '::1%scope/128')
712 self.assertEqual(str(scoped_net.netmask), 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
713 self.assertEqual(str(scoped_net.hostmask), '::')
715 def test_split_netmask(self):
717 with self.assertAddressError("Only one '/' permitted in %r" % addr):
718 self.factory(addr)
721 with self.assertAddressError("Only one '/' permitted in %r" % scoped_addr):
722 self.factory(scoped_addr)
724 def test_address_errors(self):
726 with self.assertAddressError(details):
727 self.factory(addr)
743 def test_valid_netmask(self):
746 self.assertEqual(str(self.factory(('2001:db8::', 32))),
748 self.assertEqual(str(self.factory(('2001:db8::', '32'))),
750 self.assertEqual(str(self.factory('2001:db8::/32')), '2001:db8::/32')
754 self.assertEqual(str(self.factory(net_str)), net_str)
756 self.assertEqual(str(self.factory('::/0%d' % i)), net_str)
758 self.assertEqual(str(self.factory('2001:db8::%scope/32')), '2001:db8::%scope/32')
762 self.assertEqual(str(self.factory(net_str)), net_str)
764 self.assertEqual(str(self.factory('::/0%d' % i)), net_str)
766 def test_netmask_errors(self):
769 with self.assertNetmaskError(re.escape(msg)):
770 self.factory("%s/%s" % (addr, netmask))
786 def test_netmask_in_tuple_errors(self):
789 with self.assertNetmaskError(re.escape(msg)):
790 self.factory((addr, netmask))
795 def test_pickle(self):
796 self.pickle_test('2001:db8::1000/124')
797 self.pickle_test('2001:db8::1000/127') # IPV6LENGTH - 1
798 self.pickle_test('2001:db8::1000') # IPV6LENGTH
800 self.pickle_test('2001:db8::1000%scope') # IPV6LENGTH
810 def test_subnet_of(self):
812 self.assertFalse(
813 self.factory('2000:999::/56').subnet_of(
814 self.factory('2000:aaa::/48')))
816 self.assertTrue(
817 self.factory('2000:aaa::/56').subnet_of(
818 self.factory('2000:aaa::/48')))
820 self.assertFalse(
821 self.factory('2000:bbb::/56').subnet_of(
822 self.factory('2000:aaa::/48')))
824 self.assertFalse(
825 self.factory('2000:aaa::/48').subnet_of(
826 self.factory('2000:aaa::/56')))
828 self.assertFalse(
829 self.factory('2000:999::%scope/56').subnet_of(
830 self.factory('2000:aaa::%scope/48')))
831 self.assertTrue(
832 self.factory('2000:aaa::%scope/56').subnet_of(
833 self.factory('2000:aaa::%scope/48')))
835 def test_supernet_of(self):
837 self.assertFalse(
838 self.factory('2000:999::/56').supernet_of(
839 self.factory('2000:aaa::/48')))
841 self.assertFalse(
842 self.factory('2000:aaa::/56').supernet_of(
843 self.factory('2000:aaa::/48')))
845 self.assertFalse(
846 self.factory('2000:bbb::/56').supernet_of(
847 self.factory('2000:aaa::/48')))
849 self.assertTrue(
850 self.factory('2000:aaa::/48').supernet_of(
851 self.factory('2000:aaa::/56')))
856 def assertFactoryError(self, factory, kind):
860 with self.assertCleanError(ValueError, msg, addr, kind):
863 def test_ip_address(self):
864 self.assertFactoryError(ipaddress.ip_address, "address")
866 def test_ip_interface(self):
867 self.assertFactoryError(ipaddress.ip_interface, "interface")
869 def test_ip_network(self):
870 self.assertFactoryError(ipaddress.ip_network, "network")
905 def test_foreign_type_equality(self):
908 for obj in self.objects_with_scoped:
909 self.assertNotEqual(obj, other)
910 self.assertFalse(obj == other)
911 self.assertEqual(obj.__eq__(other), NotImplemented)
912 self.assertEqual(obj.__ne__(other), NotImplemented)
914 def test_mixed_type_equality(self):
917 for lhs in self.objects:
918 for rhs in self.objects:
921 self.assertNotEqual(lhs, rhs)
923 def test_scoped_ipv6_equality(self):
924 for lhs, rhs in zip(self.v6_objects, self.v6_scoped_objects):
925 self.assertNotEqual(lhs, rhs)
927 def test_v4_with_v6_scoped_equality(self):
928 for lhs in self.v4_objects:
929 for rhs in self.v6_scoped_objects:
930 self.assertNotEqual(lhs, rhs)
932 def test_same_type_equality(self):
933 for obj in self.objects_with_scoped:
934 self.assertEqual(obj, obj)
935 self.assertLessEqual(obj, obj)
936 self.assertGreaterEqual(obj, obj)
938 def test_same_type_ordering(self):
940 (self.v4addr, self.v4addr2),
941 (self.v4net, self.v4net2),
942 (self.v4intf, self.v4intf2),
943 (self.v6addr, self.v6addr2),
944 (self.v6net, self.v6net2),
945 (self.v6intf, self.v6intf2),
946 (self.v6addr_scoped, self.v6addr2_scoped),
947 (self.v6net_scoped, self.v6net2_scoped),
948 (self.v6intf_scoped, self.v6intf2_scoped),
950 self.assertNotEqual(lhs, rhs)
951 self.assertLess(lhs, rhs)
952 self.assertLessEqual(lhs, rhs)
953 self.assertGreater(rhs, lhs)
954 self.assertGreaterEqual(rhs, lhs)
955 self.assertFalse(lhs > rhs)
956 self.assertFalse(rhs < lhs)
957 self.assertFalse(lhs >= rhs)
958 self.assertFalse(rhs <= lhs)
960 def test_containment(self):
961 for obj in self.v4_addresses:
962 self.assertIn(obj, self.v4net)
963 for obj in self.v6_addresses + self.v6_scoped_addresses:
964 self.assertIn(obj, self.v6net)
965 for obj in self.v6_addresses + self.v6_scoped_addresses:
966 self.assertIn(obj, self.v6net_scoped)
968 for obj in self.v4_objects + [self.v6net, self.v6net_scoped]:
969 self.assertNotIn(obj, self.v6net)
970 for obj in self.v4_objects + [self.v6net, self.v6net_scoped]:
971 self.assertNotIn(obj, self.v6net_scoped)
972 for obj in self.v6_objects + self.v6_scoped_objects + [self.v4net]:
973 self.assertNotIn(obj, self.v4net)
975 def test_mixed_type_ordering(self):
976 for lhs in self.objects_with_scoped:
977 for rhs in self.objects_with_scoped:
980 self.assertRaises(TypeError, lambda: lhs < rhs)
981 self.assertRaises(TypeError, lambda: lhs > rhs)
982 self.assertRaises(TypeError, lambda: lhs <= rhs)
983 self.assertRaises(TypeError, lambda: lhs >= rhs)
985 def test_foreign_type_ordering(self):
987 for obj in self.objects_with_scoped:
988 with self.assertRaises(TypeError):
990 with self.assertRaises(TypeError):
992 with self.assertRaises(TypeError):
994 with self.assertRaises(TypeError):
996 self.assertTrue(obj < LARGEST)
997 self.assertFalse(obj > LARGEST)
998 self.assertTrue(obj <= LARGEST)
999 self.assertFalse(obj >= LARGEST)
1000 self.assertFalse(obj < SMALLEST)
1001 self.assertTrue(obj > SMALLEST)
1002 self.assertFalse(obj <= SMALLEST)
1003 self.assertTrue(obj >= SMALLEST)
1005 def test_mixed_type_key(self):
1007 v4_ordered = [self.v4addr, self.v4net, self.v4intf]
1008 v6_ordered = [self.v6addr, self.v6net, self.v6intf]
1009 v6_scoped_ordered = [self.v6addr_scoped, self.v6net_scoped, self.v6intf_scoped]
1010 self.assertEqual(v4_ordered,
1011 sorted(self.v4_objects,
1013 self.assertEqual(v6_ordered,
1014 sorted(self.v6_objects,
1016 self.assertEqual(v6_scoped_ordered,
1017 sorted(self.v6_scoped_objects,
1019 self.assertEqual(v4_ordered + v6_scoped_ordered,
1020 sorted(self.v4_objects + self.v6_scoped_objects,
1022 self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object))
1024 def test_incompatible_versions(self):
1033 self.assertRaises(TypeError, v4addr.__lt__, v6addr)
1034 self.assertRaises(TypeError, v4addr.__gt__, v6addr)
1035 self.assertRaises(TypeError, v4net.__lt__, v6net)
1036 self.assertRaises(TypeError, v4net.__gt__, v6net)
1038 self.assertRaises(TypeError, v6addr.__lt__, v4addr)
1039 self.assertRaises(TypeError, v6addr.__gt__, v4addr)
1040 self.assertRaises(TypeError, v6net.__lt__, v4net)
1041 self.assertRaises(TypeError, v6net.__gt__, v4net)
1043 self.assertRaises(TypeError, v4addr.__lt__, v6addr_scoped)
1044 self.assertRaises(TypeError, v4addr.__gt__, v6addr_scoped)
1045 self.assertRaises(TypeError, v4net.__lt__, v6net_scoped)
1046 self.assertRaises(TypeError, v4net.__gt__, v6net_scoped)
1048 self.assertRaises(TypeError, v6addr_scoped.__lt__, v4addr)
1049 self.assertRaises(TypeError, v6addr_scoped.__gt__, v4addr)
1050 self.assertRaises(TypeError, v6net_scoped.__lt__, v4net)
1051 self.assertRaises(TypeError, v6net_scoped.__gt__, v4net)
1056 def setUp(self):
1057 self.ipv4_address = ipaddress.IPv4Address('1.2.3.4')
1058 self.ipv4_interface = ipaddress.IPv4Interface('1.2.3.4/24')
1059 self.ipv4_network = ipaddress.IPv4Network('1.2.3.0/24')
1060 #self.ipv4_hostmask = ipaddress.IPv4Interface('10.0.0.1/0.255.255.255')
1061 self.ipv6_address = ipaddress.IPv6Interface(
1063 self.ipv6_interface = ipaddress.IPv6Interface(
1065 self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
1066 self.ipv6_scoped_address = ipaddress.IPv6Interface(
1068 self.ipv6_scoped_interface = ipaddress.IPv6Interface(
1070 self.ipv6_scoped_network = ipaddress.IPv6Network('2001:658:22a:cafe::%scope/64')
1072 def testRepr(self):
1073 self.assertEqual("IPv4Interface('1.2.3.4/32')",
1075 self.assertEqual("IPv6Interface('::1/128')",
1077 self.assertEqual("IPv6Interface('::1%scope/128')",
1081 def testIPv4Tuple(self):
1085 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 32)), net)
1086 self.assertEqual(ipaddress.IPv4Network((ip, 32)), net)
1087 self.assertEqual(ipaddress.IPv4Network((3221225985, 32)), net)
1088 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1',
1090 self.assertEqual(ipaddress.IPv4Network((ip,
1092 self.assertEqual(ipaddress.IPv4Network((3221225985,
1095 with self.assertRaises(ValueError):
1097 with self.assertRaises(ValueError):
1099 with self.assertRaises(ValueError):
1101 with self.assertRaises(ValueError):
1103 with self.assertRaises(ValueError):
1105 with self.assertRaises(ValueError):
1109 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1', 24),
1111 self.assertEqual(ipaddress.IPv4Network((ip, 24),
1113 self.assertEqual(ipaddress.IPv4Network((3221225985, 24),
1115 self.assertEqual(ipaddress.IPv4Network(('192.0.2.1',
1118 self.assertEqual(ipaddress.IPv4Network((ip,
1121 self.assertEqual(ipaddress.IPv4Network((3221225985,
1128 self.assertEqual(ipaddress.IPv4Network(('192.0.2.0',
1130 self.assertEqual(ipaddress.IPv4Network((ip,
1132 self.assertEqual(ipaddress.IPv4Network((3221225984,
1134 self.assertEqual(ipaddress.IPv4Network(('192.0.2.0', 24)), net)
1135 self.assertEqual(ipaddress.IPv4Network((ip, 24)), net)
1136 self.assertEqual(ipaddress.IPv4Network((3221225984, 24)), net)
1138 self.assertEqual(ipaddress.IPv4Interface(('192.0.2.1', 24)),
1140 self.assertEqual(ipaddress.IPv4Interface((3221225985, 24)),
1144 with self.assertRaises(ValueError):
1148 with self.assertRaises(ValueError):
1152 def testIPv6Tuple(self):
1156 self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '128')),
1158 self.assertEqual(ipaddress.IPv6Network(
1161 self.assertEqual(ipaddress.IPv6Network((ip, '128')),
1165 self.assertEqual(ipaddress.IPv6Network(('2001:db8::', '96')),
1167 self.assertEqual(ipaddress.IPv6Network(
1170 self.assertEqual(ipaddress.IPv6Network((ip, '96')),
1177 with self.assertRaises(ValueError):
1179 with self.assertRaises(ValueError):
1182 with self.assertRaises(ValueError):
1186 self.assertEqual(ipaddress.IPv6Network(('2001:db8::1', 96),
1189 self.assertEqual(ipaddress.IPv6Network(
1193 self.assertEqual(ipaddress.IPv6Network((ip, 96), strict=False),
1197 self.assertEqual(ipaddress.IPv6Interface(('2001:db8::1', '96')),
1199 self.assertEqual(ipaddress.IPv6Interface(
1204 with self.assertRaises(ValueError):
1206 with self.assertRaises(ValueError):
1211 with self.assertRaises(ValueError):
1215 with self.assertRaises(ValueError):
1219 def testAddressIntMath(self):
1220 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255,
1222 self.assertEqual(ipaddress.IPv4Address('1.1.1.1') - 256,
1224 self.assertEqual(ipaddress.IPv6Address('::1') + (2**16 - 2),
1226 self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2),
1228 self.assertNotEqual(ipaddress.IPv6Address('::1%scope') + (2**16 - 2),
1230 self.assertNotEqual(ipaddress.IPv6Address('::ffff%scope') - (2**16 - 2),
1233 def testInvalidIntToBytes(self):
1234 self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1)
1235 self.assertRaises(ValueError, ipaddress.v4_int_to_packed,
1237 self.assertRaises(ValueError, ipaddress.v6_int_to_packed, -1)
1238 self.assertRaises(ValueError, ipaddress.v6_int_to_packed,
1241 def testInternals(self):
1245 self.assertEqual(list(ipaddress._find_address_range([ip1])),
1247 self.assertEqual(list(ipaddress._find_address_range([ip1, ip3])),
1249 self.assertEqual(list(ipaddress._find_address_range([ip1, ip2, ip3])),
1251 self.assertEqual(128, ipaddress._count_righthand_zero_bits(0, 128))
1252 self.assertEqual("IPv4Network('1.2.3.0/24')", repr(self.ipv4_network))
1254 def testGetNetwork(self):
1255 self.assertEqual(int(self.ipv4_network.network_address), 16909056)
1256 self.assertEqual(str(self.ipv4_network.network_address), '1.2.3.0')
1258 self.assertEqual(int(self.ipv6_network.network_address),
1260 self.assertEqual(str(self.ipv6_network.network_address),
1262 self.assertEqual(str(self.ipv6_network.hostmask),
1264 self.assertEqual(int(self.ipv6_scoped_network.network_address),
1266 self.assertEqual(str(self.ipv6_scoped_network.network_address),
1268 self.assertEqual(str(self.ipv6_scoped_network.hostmask),
1271 def testIpFromInt(self):
1272 self.assertEqual(self.ipv4_interface._ip,
1278 self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4.network_address)))
1279 self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6.network_address)))
1280 self.assertNotEqual(ipv6_scoped, ipaddress.ip_network(int(ipv6_scoped.network_address)))
1283 self.assertEqual(self.ipv6_interface._ip,
1285 self.assertEqual(self.ipv6_scoped_interface._ip,
1288 self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version,
1290 self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version,
1292 self.assertEqual(ipaddress.ip_network(self.ipv6_scoped_address._ip).version,
1295 def testIpFromPacked(self):
1297 self.assertEqual(self.ipv4_interface._ip,
1299 self.assertEqual(address('255.254.253.252'),
1301 self.assertEqual(self.ipv6_interface.ip,
1305 self.assertEqual(address('ffff:2:3:4:ffff::'),
1308 self.assertEqual(address('::'),
1311 def testGetIp(self):
1312 self.assertEqual(int(self.ipv4_interface.ip), 16909060)
1313 self.assertEqual(str(self.ipv4_interface.ip), '1.2.3.4')
1315 self.assertEqual(int(self.ipv6_interface.ip),
1317 self.assertEqual(str(self.ipv6_interface.ip),
1319 self.assertEqual(int(self.ipv6_scoped_interface.ip),
1321 self.assertEqual(str(self.ipv6_scoped_interface.ip),
1324 def testGetScopeId(self):
1325 self.assertEqual(self.ipv6_address.scope_id,
1327 self.assertEqual(str(self.ipv6_scoped_address.scope_id),
1329 self.assertEqual(self.ipv6_interface.scope_id,
1331 self.assertEqual(str(self.ipv6_scoped_interface.scope_id),
1333 self.assertEqual(self.ipv6_network.network_address.scope_id,
1335 self.assertEqual(str(self.ipv6_scoped_network.network_address.scope_id),
1338 def testGetNetmask(self):
1339 self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
1340 self.assertEqual(str(self.ipv4_network.netmask), '255.255.255.0')
1341 self.assertEqual(int(self.ipv6_network.netmask),
1343 self.assertEqual(self.ipv6_network.prefixlen, 64)
1344 self.assertEqual(int(self.ipv6_scoped_network.netmask),
1346 self.assertEqual(self.ipv6_scoped_network.prefixlen, 64)
1348 def testZeroNetmask(self):
1350 self.assertEqual(int(ipv4_zero_netmask.network.netmask), 0)
1351 self.assertEqual(ipv4_zero_netmask._prefix_from_prefix_string('0'), 0)
1354 self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
1355 self.assertEqual(ipv6_zero_netmask._prefix_from_prefix_string('0'), 0)
1358 self.assertEqual(int(ipv6_scoped_zero_netmask.network.netmask), 0)
1359 self.assertEqual(ipv6_scoped_zero_netmask._prefix_from_prefix_string('0'), 0)
1361 def testIPv4Net(self):
1363 self.assertEqual(net.prefixlen, 24)
1365 def testGetBroadcast(self):
1366 self.assertEqual(int(self.ipv4_network.broadcast_address), 16909311)
1367 self.assertEqual(str(self.ipv4_network.broadcast_address), '1.2.3.255')
1369 self.assertEqual(int(self.ipv6_network.broadcast_address),
1371 self.assertEqual(str(self.ipv6_network.broadcast_address),
1374 self.assertEqual(int(self.ipv6_scoped_network.broadcast_address),
1376 self.assertEqual(str(self.ipv6_scoped_network.broadcast_address),
1379 def testGetPrefixlen(self):
1380 self.assertEqual(self.ipv4_interface.network.prefixlen, 24)
1381 self.assertEqual(self.ipv6_interface.network.prefixlen, 64)
1382 self.assertEqual(self.ipv6_scoped_interface.network.prefixlen, 64)
1384 def testGetSupernet(self):
1385 self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
1386 self.assertEqual(str(self.ipv4_network.supernet().network_address),
1388 self.assertEqual(
1392 self.assertEqual(self.ipv6_network.supernet().prefixlen, 63)
1393 self.assertEqual(str(self.ipv6_network.supernet().network_address),
1395 self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(),
1397 self.assertEqual(self.ipv6_scoped_network.supernet().prefixlen, 63)
1398 self.assertEqual(str(self.ipv6_scoped_network.supernet().network_address),
1401 def testGetSupernet3(self):
1402 self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
1403 self.assertEqual(str(self.ipv4_network.supernet(3).network_address),
1406 self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
1407 self.assertEqual(str(self.ipv6_network.supernet(3).network_address),
1409 self.assertEqual(self.ipv6_scoped_network.supernet(3).prefixlen, 61)
1410 self.assertEqual(str(self.ipv6_scoped_network.supernet(3).network_address),
1413 def testGetSupernet4(self):
1414 self.assertRaises(ValueError, self.ipv4_network.supernet,
1416 self.assertRaises(ValueError, self.ipv4_network.supernet,
1418 self.assertEqual(self.ipv4_network.supernet(prefixlen_diff=2),
1419 self.ipv4_network.supernet(new_prefix=22))
1421 self.assertRaises(ValueError, self.ipv6_network.supernet,
1423 self.assertRaises(ValueError, self.ipv6_network.supernet,
1425 self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
1426 self.ipv6_network.supernet(new_prefix=62))
1427 self.assertRaises(ValueError, self.ipv6_scoped_network.supernet,
1429 self.assertRaises(ValueError, self.ipv6_scoped_network.supernet,
1431 self.assertEqual(self.ipv6_scoped_network.supernet(prefixlen_diff=2),
1432 self.ipv6_scoped_network.supernet(new_prefix=62))
1434 def testHosts(self):
1435 hosts = list(self.ipv4_network.hosts())
1436 self.assertEqual(254, len(hosts))
1437 self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0])
1438 self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1])
1442 self.assertEqual(255, len(hosts))
1443 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
1444 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
1448 self.assertEqual(255, len(hosts))
1449 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
1450 self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
1457 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
1458 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
1459 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
1466 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
1467 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
1468 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
1475 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
1476 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
1477 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
1483 self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
1484 self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
1485 self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
1488 def testFancySubnetting(self):
1489 self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),
1490 sorted(self.ipv4_network.subnets(new_prefix=27)))
1491 self.assertRaises(ValueError, list,
1492 self.ipv4_network.subnets(new_prefix=23))
1493 self.assertRaises(ValueError, list,
1494 self.ipv4_network.subnets(prefixlen_diff=3,
1496 self.assertEqual(sorted(self.ipv6_network.subnets(prefixlen_diff=4)),
1497 sorted(self.ipv6_network.subnets(new_prefix=68)))
1498 self.assertRaises(ValueError, list,
1499 self.ipv6_network.subnets(new_prefix=63))
1500 self.assertRaises(ValueError, list,
1501 self.ipv6_network.subnets(prefixlen_diff=4,
1503 self.assertEqual(sorted(self.ipv6_scoped_network.subnets(prefixlen_diff=4)),
1504 sorted(self.ipv6_scoped_network.subnets(new_prefix=68)))
1505 self.assertRaises(ValueError, list,
1506 self.ipv6_scoped_network.subnets(new_prefix=63))
1507 self.assertRaises(ValueError, list,
1508 self.ipv6_scoped_network.subnets(prefixlen_diff=4,
1511 def testGetSubnets(self):
1512 self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
1513 self.assertEqual(str(list(
1514 self.ipv4_network.subnets())[0].network_address),
1516 self.assertEqual(str(list(
1517 self.ipv4_network.subnets())[1].network_address),
1520 self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
1521 self.assertEqual(list(self.ipv6_scoped_network.subnets())[0].prefixlen, 65)
1523 def testGetSubnetForSingle32(self):
1527 self.assertEqual(subnets1, ['1.2.3.4/32'])
1528 self.assertEqual(subnets1, subnets2)
1530 def testGetSubnetForSingle128(self):
1534 self.assertEqual(subnets1, ['::1/128'])
1535 self.assertEqual(subnets1, subnets2)
1540 self.assertEqual(subnets1, ['::1%scope/128'])
1541 self.assertEqual(subnets1, subnets2)
1543 def testSubnet2(self):
1544 ips = [str(x) for x in self.ipv4_network.subnets(2)]
1545 self.assertEqual(
1549 ipsv6 = [str(x) for x in self.ipv6_network.subnets(2)]
1550 self.assertEqual(
1557 def testGetSubnets3(self):
1558 subnets = [str(x) for x in self.ipv4_network.subnets(8)]
1559 self.assertEqual(subnets[:3],
1561 self.assertEqual(subnets[-3:],
1563 self.assertEqual(len(subnets), 256)
1567 self.assertEqual(subnets[:3],
1571 self.assertEqual(subnets[-3:],
1575 self.assertEqual(len(subnets), 256)
1577 def testSubnetFailsForLargeCidrDiff(self):
1578 self.assertRaises(ValueError, list,
1579 self.ipv4_interface.network.subnets(9))
1580 self.assertRaises(ValueError, list,
1581 self.ipv4_network.subnets(9))
1582 self.assertRaises(ValueError, list,
1583 self.ipv6_interface.network.subnets(65))
1584 self.assertRaises(ValueError, list,
1585 self.ipv6_network.subnets(65))
1586 self.assertRaises(ValueError, list,
1587 self.ipv6_scoped_interface.network.subnets(65))
1588 self.assertRaises(ValueError, list,
1589 self.ipv6_scoped_network.subnets(65))
1591 def testSupernetFailsForLargeCidrDiff(self):
1592 self.assertRaises(ValueError,
1593 self.ipv4_interface.network.supernet, 25)
1594 self.assertRaises(ValueError,
1595 self.ipv6_interface.network.supernet, 65)
1596 self.assertRaises(ValueError,
1597 self.ipv6_scoped_interface.network.supernet, 65)
1599 def testSubnetFailsForNegativeCidrDiff(self):
1600 self.assertRaises(ValueError, list,
1601 self.ipv4_interface.network.subnets(-1))
1602 self.assertRaises(ValueError, list,
1603 self.ipv4_network.subnets(-1))
1604 self.assertRaises(ValueError, list,
1605 self.ipv6_interface.network.subnets(-1))
1606 self.assertRaises(ValueError, list,
1607 self.ipv6_network.subnets(-1))
1608 self.assertRaises(ValueError, list,
1609 self.ipv6_scoped_interface.network.subnets(-1))
1610 self.assertRaises(ValueError, list,
1611 self.ipv6_scoped_network.subnets(-1))
1613 def testGetNum_Addresses(self):
1614 self.assertEqual(self.ipv4_network.num_addresses, 256)
1615 self.assertEqual(list(self.ipv4_network.subnets())[0].num_addresses,
1617 self.assertEqual(self.ipv4_network.supernet().num_addresses, 512)
1619 self.assertEqual(self.ipv6_network.num_addresses, 18446744073709551616)
1620 self.assertEqual(list(self.ipv6_network.subnets())[0].num_addresses,
1622 self.assertEqual(self.ipv6_network.supernet().num_addresses,
1624 self.assertEqual(self.ipv6_scoped_network.num_addresses, 18446744073709551616)
1625 self.assertEqual(list(self.ipv6_scoped_network.subnets())[0].num_addresses,
1627 self.assertEqual(self.ipv6_scoped_network.supernet().num_addresses,
1630 def testContains(self):
1631 self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'),
1632 self.ipv4_network)
1633 self.assertNotIn(ipaddress.IPv4Interface('1.2.4.1/24'),
1634 self.ipv4_network)
1637 self.assertIn(addr1, self.ipv4_network)
1640 self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__(
1643 def testNth(self):
1644 self.assertEqual(str(self.ipv4_network[5]), '1.2.3.5')
1645 self.assertRaises(IndexError, self.ipv4_network.__getitem__, 256)
1647 self.assertEqual(str(self.ipv6_network[5]),
1649 self.assertRaises(IndexError, self.ipv6_network.__getitem__, 1 << 64)
1650 self.assertEqual(str(self.ipv6_scoped_network[5]),
1652 self.assertRaises(IndexError, self.ipv6_scoped_network.__getitem__, 1 << 64)
1654 def testGetitem(self):
1657 self.assertEqual(28, addr.prefixlen)
1659 self.assertEqual('172.31.255.128', str(addr_list[0]))
1660 self.assertEqual('172.31.255.128', str(addr[0]))
1661 self.assertEqual('172.31.255.143', str(addr_list[-1]))
1662 self.assertEqual('172.31.255.143', str(addr[-1]))
1663 self.assertEqual(addr_list[-1], addr[-1])
1665 def testEqual(self):
1666 self.assertTrue(self.ipv4_interface ==
1668 self.assertFalse(self.ipv4_interface ==
1670 self.assertFalse(self.ipv4_interface ==
1672 self.assertFalse(self.ipv4_interface ==
1674 self.assertFalse(self.ipv4_interface == '')
1675 self.assertFalse(self.ipv4_interface == [])
1676 self.assertFalse(self.ipv4_interface == 2)
1678 self.assertTrue(self.ipv6_interface ==
1680 self.assertFalse(self.ipv6_interface ==
1682 self.assertFalse(self.ipv6_interface ==
1684 self.assertFalse(self.ipv6_interface == '')
1685 self.assertFalse(self.ipv6_interface == [])
1686 self.assertFalse(self.ipv6_interface == 2)
1688 self.assertTrue(self.ipv6_scoped_interface ==
1690 self.assertFalse(self.ipv6_scoped_interface ==
1692 self.assertFalse(self.ipv6_scoped_interface ==
1694 self.assertFalse(self.ipv6_scoped_interface ==
1696 self.assertFalse(self.ipv6_scoped_interface ==
1698 self.assertFalse(self.ipv6_scoped_interface == '')
1699 self.assertFalse(self.ipv6_scoped_interface == [])
1700 self.assertFalse(self.ipv6_scoped_interface == 2)
1702 def testNotEqual(self):
1703 self.assertFalse(self.ipv4_interface !=
1705 self.assertTrue(self.ipv4_interface !=
1707 self.assertTrue(self.ipv4_interface !=
1709 self.assertTrue(self.ipv4_interface !=
1711 self.assertTrue(self.ipv4_interface != '')
1712 self.assertTrue(self.ipv4_interface != [])
1713 self.assertTrue(self.ipv4_interface != 2)
1715 self.assertTrue(self.ipv4_address !=
1717 self.assertTrue(self.ipv4_address != '')
1718 self.assertTrue(self.ipv4_address != [])
1719 self.assertTrue(self.ipv4_address != 2)
1721 self.assertFalse(self.ipv6_interface !=
1723 self.assertTrue(self.ipv6_interface !=
1725 self.assertTrue(self.ipv6_interface !=
1727 self.assertTrue(self.ipv6_interface != '')
1728 self.assertTrue(self.ipv6_interface != [])
1729 self.assertTrue(self.ipv6_interface != 2)
1731 self.assertTrue(self.ipv6_address !=
1733 self.assertTrue(self.ipv6_address != '')
1734 self.assertTrue(self.ipv6_address != [])
1735 self.assertTrue(self.ipv6_address != 2)
1737 self.assertFalse(self.ipv6_scoped_interface !=
1739 self.assertTrue(self.ipv6_scoped_interface !=
1741 self.assertTrue(self.ipv6_scoped_interface !=
1743 self.assertTrue(self.ipv6_scoped_interface !=
1745 self.assertTrue(self.ipv6_scoped_interface !=
1747 self.assertTrue(self.ipv6_scoped_interface != '')
1748 self.assertTrue(self.ipv6_scoped_interface != [])
1749 self.assertTrue(self.ipv6_scoped_interface != 2)
1751 self.assertTrue(self.ipv6_scoped_address !=
1753 self.assertTrue(self.ipv6_scoped_address != '')
1754 self.assertTrue(self.ipv6_scoped_address != [])
1755 self.assertTrue(self.ipv6_scoped_address != 2)
1757 def testSlash32Constructor(self):
1758 self.assertEqual(str(ipaddress.IPv4Interface(
1761 def testSlash128Constructor(self):
1762 self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
1764 self.assertEqual(str(ipaddress.IPv6Interface('::1%scope/128')),
1767 def testSlash0Constructor(self):
1768 self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
1771 def testCollapsing(self):
1782 self.assertEqual(list(collapsed),
1795 self.assertEqual(list(collapsed),
1810 self.assertEqual(list(collapsed),
1816 self.assertEqual(list(collapsed),
1821 self.assertEqual(list(ipaddress.collapse_addresses(
1827 self.assertEqual(list(ipaddress.collapse_addresses(
1835 self.assertEqual(list(collapsed), [ip3])
1842 self.assertEqual(list(collapsed), [ip3])
1854 self.assertRaises(TypeError, ipaddress.collapse_addresses,
1866 self.assertRaises(TypeError, ipaddress.collapse_addresses,
1869 def testSummarizing(self):
1879 def version(self):
1883 self.assertRaises(ValueError, list,
1886 self.assertRaises(TypeError, list,
1888 self.assertRaises(TypeError, list,
1891 self.assertEqual(list(summarize(ip1, ip2))[0],
1895 self.assertEqual(list(summarize(ip1, ip2)),
1901 self.assertEqual([ipaddress.IPv4Network('0.0.0.0/0')],
1907 self.assertEqual(list(summarize(ip1, ip2))[0],
1911 self.assertEqual(list(summarize(ip1, ip2)),
1918 self.assertEqual(list(summarize(ip1, ip2))[0],
1922 self.assertEqual(list(summarize(ip1, ip2)),
1927 self.assertRaises(ValueError, list,
1931 self.assertRaises(TypeError, list,
1934 self.assertRaises(TypeError, list,
1938 self.assertRaises(TypeError, list,
1942 def testAddressComparison(self):
1943 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
1945 self.assertTrue(ipaddress.ip_address('1.1.1.1') <=
1947 self.assertTrue(ipaddress.ip_address('::1') <=
1949 self.assertTrue(ipaddress.ip_address('::1') <=
1951 self.assertTrue(ipaddress.ip_address('::1%scope') <=
1953 self.assertTrue(ipaddress.ip_address('::1%scope') <=
1956 def testInterfaceComparison(self):
1957 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') ==
1959 self.assertTrue(ipaddress.ip_interface('1.1.1.1/16') <
1961 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') <
1963 self.assertTrue(ipaddress.ip_interface('1.1.1.2/16') <
1965 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') >
1967 self.assertTrue(ipaddress.ip_interface('1.1.1.2/24') >
1969 self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') >
1972 self.assertTrue(ipaddress.ip_interface('::1/64') ==
1974 self.assertTrue(ipaddress.ip_interface('::1/64') <
1976 self.assertTrue(ipaddress.ip_interface('::1/64') <
1978 self.assertTrue(ipaddress.ip_interface('::2/48') <
1980 self.assertTrue(ipaddress.ip_interface('::1/80') >
1982 self.assertTrue(ipaddress.ip_interface('::2/64') >
1984 self.assertTrue(ipaddress.ip_interface('::1/64') >
1987 self.assertTrue(ipaddress.ip_interface('::1%scope/64') ==
1989 self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
1991 self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
1993 self.assertTrue(ipaddress.ip_interface('::2%scope/48') <
1995 self.assertTrue(ipaddress.ip_interface('::1%scope/80') >
1997 self.assertTrue(ipaddress.ip_interface('::2%scope/64') >
1999 self.assertTrue(ipaddress.ip_interface('::1%scope/64') >
2003 self.assertFalse(ipaddress.ip_interface('::1%scope/64') ==
2005 self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
2007 self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
2009 self.assertTrue(ipaddress.ip_interface('::2%scope/48') <
2011 self.assertTrue(ipaddress.ip_interface('::1%scope/80') >
2013 self.assertTrue(ipaddress.ip_interface('::2%scope/64') >
2015 self.assertTrue(ipaddress.ip_interface('::1%scope/64') >
2018 self.assertFalse(ipaddress.ip_interface('::1/64') ==
2020 self.assertTrue(ipaddress.ip_interface('::1/64') <
2022 self.assertTrue(ipaddress.ip_interface('::1/64') <
2024 self.assertTrue(ipaddress.ip_interface('::2/48') <
2026 self.assertTrue(ipaddress.ip_interface('::1/80') >
2028 self.assertTrue(ipaddress.ip_interface('::2/64') >
2030 self.assertTrue(ipaddress.ip_interface('::1/64') >
2033 def testNetworkComparison(self):
2039 self.assertTrue(ip1 < ip3)
2040 self.assertTrue(ip3 > ip2)
2042 self.assertEqual(ip1.compare_networks(ip1), 0)
2045 self.assertEqual(ip1.compare_networks(ip2), -1)
2046 self.assertEqual(ip2.compare_networks(ip1), 1)
2048 self.assertEqual(ip1.compare_networks(ip3), -1)
2049 self.assertEqual(ip3.compare_networks(ip1), 1)
2050 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
2056 self.assertTrue(ip1 < ip3)
2057 self.assertTrue(ip3 > ip2)
2058 self.assertEqual(ip1.compare_networks(ip3), -1)
2059 self.assertTrue(ip1._get_networks_key() < ip3._get_networks_key())
2063 self.assertRaises(TypeError,
2064 self.ipv4_network.compare_networks,
2065 self.ipv6_network)
2068 self.assertRaises(TypeError, ipv4.__lt__, ipv6)
2069 self.assertRaises(TypeError, ipv4.__gt__, ipv6)
2070 self.assertRaises(TypeError, ipv6.__lt__, ipv4)
2071 self.assertRaises(TypeError, ipv6.__gt__, ipv4)
2075 self.assertFalse(ip1 < ip1)
2076 self.assertFalse(ip1 > ip1)
2078 self.assertTrue(ip1 < ip2)
2079 self.assertFalse(ip2 < ip1)
2080 self.assertFalse(ip1 > ip2)
2081 self.assertTrue(ip2 > ip1)
2083 self.assertTrue(ip2 < ip3)
2084 self.assertFalse(ip3 < ip2)
2085 self.assertFalse(ip2 > ip3)
2086 self.assertTrue(ip3 > ip2)
2096 self.assertEqual(sorted, unsorted)
2099 self.assertEqual(sorted, unsorted)
2100 self.assertIs(ip1.__lt__(ipaddress.ip_address('10.10.10.0')),
2102 self.assertIs(ip2.__lt__(ipaddress.ip_address('10.10.10.0')),
2106 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
2108 self.assertTrue(ipaddress.ip_network('1.1.1.1') <=
2110 self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
2113 self.assertTrue(ipaddress.ip_network('::1') <=
2115 self.assertTrue(ipaddress.ip_network('::1') <=
2117 self.assertFalse(ipaddress.ip_network('::2') <=
2120 def testStrictNetworks(self):
2121 self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
2122 self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
2123 self.assertRaises(ValueError, ipaddress.ip_network, '::1%scope/120')
2125 def testOverlaps(self):
2129 self.assertTrue(self.ipv4_network.overlaps(other))
2130 self.assertFalse(self.ipv4_network.overlaps(other2))
2131 self.assertTrue(other2.overlaps(other3))
2133 def testEmbeddedIpv4(self):
2137 self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
2139 self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
2140 self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
2144 def testIPv6AddressTooLarge(self):
2146 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
2149 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
2152 self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1%scope'),
2154 self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1%scope'),
2156 self.assertNotEqual(ipaddress.ip_address('::FFFF:192.0.2.1%scope'),
2158 self.assertNotEqual(ipaddress.ip_address('FFFF::192.0.2.1%scope'),
2160 self.assertNotEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
2162 self.assertNotEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
2165 def testIPVersion(self):
2166 self.assertEqual(self.ipv4_address.version, 4)
2167 self.assertEqual(self.ipv6_address.version, 6)
2168 self.assertEqual(self.ipv6_scoped_address.version, 6)
2170 def testMaxPrefixLength(self):
2171 self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
2172 self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
2173 self.assertEqual(self.ipv6_scoped_interface.max_prefixlen, 128)
2175 def testPacked(self):
2176 self.assertEqual(self.ipv4_address.packed,
2178 self.assertEqual(ipaddress.IPv4Interface('255.254.253.252').packed,
2180 self.assertEqual(self.ipv6_address.packed,
2183 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::').packed,
2186 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
2188 self.assertEqual(self.ipv6_scoped_address.packed,
2191 self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::%scope').packed,
2194 self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0%scope').packed,
2197 def testIpType(self):
2202 self.assertEqual(ipaddress.IPv4Network, type(ipv4net))
2203 self.assertEqual(ipaddress.IPv4Address, type(ipv4addr))
2204 self.assertEqual(ipaddress.IPv6Network, type(ipv6net))
2205 self.assertEqual(ipaddress.IPv6Address, type(ipv6addr))
2207 def testReservedIpv4(self):
2209 self.assertEqual(True, ipaddress.ip_interface(
2211 self.assertEqual(False, ipaddress.ip_network('240.0.0.0').is_multicast)
2212 self.assertEqual(True, ipaddress.ip_network('240.0.0.0').is_reserved)
2214 self.assertEqual(True, ipaddress.ip_interface(
2216 self.assertEqual(False, ipaddress.ip_network('192.169.0.0').is_private)
2217 self.assertEqual(True, ipaddress.ip_network(
2219 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_private)
2220 self.assertEqual(False, ipaddress.ip_network('11.0.0.0').is_reserved)
2221 self.assertEqual(True, ipaddress.ip_network(
2223 self.assertEqual(False, ipaddress.ip_network('172.32.0.0').is_private)
2224 self.assertEqual(True,
2227 self.assertEqual(True,
2230 self.assertEqual(False,
2234 self.assertEqual(True,
2237 self.assertEqual(True, ipaddress.ip_network(
2239 self.assertEqual(False, ipaddress.ip_network('128.0.0.0').is_loopback)
2240 self.assertEqual(False,
2242 self.assertEqual(False, ipaddress.ip_network('100.64.0.0/10').is_global)
2244 self.assertEqual(True,
2246 self.assertEqual(True,
2250 self.assertEqual(True, ipaddress.ip_address('0.0.0.0').is_unspecified)
2251 self.assertEqual(True, ipaddress.ip_address('224.1.1.1').is_multicast)
2252 self.assertEqual(False, ipaddress.ip_address('240.0.0.0').is_multicast)
2253 self.assertEqual(True, ipaddress.ip_address('240.0.0.1').is_reserved)
2254 self.assertEqual(False,
2257 self.assertEqual(True, ipaddress.ip_address('192.168.1.1').is_private)
2258 self.assertEqual(False, ipaddress.ip_address('192.169.0.0').is_private)
2259 self.assertEqual(True, ipaddress.ip_address(
2261 self.assertEqual(False, ipaddress.ip_address('11.0.0.0').is_private)
2262 self.assertEqual(True, ipaddress.ip_address(
2264 self.assertEqual(False, ipaddress.ip_address('172.32.0.0').is_private)
2266 self.assertEqual(True,
2268 self.assertEqual(False,
2271 self.assertTrue(ipaddress.ip_address('192.0.7.1').is_global)
2272 self.assertFalse(ipaddress.ip_address('203.0.113.1').is_global)
2274 self.assertEqual(True,
2276 self.assertEqual(True, ipaddress.ip_address('127.42.0.0').is_loopback)
2277 self.assertEqual(False, ipaddress.ip_address('128.0.0.0').is_loopback)
2278 self.assertEqual(True, ipaddress.ip_network('0.0.0.0').is_unspecified)
2280 def testPrivateNetworks(self):
2281 self.assertEqual(False, ipaddress.ip_network("0.0.0.0/0").is_private)
2282 self.assertEqual(False, ipaddress.ip_network("1.0.0.0/8").is_private)
2284 self.assertEqual(True, ipaddress.ip_network("0.0.0.0/8").is_private)
2285 self.assertEqual(True, ipaddress.ip_network("10.0.0.0/8").is_private)
2286 self.assertEqual(True, ipaddress.ip_network("127.0.0.0/8").is_private)
2287 self.assertEqual(True, ipaddress.ip_network("169.254.0.0/16").is_private)
2288 self.assertEqual(True, ipaddress.ip_network("172.16.0.0/12").is_private)
2289 self.assertEqual(True, ipaddress.ip_network("192.0.0.0/29").is_private)
2290 self.assertEqual(True, ipaddress.ip_network("192.0.0.170/31").is_private)
2291 self.assertEqual(True, ipaddress.ip_network("192.0.2.0/24").is_private)
2292 self.assertEqual(True, ipaddress.ip_network("192.168.0.0/16").is_private)
2293 self.assertEqual(True, ipaddress.ip_network("198.18.0.0/15").is_private)
2294 self.assertEqual(True, ipaddress.ip_network("198.51.100.0/24").is_private)
2295 self.assertEqual(True, ipaddress.ip_network("203.0.113.0/24").is_private)
2296 self.assertEqual(True, ipaddress.ip_network("240.0.0.0/4").is_private)
2297 self.assertEqual(True, ipaddress.ip_network("255.255.255.255/32").is_private)
2299 self.assertEqual(False, ipaddress.ip_network("::/0").is_private)
2300 self.assertEqual(False, ipaddress.ip_network("::ff/128").is_private)
2302 self.assertEqual(True, ipaddress.ip_network("::1/128").is_private)
2303 self.assertEqual(True, ipaddress.ip_network("::/128").is_private)
2304 self.assertEqual(True, ipaddress.ip_network("::ffff:0:0/96").is_private)
2305 self.assertEqual(True, ipaddress.ip_network("100::/64").is_private)
2306 self.assertEqual(True, ipaddress.ip_network("2001::/23").is_private)
2307 self.assertEqual(True, ipaddress.ip_network("2001:2::/48").is_private)
2308 self.assertEqual(True, ipaddress.ip_network("2001:db8::/32").is_private)
2309 self.assertEqual(True, ipaddress.ip_network("2001:10::/28").is_private)
2310 self.assertEqual(True, ipaddress.ip_network("fc00::/7").is_private)
2311 self.assertEqual(True, ipaddress.ip_network("fe80::/10").is_private)
2313 def testReservedIpv6(self):
2315 self.assertEqual(True, ipaddress.ip_network('ffff::').is_multicast)
2316 self.assertEqual(True, ipaddress.ip_network(2**128 - 1).is_multicast)
2317 self.assertEqual(True, ipaddress.ip_network('ff00::').is_multicast)
2318 self.assertEqual(False, ipaddress.ip_network('fdff::').is_multicast)
2320 self.assertEqual(True, ipaddress.ip_network('fecf::').is_site_local)
2321 self.assertEqual(True, ipaddress.ip_network(
2323 self.assertEqual(False, ipaddress.ip_network(
2325 self.assertEqual(False, ipaddress.ip_network('ff00::').is_site_local)
2327 self.assertEqual(True, ipaddress.ip_network('fc00::').is_private)
2328 self.assertEqual(True, ipaddress.ip_network(
2330 self.assertEqual(False, ipaddress.ip_network('fbff:ffff::').is_private)
2331 self.assertEqual(False, ipaddress.ip_network('fe00::').is_private)
2333 self.assertEqual(True, ipaddress.ip_network('fea0::').is_link_local)
2334 self.assertEqual(True, ipaddress.ip_network(
2336 self.assertEqual(False, ipaddress.ip_network(
2338 self.assertEqual(False, ipaddress.ip_network('fec0::').is_link_local)
2340 self.assertEqual(True, ipaddress.ip_interface('0:0::0:01').is_loopback)
2341 self.assertEqual(False, ipaddress.ip_interface('::1/127').is_loopback)
2342 self.assertEqual(False, ipaddress.ip_network('::').is_loopback)
2343 self.assertEqual(False, ipaddress.ip_network('::2').is_loopback)
2345 self.assertEqual(True, ipaddress.ip_network('0::0').is_unspecified)
2346 self.assertEqual(False, ipaddress.ip_network('::1').is_unspecified)
2347 self.assertEqual(False, ipaddress.ip_network('::/127').is_unspecified)
2349 self.assertEqual(True,
2351 self.assertEqual(True,
2354 self.assertEqual(True, ipaddress.ip_address('ffff::').is_multicast)
2355 self.assertEqual(True, ipaddress.ip_address(2**128 - 1).is_multicast)
2356 self.assertEqual(True, ipaddress.ip_address('ff00::').is_multicast)
2357 self.assertEqual(False, ipaddress.ip_address('fdff::').is_multicast)
2359 self.assertEqual(True, ipaddress.ip_address('fecf::').is_site_local)
2360 self.assertEqual(True, ipaddress.ip_address(
2362 self.assertEqual(False, ipaddress.ip_address(
2364 self.assertEqual(False, ipaddress.ip_address('ff00::').is_site_local)
2366 self.assertEqual(True, ipaddress.ip_address('fc00::').is_private)
2367 self.assertEqual(True, ipaddress.ip_address(
2369 self.assertEqual(False, ipaddress.ip_address('fbff:ffff::').is_private)
2370 self.assertEqual(False, ipaddress.ip_address('fe00::').is_private)
2372 self.assertEqual(True, ipaddress.ip_address('fea0::').is_link_local)
2373 self.assertEqual(True, ipaddress.ip_address(
2375 self.assertEqual(False, ipaddress.ip_address(
2377 self.assertEqual(False, ipaddress.ip_address('fec0::').is_link_local)
2379 self.assertEqual(True, ipaddress.ip_address('0:0::0:01').is_loopback)
2380 self.assertEqual(True, ipaddress.ip_address('::1').is_loopback)
2381 self.assertEqual(False, ipaddress.ip_address('::2').is_loopback)
2383 self.assertEqual(True, ipaddress.ip_address('0::0').is_unspecified)
2384 self.assertEqual(False, ipaddress.ip_address('::1').is_unspecified)
2387 self.assertEqual(True, ipaddress.ip_address('100::').is_reserved)
2388 self.assertEqual(True, ipaddress.ip_network('4000::1/128').is_reserved)
2390 def testIpv4Mapped(self):
2391 self.assertEqual(
2394 self.assertEqual(ipaddress.ip_address('::c0a8:101').ipv4_mapped, None)
2395 self.assertEqual(ipaddress.ip_address('::ffff:c0a8:101').ipv4_mapped,
2398 def testIpv4MappedPrivateCheck(self):
2399 self.assertEqual(
2401 self.assertEqual(
2404 def testAddrExclude(self):
2411 self.assertEqual(sorted(list(addr1.address_exclude(addr2))),
2414 self.assertRaises(ValueError, list, addr1.address_exclude(addr3))
2415 self.assertRaises(TypeError, list, addr1.address_exclude(addr4))
2416 self.assertRaises(TypeError, list, addr1.address_exclude(addr5))
2417 self.assertEqual(list(addr1.address_exclude(addr1)), [])
2418 self.assertEqual(sorted(list(addr1.address_exclude(addr6))),
2428 def testHash(self):
2429 self.assertEqual(hash(ipaddress.ip_interface('10.1.1.0/24')),
2431 self.assertEqual(hash(ipaddress.ip_network('10.1.1.0/24')),
2433 self.assertEqual(hash(ipaddress.ip_address('10.1.1.0')),
2436 self.assertEqual(hash(ipaddress.ip_address('1.2.3.4')),
2442 dummy[self.ipv4_address] = None
2443 dummy[self.ipv6_address] = None
2446 self.assertIn(self.ipv4_address, dummy)
2447 self.assertIn(ip2, dummy)
2449 def testIPBases(self):
2450 net = self.ipv4_network
2451 self.assertEqual('1.2.3.0/24', net.compressed)
2452 net = self.ipv6_network
2453 self.assertRaises(ValueError, net._string_from_ip_int, 2**128 + 1)
2455 def testIPv6NetworkHelpers(self):
2456 net = self.ipv6_network
2457 self.assertEqual('2001:658:22a:cafe::/64', net.with_prefixlen)
2458 self.assertEqual('2001:658:22a:cafe::/ffff:ffff:ffff:ffff::',
2460 self.assertEqual('2001:658:22a:cafe::/::ffff:ffff:ffff:ffff',
2462 self.assertEqual('2001:658:22a:cafe::/64', str(net))
2464 def testIPv4NetworkHelpers(self):
2465 net = self.ipv4_network
2466 self.assertEqual('1.2.3.0/24', net.with_prefixlen)
2467 self.assertEqual('1.2.3.0/255.255.255.0', net.with_netmask)
2468 self.assertEqual('1.2.3.0/0.0.0.255', net.with_hostmask)
2469 self.assertEqual('1.2.3.0/24', str(net))
2471 def testCopyConstructor(self):
2479 self.assertEqual(addr1, addr2)
2480 self.assertEqual(addr3, addr4)
2481 self.assertEqual(addr5, ipaddress.IPv4Address(addr5))
2482 self.assertEqual(addr6, ipaddress.IPv6Address(addr6))
2484 def testCompressIPv6Address(self):
2507 self.assertEqual(compressed, str(ipaddress.IPv6Interface(
2510 def testExplodeShortHandIpStr(self):
2515 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0001/128',
2517 self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0001/128',
2520 self.assertEqual('2001:0000:5ef5:79fd:0000:059d:a0e5:0ba1',
2522 self.assertEqual('2001:0000:0000:0000:0000:0000:0000:0000/96',
2524 self.assertEqual('192.168.178.1', addr4.exploded)
2526 def testReversePointer(self):
2529 self.assertEqual('1.0.0.127.in-addr.arpa', addr1.reverse_pointer)
2530 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.' +
2534 def testIntRepresentation(self):
2535 self.assertEqual(16909060, int(self.ipv4_address))
2536 self.assertEqual(42540616829182469433547762482097946625,
2537 int(self.ipv6_address))
2539 def testForceVersion(self):
2540 self.assertEqual(ipaddress.ip_network(1).version, 4)
2541 self.assertEqual(ipaddress.IPv6Network(1).version, 6)
2543 def testWithStar(self):
2544 self.assertEqual(self.ipv4_interface.with_prefixlen, "1.2.3.4/24")
2545 self.assertEqual(self.ipv4_interface.with_netmask,
2547 self.assertEqual(self.ipv4_interface.with_hostmask,
2550 self.assertEqual(self.ipv6_interface.with_prefixlen,
2552 self.assertEqual(self.ipv6_interface.with_netmask,
2556 self.assertEqual(self.ipv6_interface.with_hostmask,
2559 def testNetworkElementCaching(self):
2561 self.assertNotIn('broadcast_address', self.ipv4_network.__dict__)
2562 self.assertNotIn('hostmask', self.ipv4_network.__dict__)
2565 self.assertEqual(self.ipv4_network.broadcast_address,
2567 self.assertEqual(self.ipv4_network.hostmask,
2571 self.assertIn('broadcast_address', self.ipv4_network.__dict__)
2572 self.assertIn('hostmask', self.ipv4_network.__dict__)
2575 self.assertNotIn('broadcast_address', self.ipv6_network.__dict__)
2576 self.assertNotIn('hostmask', self.ipv6_network.__dict__)
2579 self.assertEqual(self.ipv6_network.network_address,
2581 self.assertEqual(self.ipv6_interface.network.network_address,
2584 self.assertEqual(
2585 self.ipv6_network.broadcast_address,
2587 self.assertEqual(self.ipv6_network.hostmask,
2589 self.assertEqual(
2590 self.ipv6_interface.network.broadcast_address,
2592 self.assertEqual(self.ipv6_interface.network.hostmask,
2596 self.assertIn('broadcast_address', self.ipv6_network.__dict__)
2597 self.assertIn('hostmask', self.ipv6_network.__dict__)
2598 self.assertIn('broadcast_address', self.ipv6_interface.network.__dict__)
2599 self.assertIn('hostmask', self.ipv6_interface.network.__dict__)
2601 def testTeredo(self):
2606 self.assertEqual((server, client),
2609 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
2611 self.assertFalse(ipaddress.ip_address(bad_addr).teredo)
2615 self.assertEqual((ipaddress.IPv4Address('94.245.121.253'),
2619 def testsixtofour(self):
2622 self.assertEqual(ipaddress.IPv4Address('172.29.45.100'),
2624 self.assertFalse(bad_addr.sixtofour)
2627 def testV4HashIsNotConstant(self):
2630 self.assertNotEqual(ipv4_address1.__hash__(), ipv4_address2.__hash__())
2633 def testV6HashIsNotConstant(self):
2636 self.assertNotEqual(ipv6_address1.__hash__(), ipv6_address2.__hash__())