diff --git a/Lib/test/test_ipaddress.py b/Lib/test/test_ipaddress.py
index 3a59a61..f4a4afb 100644
--- a/Lib/test/test_ipaddress.py
+++ b/Lib/test/test_ipaddress.py
@@ -170,6 +170,15 @@
         assertBadLength(15)
         assertBadLength(17)
 
+    def test_blank_scope_id(self):
+        address = ('::1%')
+        with self.assertAddressError('Invalid IPv6 address: "%r"', address):
+            self.factory(address)
+
+    def test_invalid_scope_id_with_percent(self):
+        address = ('::1%scope%')
+        with self.assertAddressError('Invalid IPv6 address: "%r"', address):
+            self.factory(address)
 
 class AddressTestCase_v4(BaseTestCase, CommonTestMixin_v4):
     factory = ipaddress.IPv4Address
@@ -328,24 +337,30 @@
             self.assertEqual(txt, format(v6, fmt))
 
     def test_network_passed_as_address(self):
-        addr = "::1/24"
-        with self.assertAddressError("Unexpected '/' in %r", addr):
-            ipaddress.IPv6Address(addr)
+        def assertBadSplit(addr):
+            msg = "Unexpected '/' in %r"
+            with self.assertAddressError(msg, addr):
+                ipaddress.IPv6Address(addr)
+        assertBadSplit("::1/24")
+        assertBadSplit("::1%scope_id/24")
 
     def test_bad_address_split_v6_not_enough_parts(self):
         def assertBadSplit(addr):
             msg = "At least 3 parts expected in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit(":")
         assertBadSplit(":1")
         assertBadSplit("FEDC:9878")
+        assertBadSplit(":%scope")
+        assertBadSplit(":1%scope")
+        assertBadSplit("FEDC:9878%scope")
 
     def test_bad_address_split_v6_too_many_colons(self):
         def assertBadSplit(addr):
             msg = "At most 8 colons permitted in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit("9:8:7:6:5:4:3::2:1")
@@ -355,10 +370,17 @@
         # A trailing IPv4 address is two parts
         assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42")
 
+        assertBadSplit("9:8:7:6:5:4:3::2:1%scope")
+        assertBadSplit("10:9:8:7:6:5:4:3:2:1%scope")
+        assertBadSplit("::8:7:6:5:4:3:2:1%scope")
+        assertBadSplit("8:7:6:5:4:3:2:1::%scope")
+        # A trailing IPv4 address is two parts
+        assertBadSplit("10:9:8:7:6:5:4:3:42.42.42.42%scope")
+
     def test_bad_address_split_v6_too_many_parts(self):
         def assertBadSplit(addr):
             msg = "Exactly 8 parts expected without '::' in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit("3ffe:0:0:0:0:0:0:0:1")
@@ -368,18 +390,26 @@
         assertBadSplit("9:8:7:6:5:4:3:42.42.42.42")
         assertBadSplit("7:6:5:4:3:42.42.42.42")
 
+        assertBadSplit("3ffe:0:0:0:0:0:0:0:1%scope")
+        assertBadSplit("9:8:7:6:5:4:3:2:1%scope")
+        assertBadSplit("7:6:5:4:3:2:1%scope")
+        # A trailing IPv4 address is two parts
+        assertBadSplit("9:8:7:6:5:4:3:42.42.42.42%scope")
+        assertBadSplit("7:6:5:4:3:42.42.42.42%scope")
+
     def test_bad_address_split_v6_too_many_parts_with_double_colon(self):
         def assertBadSplit(addr):
             msg = "Expected at most 7 other parts with '::' in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit("1:2:3:4::5:6:7:8")
+        assertBadSplit("1:2:3:4::5:6:7:8%scope")
 
     def test_bad_address_split_v6_repeated_double_colon(self):
         def assertBadSplit(addr):
             msg = "At most one '::' permitted in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit("3ffe::1::1")
@@ -393,10 +423,21 @@
         assertBadSplit(":::")
         assertBadSplit('2001:db8:::1')
 
+        assertBadSplit("3ffe::1::1%scope")
+        assertBadSplit("1::2::3::4:5%scope")
+        assertBadSplit("2001::db:::1%scope")
+        assertBadSplit("3ffe::1::%scope")
+        assertBadSplit("::3ffe::1%scope")
+        assertBadSplit(":3ffe::1::1%scope")
+        assertBadSplit("3ffe::1::1:%scope")
+        assertBadSplit(":3ffe::1::1:%scope")
+        assertBadSplit(":::%scope")
+        assertBadSplit('2001:db8:::1%scope')
+
     def test_bad_address_split_v6_leading_colon(self):
         def assertBadSplit(addr):
             msg = "Leading ':' only permitted as part of '::' in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit(":2001:db8::1")
@@ -404,10 +445,15 @@
         assertBadSplit(":1:2:3:4:5:6:")
         assertBadSplit(":6:5:4:3:2:1::")
 
+        assertBadSplit(":2001:db8::1%scope")
+        assertBadSplit(":1:2:3:4:5:6:7%scope")
+        assertBadSplit(":1:2:3:4:5:6:%scope")
+        assertBadSplit(":6:5:4:3:2:1::%scope")
+
     def test_bad_address_split_v6_trailing_colon(self):
         def assertBadSplit(addr):
             msg = "Trailing ':' only permitted as part of '::' in %r"
-            with self.assertAddressError(msg, addr):
+            with self.assertAddressError(msg, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadSplit("2001:db8::1:")
@@ -415,9 +461,14 @@
         assertBadSplit("::1.2.3.4:")
         assertBadSplit("::7:6:5:4:3:2:")
 
+        assertBadSplit("2001:db8::1:%scope")
+        assertBadSplit("1:2:3:4:5:6:7:%scope")
+        assertBadSplit("::1.2.3.4:%scope")
+        assertBadSplit("::7:6:5:4:3:2:%scope")
+
     def test_bad_v4_part_in(self):
         def assertBadAddressPart(addr, v4_error):
-            with self.assertAddressError("%s in %r", v4_error, addr):
+            with self.assertAddressError("%s in %r", v4_error, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadAddressPart("3ffe::1.net", "Expected 4 octets in '1.net'")
@@ -431,9 +482,20 @@
                              "Only decimal digits permitted in 'net' "
                              "in '1.1.1.net'")
 
+        assertBadAddressPart("3ffe::1.net%scope", "Expected 4 octets in '1.net'")
+        assertBadAddressPart("3ffe::127.0.1%scope",
+                             "Expected 4 octets in '127.0.1'")
+        assertBadAddressPart("::1.2.3%scope",
+                             "Expected 4 octets in '1.2.3'")
+        assertBadAddressPart("::1.2.3.4.5%scope",
+                             "Expected 4 octets in '1.2.3.4.5'")
+        assertBadAddressPart("3ffe::1.1.1.net%scope",
+                             "Only decimal digits permitted in 'net' "
+                             "in '1.1.1.net'")
+
     def test_invalid_characters(self):
         def assertBadPart(addr, part):
-            msg = "Only hex digits permitted in %r in %r" % (part, addr)
+            msg = "Only hex digits permitted in %r in %r" % (part, addr.split('%')[0])
             with self.assertAddressError(re.escape(msg)):
                 ipaddress.IPv6Address(addr)
 
@@ -444,10 +506,17 @@
         assertBadPart("1.2.3.4::", "1.2.3.4")
         assertBadPart('1234:axy::b', "axy")
 
+        assertBadPart("3ffe::goog%scope", "goog")
+        assertBadPart("3ffe::-0%scope", "-0")
+        assertBadPart("3ffe::+0%scope", "+0")
+        assertBadPart("3ffe::-1%scope", "-1")
+        assertBadPart("1.2.3.4::%scope", "1.2.3.4")
+        assertBadPart('1234:axy::b%scope', "axy")
+
     def test_part_length(self):
         def assertBadPart(addr, part):
             msg = "At most 4 characters permitted in %r in %r"
-            with self.assertAddressError(msg, part, addr):
+            with self.assertAddressError(msg, part, addr.split('%')[0]):
                 ipaddress.IPv6Address(addr)
 
         assertBadPart("::00000", "00000")
@@ -455,11 +524,17 @@
         assertBadPart("02001:db8::", "02001")
         assertBadPart('2001:888888::1', "888888")
 
+        assertBadPart("::00000%scope", "00000")
+        assertBadPart("3ffe::10000%scope", "10000")
+        assertBadPart("02001:db8::%scope", "02001")
+        assertBadPart('2001:888888::1%scope', "888888")
+
     def test_pickle(self):
         self.pickle_test('2001:db8::')
 
     def test_weakref(self):
         weakref.ref(self.factory('2001:db8::'))
+        weakref.ref(self.factory('2001:db8::%scope'))
 
 
 class NetmaskTestMixin_v4(CommonTestMixin_v4):
@@ -617,11 +692,20 @@
             # IPv6Network has prefixlen, but IPv6Interface doesn't.
             # Should we add it to IPv4Interface too? (bpo-36392)
 
+        scoped_net = self.factory('::1%scope')
+        self.assertEqual(str(scoped_net), '::1%scope/128')
+        self.assertEqual(str(scoped_net.netmask), 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
+        self.assertEqual(str(scoped_net.hostmask), '::')
+
     def test_split_netmask(self):
         addr = "cafe:cafe::/128/190"
         with self.assertAddressError("Only one '/' permitted in %r" % addr):
             self.factory(addr)
 
+        scoped_addr = "cafe:cafe::%scope/128/190"
+        with self.assertAddressError("Only one '/' permitted in %r" % scoped_addr):
+            self.factory(scoped_addr)
+
     def test_address_errors(self):
         def assertBadAddress(addr, details):
             with self.assertAddressError(details):
@@ -634,6 +718,13 @@
         assertBadAddress("10/8", "At least 3 parts")
         assertBadAddress("1234:axy::b", "Only hex digits")
 
+        assertBadAddress("/%scope", "Address cannot be empty")
+        assertBadAddress("/%scope8", "Address cannot be empty")
+        assertBadAddress("google.com%scope", "At least 3 parts")
+        assertBadAddress("1.2.3.4%scope", "At least 3 parts")
+        assertBadAddress("10%scope/8", "At least 3 parts")
+        assertBadAddress("1234:axy::b%scope", "Only hex digits")
+
     def test_valid_netmask(self):
         # We only support CIDR for IPv6, because expanded netmasks are not
         # standard notation.
@@ -645,6 +736,14 @@
             # Zero prefix is treated as decimal.
             self.assertEqual(str(self.factory('::/0%d' % i)), net_str)
 
+        self.assertEqual(str(self.factory('2001:db8::%scope/32')), '2001:db8::%scope/32')
+        for i in range(0, 129):
+            # Generate and re-parse the CIDR format (trivial).
+            net_str = '::/%d' % i
+            self.assertEqual(str(self.factory(net_str)), net_str)
+            # Zero prefix is treated as decimal.
+            self.assertEqual(str(self.factory('::/0%d' % i)), net_str)
+
     def test_netmask_errors(self):
         def assertBadNetmask(addr, netmask):
             msg = "%r is not a valid netmask" % netmask
@@ -663,6 +762,8 @@
         assertBadNetmask("::1", "pudding")
         assertBadNetmask("::", "::")
 
+        assertBadNetmask("::1%scope", "pudding")
+
     def test_netmask_in_tuple_errors(self):
         def assertBadNetmask(addr, netmask):
             msg = "%r is not a valid netmask" % netmask
@@ -670,12 +771,15 @@
                 self.factory((addr, netmask))
         assertBadNetmask("::1", -1)
         assertBadNetmask("::1", 129)
+        assertBadNetmask("::1%scope", 129)
 
     def test_pickle(self):
         self.pickle_test('2001:db8::1000/124')
         self.pickle_test('2001:db8::1000/127')  # IPV6LENGTH - 1
         self.pickle_test('2001:db8::1000')      # IPV6LENGTH
 
+        self.pickle_test('2001:db8::1000%scope')      # IPV6LENGTH
+
 
 class InterfaceTestCase_v6(BaseTestCase, NetmaskTestMixin_v6):
     factory = ipaddress.IPv6Interface
@@ -702,6 +806,13 @@
             self.factory('2000:aaa::/48').subnet_of(
                 self.factory('2000:aaa::/56')))
 
+        self.assertFalse(
+            self.factory('2000:999::%scope/56').subnet_of(
+                self.factory('2000:aaa::%scope/48')))
+        self.assertTrue(
+            self.factory('2000:aaa::%scope/56').subnet_of(
+                self.factory('2000:aaa::%scope/48')))
+
     def test_supernet_of(self):
         # containee left of container
         self.assertFalse(
@@ -748,13 +859,19 @@
     v6addr = ipaddress.IPv6Address(1)
     v6net = ipaddress.IPv6Network(1)
     v6intf = ipaddress.IPv6Interface(1)
+    v6addr_scoped = ipaddress.IPv6Address('::1%scope')
+    v6net_scoped= ipaddress.IPv6Network('::1%scope')
+    v6intf_scoped= ipaddress.IPv6Interface('::1%scope')
 
     v4_addresses = [v4addr, v4intf]
     v4_objects = v4_addresses + [v4net]
     v6_addresses = [v6addr, v6intf]
     v6_objects = v6_addresses + [v6net]
+    v6_scoped_addresses = [v6addr_scoped, v6intf_scoped]
+    v6_scoped_objects = v6_scoped_addresses + [v6net_scoped]
 
     objects = v4_objects + v6_objects
+    objects_with_scoped = objects + v6_scoped_objects
 
     v4addr2 = ipaddress.IPv4Address(2)
     v4net2 = ipaddress.IPv4Network(2)
@@ -762,11 +879,14 @@
     v6addr2 = ipaddress.IPv6Address(2)
     v6net2 = ipaddress.IPv6Network(2)
     v6intf2 = ipaddress.IPv6Interface(2)
+    v6addr2_scoped = ipaddress.IPv6Address('::2%scope')
+    v6net2_scoped = ipaddress.IPv6Network('::2%scope')
+    v6intf2_scoped = ipaddress.IPv6Interface('::2%scope')
 
     def test_foreign_type_equality(self):
         # __eq__ should never raise TypeError directly
         other = object()
-        for obj in self.objects:
+        for obj in self.objects_with_scoped:
             self.assertNotEqual(obj, other)
             self.assertFalse(obj == other)
             self.assertEqual(obj.__eq__(other), NotImplemented)
@@ -781,8 +901,17 @@
                     continue
                 self.assertNotEqual(lhs, rhs)
 
+    def test_scoped_ipv6_equality(self):
+        for lhs, rhs in zip(self.v6_objects, self.v6_scoped_objects):
+            self.assertNotEqual(lhs, rhs)
+
+    def test_v4_with_v6_scoped_equality(self):
+        for lhs in self.v4_objects:
+            for rhs in self.v6_scoped_objects:
+                self.assertNotEqual(lhs, rhs)
+
     def test_same_type_equality(self):
-        for obj in self.objects:
+        for obj in self.objects_with_scoped:
             self.assertEqual(obj, obj)
             self.assertLessEqual(obj, obj)
             self.assertGreaterEqual(obj, obj)
@@ -795,6 +924,9 @@
             (self.v6addr, self.v6addr2),
             (self.v6net, self.v6net2),
             (self.v6intf, self.v6intf2),
+            (self.v6addr_scoped, self.v6addr2_scoped),
+            (self.v6net_scoped, self.v6net2_scoped),
+            (self.v6intf_scoped, self.v6intf2_scoped),
         ):
             self.assertNotEqual(lhs, rhs)
             self.assertLess(lhs, rhs)
@@ -809,16 +941,21 @@
     def test_containment(self):
         for obj in self.v4_addresses:
             self.assertIn(obj, self.v4net)
-        for obj in self.v6_addresses:
+        for obj in self.v6_addresses + self.v6_scoped_addresses:
             self.assertIn(obj, self.v6net)
-        for obj in self.v4_objects + [self.v6net]:
+        for obj in self.v6_addresses + self.v6_scoped_addresses:
+            self.assertIn(obj, self.v6net_scoped)
+
+        for obj in self.v4_objects + [self.v6net, self.v6net_scoped]:
             self.assertNotIn(obj, self.v6net)
-        for obj in self.v6_objects + [self.v4net]:
+        for obj in self.v4_objects + [self.v6net, self.v6net_scoped]:
+            self.assertNotIn(obj, self.v6net_scoped)
+        for obj in self.v6_objects + self.v6_scoped_objects + [self.v4net]:
             self.assertNotIn(obj, self.v4net)
 
     def test_mixed_type_ordering(self):
-        for lhs in self.objects:
-            for rhs in self.objects:
+        for lhs in self.objects_with_scoped:
+            for rhs in self.objects_with_scoped:
                 if isinstance(lhs, type(rhs)) or isinstance(rhs, type(lhs)):
                     continue
                 self.assertRaises(TypeError, lambda: lhs < rhs)
@@ -828,7 +965,7 @@
 
     def test_foreign_type_ordering(self):
         other = object()
-        for obj in self.objects:
+        for obj in self.objects_with_scoped:
             with self.assertRaises(TypeError):
                 obj < other
             with self.assertRaises(TypeError):
@@ -850,14 +987,18 @@
         # with get_mixed_type_key, you can sort addresses and network.
         v4_ordered = [self.v4addr, self.v4net, self.v4intf]
         v6_ordered = [self.v6addr, self.v6net, self.v6intf]
+        v6_scoped_ordered = [self.v6addr_scoped, self.v6net_scoped, self.v6intf_scoped]
         self.assertEqual(v4_ordered,
                          sorted(self.v4_objects,
                                 key=ipaddress.get_mixed_type_key))
         self.assertEqual(v6_ordered,
                          sorted(self.v6_objects,
                                 key=ipaddress.get_mixed_type_key))
-        self.assertEqual(v4_ordered + v6_ordered,
-                         sorted(self.objects,
+        self.assertEqual(v6_scoped_ordered,
+                         sorted(self.v6_scoped_objects,
+                                key=ipaddress.get_mixed_type_key))
+        self.assertEqual(v4_ordered + v6_scoped_ordered,
+                         sorted(self.v4_objects + self.v6_scoped_objects,
                                 key=ipaddress.get_mixed_type_key))
         self.assertEqual(NotImplemented, ipaddress.get_mixed_type_key(object))
 
@@ -867,6 +1008,8 @@
         v4net = ipaddress.ip_network('1.1.1.1')
         v6addr = ipaddress.ip_address('::1')
         v6net = ipaddress.ip_network('::1')
+        v6addr_scoped = ipaddress.ip_address('::1%scope')
+        v6net_scoped = ipaddress.ip_network('::1%scope')
 
         self.assertRaises(TypeError, v4addr.__lt__, v6addr)
         self.assertRaises(TypeError, v4addr.__gt__, v6addr)
@@ -878,6 +1021,16 @@
         self.assertRaises(TypeError, v6net.__lt__, v4net)
         self.assertRaises(TypeError, v6net.__gt__, v4net)
 
+        self.assertRaises(TypeError, v4addr.__lt__, v6addr_scoped)
+        self.assertRaises(TypeError, v4addr.__gt__, v6addr_scoped)
+        self.assertRaises(TypeError, v4net.__lt__, v6net_scoped)
+        self.assertRaises(TypeError, v4net.__gt__, v6net_scoped)
+
+        self.assertRaises(TypeError, v6addr_scoped.__lt__, v4addr)
+        self.assertRaises(TypeError, v6addr_scoped.__gt__, v4addr)
+        self.assertRaises(TypeError, v6net_scoped.__lt__, v4net)
+        self.assertRaises(TypeError, v6net_scoped.__gt__, v4net)
+
 
 class IpaddrUnitTest(unittest.TestCase):
 
@@ -891,12 +1044,19 @@
         self.ipv6_interface = ipaddress.IPv6Interface(
             '2001:658:22a:cafe:200:0:0:1/64')
         self.ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/64')
+        self.ipv6_scoped_address = ipaddress.IPv6Interface(
+            '2001:658:22a:cafe:200:0:0:1%scope')
+        self.ipv6_scoped_interface = ipaddress.IPv6Interface(
+            '2001:658:22a:cafe:200:0:0:1%scope/64')
+        self.ipv6_scoped_network = ipaddress.IPv6Network('2001:658:22a:cafe::%scope/64')
 
     def testRepr(self):
         self.assertEqual("IPv4Interface('1.2.3.4/32')",
                          repr(ipaddress.IPv4Interface('1.2.3.4')))
         self.assertEqual("IPv6Interface('::1/128')",
                          repr(ipaddress.IPv6Interface('::1')))
+        self.assertEqual("IPv6Interface('::1%scope/128')",
+                         repr(ipaddress.IPv6Interface('::1%scope')))
 
     # issue #16531: constructing IPv4Network from an (address, mask) tuple
     def testIPv4Tuple(self):
@@ -983,6 +1143,8 @@
         self.assertEqual(ipaddress.IPv6Network((ip, '96')),
                          net)
 
+        ip_scoped = ipaddress.IPv6Address('2001:db8::%scope')
+
         # strict=True and host bits set
         ip = ipaddress.IPv6Address('2001:db8::1')
         with self.assertRaises(ValueError):
@@ -1011,6 +1173,13 @@
                 (42540766411282592856903984951653826561, '96')),
                          ipaddress.IPv6Interface('2001:db8::1/96'))
 
+        ip_scoped = ipaddress.IPv6Address('2001:db8::1%scope')
+        with self.assertRaises(ValueError):
+            ipaddress.IPv6Network(('2001:db8::1%scope', 96))
+        with self.assertRaises(ValueError):
+            ipaddress.IPv6Network((ip_scoped, 96))
+        # strict=False and host bits set
+
     # issue57
     def testAddressIntMath(self):
         self.assertEqual(ipaddress.IPv4Address('1.1.1.1') + 255,
@@ -1021,6 +1190,10 @@
                          ipaddress.IPv6Address('::ffff'))
         self.assertEqual(ipaddress.IPv6Address('::ffff') - (2**16 - 2),
                          ipaddress.IPv6Address('::1'))
+        self.assertNotEqual(ipaddress.IPv6Address('::1%scope') + (2**16 - 2),
+                            ipaddress.IPv6Address('::ffff%scope'))
+        self.assertNotEqual(ipaddress.IPv6Address('::ffff%scope') - (2**16 - 2),
+                            ipaddress.IPv6Address('::1%scope'))
 
     def testInvalidIntToBytes(self):
         self.assertRaises(ValueError, ipaddress.v4_int_to_packed, -1)
@@ -1053,6 +1226,12 @@
                          '2001:658:22a:cafe::')
         self.assertEqual(str(self.ipv6_network.hostmask),
                          '::ffff:ffff:ffff:ffff')
+        self.assertEqual(int(self.ipv6_scoped_network.network_address),
+                         42540616829182469433403647294022090752)
+        self.assertEqual(str(self.ipv6_scoped_network.network_address),
+                         '2001:658:22a:cafe::%scope')
+        self.assertEqual(str(self.ipv6_scoped_network.hostmask),
+                         '::ffff:ffff:ffff:ffff')
 
     def testIpFromInt(self):
         self.assertEqual(self.ipv4_interface._ip,
@@ -1060,17 +1239,23 @@
 
         ipv4 = ipaddress.ip_network('1.2.3.4')
         ipv6 = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1')
+        ipv6_scoped = ipaddress.ip_network('2001:658:22a:cafe:200:0:0:1%scope')
         self.assertEqual(ipv4, ipaddress.ip_network(int(ipv4.network_address)))
         self.assertEqual(ipv6, ipaddress.ip_network(int(ipv6.network_address)))
+        self.assertNotEqual(ipv6_scoped, ipaddress.ip_network(int(ipv6_scoped.network_address)))
 
         v6_int = 42540616829182469433547762482097946625
         self.assertEqual(self.ipv6_interface._ip,
                          ipaddress.IPv6Interface(v6_int)._ip)
+        self.assertEqual(self.ipv6_scoped_interface._ip,
+                         ipaddress.IPv6Interface(v6_int)._ip)
 
         self.assertEqual(ipaddress.ip_network(self.ipv4_address._ip).version,
                          4)
         self.assertEqual(ipaddress.ip_network(self.ipv6_address._ip).version,
                          6)
+        self.assertEqual(ipaddress.ip_network(self.ipv6_scoped_address._ip).version,
+                         6)
 
     def testIpFromPacked(self):
         address = ipaddress.ip_address
@@ -1096,6 +1281,24 @@
                          42540616829182469433547762482097946625)
         self.assertEqual(str(self.ipv6_interface.ip),
                          '2001:658:22a:cafe:200::1')
+        self.assertEqual(int(self.ipv6_scoped_interface.ip),
+                         42540616829182469433547762482097946625)
+        self.assertEqual(str(self.ipv6_scoped_interface.ip),
+                         '2001:658:22a:cafe:200::1')
+
+    def testGetScopeId(self):
+        self.assertEqual(self.ipv6_address.scope_id,
+                         None)
+        self.assertEqual(str(self.ipv6_scoped_address.scope_id),
+                         'scope')
+        self.assertEqual(self.ipv6_interface.scope_id,
+                         None)
+        self.assertEqual(str(self.ipv6_scoped_interface.scope_id),
+                         'scope')
+        self.assertEqual(self.ipv6_network.network_address.scope_id,
+                         None)
+        self.assertEqual(str(self.ipv6_scoped_network.network_address.scope_id),
+                         'scope')
 
     def testGetNetmask(self):
         self.assertEqual(int(self.ipv4_network.netmask), 4294967040)
@@ -1103,6 +1306,9 @@
         self.assertEqual(int(self.ipv6_network.netmask),
                          340282366920938463444927863358058659840)
         self.assertEqual(self.ipv6_network.prefixlen, 64)
+        self.assertEqual(int(self.ipv6_scoped_network.netmask),
+                         340282366920938463444927863358058659840)
+        self.assertEqual(self.ipv6_scoped_network.prefixlen, 64)
 
     def testZeroNetmask(self):
         ipv4_zero_netmask = ipaddress.IPv4Interface('1.2.3.4/0')
@@ -1113,6 +1319,10 @@
         self.assertEqual(int(ipv6_zero_netmask.network.netmask), 0)
         self.assertEqual(ipv6_zero_netmask._prefix_from_prefix_string('0'), 0)
 
+        ipv6_scoped_zero_netmask = ipaddress.IPv6Interface('::1%scope/0')
+        self.assertEqual(int(ipv6_scoped_zero_netmask.network.netmask), 0)
+        self.assertEqual(ipv6_scoped_zero_netmask._prefix_from_prefix_string('0'), 0)
+
     def testIPv4Net(self):
         net = ipaddress.IPv4Network('127.0.0.0/0.0.0.255')
         self.assertEqual(net.prefixlen, 24)
@@ -1126,9 +1336,15 @@
         self.assertEqual(str(self.ipv6_network.broadcast_address),
                          '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
 
+        self.assertEqual(int(self.ipv6_scoped_network.broadcast_address),
+                         42540616829182469451850391367731642367)
+        self.assertEqual(str(self.ipv6_scoped_network.broadcast_address),
+                         '2001:658:22a:cafe:ffff:ffff:ffff:ffff')
+
     def testGetPrefixlen(self):
         self.assertEqual(self.ipv4_interface.network.prefixlen, 24)
         self.assertEqual(self.ipv6_interface.network.prefixlen, 64)
+        self.assertEqual(self.ipv6_scoped_interface.network.prefixlen, 64)
 
     def testGetSupernet(self):
         self.assertEqual(self.ipv4_network.supernet().prefixlen, 23)
@@ -1143,6 +1359,9 @@
                          '2001:658:22a:cafe::')
         self.assertEqual(ipaddress.IPv6Interface('::0/0').network.supernet(),
                          ipaddress.IPv6Network('::0/0'))
+        self.assertEqual(self.ipv6_scoped_network.supernet().prefixlen, 63)
+        self.assertEqual(str(self.ipv6_scoped_network.supernet().network_address),
+                         '2001:658:22a:cafe::')
 
     def testGetSupernet3(self):
         self.assertEqual(self.ipv4_network.supernet(3).prefixlen, 21)
@@ -1152,6 +1371,9 @@
         self.assertEqual(self.ipv6_network.supernet(3).prefixlen, 61)
         self.assertEqual(str(self.ipv6_network.supernet(3).network_address),
                          '2001:658:22a:caf8::')
+        self.assertEqual(self.ipv6_scoped_network.supernet(3).prefixlen, 61)
+        self.assertEqual(str(self.ipv6_scoped_network.supernet(3).network_address),
+                         '2001:658:22a:caf8::')
 
     def testGetSupernet4(self):
         self.assertRaises(ValueError, self.ipv4_network.supernet,
@@ -1167,6 +1389,12 @@
                           new_prefix=65)
         self.assertEqual(self.ipv6_network.supernet(prefixlen_diff=2),
                          self.ipv6_network.supernet(new_prefix=62))
+        self.assertRaises(ValueError, self.ipv6_scoped_network.supernet,
+                          prefixlen_diff=2, new_prefix=1)
+        self.assertRaises(ValueError, self.ipv6_scoped_network.supernet,
+                          new_prefix=65)
+        self.assertEqual(self.ipv6_scoped_network.supernet(prefixlen_diff=2),
+                         self.ipv6_scoped_network.supernet(new_prefix=62))
 
     def testHosts(self):
         hosts = list(self.ipv4_network.hosts())
@@ -1180,6 +1408,12 @@
         self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
         self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
 
+        ipv6_scoped_network = ipaddress.IPv6Network('2001:658:22a:cafe::%scope/120')
+        hosts = list(ipv6_scoped_network.hosts())
+        self.assertEqual(255, len(hosts))
+        self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
+        self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
+
         # special case where only 1 bit is left for address
         addrs = [ipaddress.IPv4Address('2.0.0.0'),
                  ipaddress.IPv4Address('2.0.0.1')]
@@ -1198,6 +1432,14 @@
         self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
         self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
                          list(ipaddress.ip_network(tpl_args).hosts()))
+        addrs = [ipaddress.IPv6Address('2001:658:22a:cafe::'),
+                 ipaddress.IPv6Address('2001:658:22a:cafe::1')]
+        str_args = '2001:658:22a:cafe::/127'
+        tpl_args = ('2001:658:22a:cafe::', 127)
+        self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
+        self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
+        self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
+                         list(ipaddress.ip_network(tpl_args).hosts()))
 
     def testFancySubnetting(self):
         self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),
@@ -1214,6 +1456,13 @@
         self.assertRaises(ValueError, list,
                           self.ipv6_network.subnets(prefixlen_diff=4,
                                                    new_prefix=68))
+        self.assertEqual(sorted(self.ipv6_scoped_network.subnets(prefixlen_diff=4)),
+                         sorted(self.ipv6_scoped_network.subnets(new_prefix=68)))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_network.subnets(new_prefix=63))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_network.subnets(prefixlen_diff=4,
+                                                           new_prefix=68))
 
     def testGetSubnets(self):
         self.assertEqual(list(self.ipv4_network.subnets())[0].prefixlen, 25)
@@ -1225,6 +1474,7 @@
                          '1.2.3.128')
 
         self.assertEqual(list(self.ipv6_network.subnets())[0].prefixlen, 65)
+        self.assertEqual(list(self.ipv6_scoped_network.subnets())[0].prefixlen, 65)
 
     def testGetSubnetForSingle32(self):
         ip = ipaddress.IPv4Network('1.2.3.4/32')
@@ -1240,6 +1490,12 @@
         self.assertEqual(subnets1, ['::1/128'])
         self.assertEqual(subnets1, subnets2)
 
+        ip_scoped = ipaddress.IPv6Network('::1%scope/128')
+        subnets1 = [str(x) for x in ip_scoped.subnets()]
+        subnets2 = [str(x) for x in ip_scoped.subnets(2)]
+        self.assertEqual(subnets1, ['::1%scope/128'])
+        self.assertEqual(subnets1, subnets2)
+
     def testSubnet2(self):
         ips = [str(x) for x in self.ipv4_network.subnets(2)]
         self.assertEqual(
@@ -1283,12 +1539,18 @@
                           self.ipv6_interface.network.subnets(65))
         self.assertRaises(ValueError, list,
                           self.ipv6_network.subnets(65))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_interface.network.subnets(65))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_network.subnets(65))
 
     def testSupernetFailsForLargeCidrDiff(self):
         self.assertRaises(ValueError,
                           self.ipv4_interface.network.supernet, 25)
         self.assertRaises(ValueError,
                           self.ipv6_interface.network.supernet, 65)
+        self.assertRaises(ValueError,
+                          self.ipv6_scoped_interface.network.supernet, 65)
 
     def testSubnetFailsForNegativeCidrDiff(self):
         self.assertRaises(ValueError, list,
@@ -1299,6 +1561,10 @@
                           self.ipv6_interface.network.subnets(-1))
         self.assertRaises(ValueError, list,
                           self.ipv6_network.subnets(-1))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_interface.network.subnets(-1))
+        self.assertRaises(ValueError, list,
+                          self.ipv6_scoped_network.subnets(-1))
 
     def testGetNum_Addresses(self):
         self.assertEqual(self.ipv4_network.num_addresses, 256)
@@ -1311,6 +1577,11 @@
                          9223372036854775808)
         self.assertEqual(self.ipv6_network.supernet().num_addresses,
                          36893488147419103232)
+        self.assertEqual(self.ipv6_scoped_network.num_addresses, 18446744073709551616)
+        self.assertEqual(list(self.ipv6_scoped_network.subnets())[0].num_addresses,
+                         9223372036854775808)
+        self.assertEqual(self.ipv6_scoped_network.supernet().num_addresses,
+                         36893488147419103232)
 
     def testContains(self):
         self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'),
@@ -1332,6 +1603,9 @@
         self.assertEqual(str(self.ipv6_network[5]),
                          '2001:658:22a:cafe::5')
         self.assertRaises(IndexError, self.ipv6_network.__getitem__, 1 << 64)
+        self.assertEqual(str(self.ipv6_scoped_network[5]),
+                         '2001:658:22a:cafe::5')
+        self.assertRaises(IndexError, self.ipv6_scoped_network.__getitem__, 1 << 64)
 
     def testGetitem(self):
         # http://code.google.com/p/ipaddr-py/issues/detail?id=15
@@ -1351,6 +1625,8 @@
                          ipaddress.IPv4Interface('1.2.3.4/23'))
         self.assertFalse(self.ipv4_interface ==
                          ipaddress.IPv6Interface('::1.2.3.4/24'))
+        self.assertFalse(self.ipv4_interface ==
+                         ipaddress.IPv6Interface('::1.2.3.4%scope/24'))
         self.assertFalse(self.ipv4_interface == '')
         self.assertFalse(self.ipv4_interface == [])
         self.assertFalse(self.ipv4_interface == 2)
@@ -1365,6 +1641,20 @@
         self.assertFalse(self.ipv6_interface == [])
         self.assertFalse(self.ipv6_interface == 2)
 
+        self.assertTrue(self.ipv6_scoped_interface ==
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1%scope/64'))
+        self.assertFalse(self.ipv6_scoped_interface ==
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1%scope/63'))
+        self.assertFalse(self.ipv6_scoped_interface ==
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
+        self.assertFalse(self.ipv6_scoped_interface ==
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
+        self.assertFalse(self.ipv6_scoped_interface ==
+                         ipaddress.IPv4Interface('1.2.3.4/23'))
+        self.assertFalse(self.ipv6_scoped_interface == '')
+        self.assertFalse(self.ipv6_scoped_interface == [])
+        self.assertFalse(self.ipv6_scoped_interface == 2)
+
     def testNotEqual(self):
         self.assertFalse(self.ipv4_interface !=
                          ipaddress.IPv4Interface('1.2.3.4/24'))
@@ -1372,6 +1662,8 @@
                         ipaddress.IPv4Interface('1.2.3.4/23'))
         self.assertTrue(self.ipv4_interface !=
                         ipaddress.IPv6Interface('::1.2.3.4/24'))
+        self.assertTrue(self.ipv4_interface !=
+                        ipaddress.IPv6Interface('::1.2.3.4%scope/24'))
         self.assertTrue(self.ipv4_interface != '')
         self.assertTrue(self.ipv4_interface != [])
         self.assertTrue(self.ipv4_interface != 2)
@@ -1398,6 +1690,26 @@
         self.assertTrue(self.ipv6_address != [])
         self.assertTrue(self.ipv6_address != 2)
 
+        self.assertFalse(self.ipv6_scoped_interface !=
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1%scope/64'))
+        self.assertTrue(self.ipv6_scoped_interface !=
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1%scope/63'))
+        self.assertTrue(self.ipv6_scoped_interface !=
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/64'))
+        self.assertTrue(self.ipv6_scoped_interface !=
+            ipaddress.IPv6Interface('2001:658:22a:cafe:200::1/63'))
+        self.assertTrue(self.ipv6_scoped_interface !=
+                        ipaddress.IPv4Interface('1.2.3.4/23'))
+        self.assertTrue(self.ipv6_scoped_interface != '')
+        self.assertTrue(self.ipv6_scoped_interface != [])
+        self.assertTrue(self.ipv6_scoped_interface != 2)
+
+        self.assertTrue(self.ipv6_scoped_address !=
+                        ipaddress.IPv4Address('1.2.3.4'))
+        self.assertTrue(self.ipv6_scoped_address != '')
+        self.assertTrue(self.ipv6_scoped_address != [])
+        self.assertTrue(self.ipv6_scoped_address != 2)
+
     def testSlash32Constructor(self):
         self.assertEqual(str(ipaddress.IPv4Interface(
                     '1.2.3.4/255.255.255.255')), '1.2.3.4/32')
@@ -1405,6 +1717,8 @@
     def testSlash128Constructor(self):
         self.assertEqual(str(ipaddress.IPv6Interface('::1/128')),
                                   '::1/128')
+        self.assertEqual(str(ipaddress.IPv6Interface('::1%scope/128')),
+                                  '::1%scope/128')
 
     def testSlash0Constructor(self):
         self.assertEqual(str(ipaddress.IPv4Interface('1.2.3.4/0.0.0.0')),
@@ -1476,6 +1790,13 @@
         collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3])
         self.assertEqual(list(collapsed), [ip3])
 
+        ip1 = ipaddress.IPv6Network('2001::%scope/100')
+        ip2 = ipaddress.IPv6Network('2001::%scope/120')
+        ip3 = ipaddress.IPv6Network('2001::%scope/96')
+        # test that ipv6 addresses are subsumed properly.
+        collapsed = ipaddress.collapse_addresses([ip1, ip2, ip3])
+        self.assertEqual(list(collapsed), [ip3])
+
         # the toejam test
         addr_tuples = [
                 (ipaddress.ip_address('1.1.1.1'),
@@ -1489,6 +1810,18 @@
             self.assertRaises(TypeError, ipaddress.collapse_addresses,
                               [ip1, ip2])
 
+        addr_tuples = [
+                (ipaddress.ip_address('1.1.1.1'),
+                 ipaddress.ip_address('::1%scope')),
+                (ipaddress.IPv4Network('1.1.0.0/24'),
+                 ipaddress.IPv6Network('2001::%scope/120')),
+                (ipaddress.IPv4Network('1.1.0.0/32'),
+                 ipaddress.IPv6Network('2001::%scope/128')),
+        ]
+        for ip1, ip2 in addr_tuples:
+            self.assertRaises(TypeError, ipaddress.collapse_addresses,
+                              [ip1, ip2])
+
     def testSummarizing(self):
         #ip = ipaddress.ip_address
         #ipnet = ipaddress.ip_network
@@ -1508,6 +1841,8 @@
         # test that a summary over ip4 & ip6 fails
         self.assertRaises(TypeError, list,
                           summarize(ip1, ipaddress.IPv6Address('::1')))
+        self.assertRaises(TypeError, list,
+                          summarize(ip1, ipaddress.IPv6Address('::1%scope')))
         # test a /24 is summarized properly
         self.assertEqual(list(summarize(ip1, ip2))[0],
                          ipaddress.ip_network('1.1.1.0/24'))
@@ -1533,6 +1868,17 @@
                          [ipaddress.ip_network('1::/16'),
                           ipaddress.ip_network('2::/128')])
 
+        ip1 = ipaddress.ip_address('1::%scope')
+        ip2 = ipaddress.ip_address('1:ffff:ffff:ffff:ffff:ffff:ffff:ffff%scope')
+        # test an IPv6 is summarized properly
+        self.assertEqual(list(summarize(ip1, ip2))[0],
+                         ipaddress.ip_network('1::/16'))
+        # test an IPv6 range that isn't on a network byte boundary
+        ip2 = ipaddress.ip_address('2::%scope')
+        self.assertEqual(list(summarize(ip1, ip2)),
+                         [ipaddress.ip_network('1::/16'),
+                          ipaddress.ip_network('2::/128')])
+
         # test exception raised when first is greater than last
         self.assertRaises(ValueError, list,
                           summarize(ipaddress.ip_address('1.1.1.0'),
@@ -1558,6 +1904,10 @@
                         ipaddress.ip_address('::1'))
         self.assertTrue(ipaddress.ip_address('::1') <=
                         ipaddress.ip_address('::2'))
+        self.assertTrue(ipaddress.ip_address('::1%scope') <=
+                        ipaddress.ip_address('::1%scope'))
+        self.assertTrue(ipaddress.ip_address('::1%scope') <=
+                        ipaddress.ip_address('::2%scope'))
 
     def testInterfaceComparison(self):
         self.assertTrue(ipaddress.ip_interface('1.1.1.1/24') ==
@@ -1590,6 +1940,52 @@
         self.assertTrue(ipaddress.ip_interface('::1/64') >
                         ipaddress.ip_interface('::2/48'))
 
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') ==
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
+                        ipaddress.ip_interface('::1%scope/80'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
+                        ipaddress.ip_interface('::2%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::2%scope/48') <
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/80') >
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::2%scope/64') >
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') >
+                        ipaddress.ip_interface('::2%scope/48'))
+
+
+        self.assertFalse(ipaddress.ip_interface('::1%scope/64') ==
+                        ipaddress.ip_interface('::1/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
+                        ipaddress.ip_interface('::1/80'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') <
+                        ipaddress.ip_interface('::2/64'))
+        self.assertTrue(ipaddress.ip_interface('::2%scope/48') <
+                        ipaddress.ip_interface('::1/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/80') >
+                        ipaddress.ip_interface('::1/64'))
+        self.assertTrue(ipaddress.ip_interface('::2%scope/64') >
+                        ipaddress.ip_interface('::1/64'))
+        self.assertTrue(ipaddress.ip_interface('::1%scope/64') >
+                        ipaddress.ip_interface('::2/48'))
+
+        self.assertFalse(ipaddress.ip_interface('::1/64') ==
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1/64') <
+                        ipaddress.ip_interface('::1%scope/80'))
+        self.assertTrue(ipaddress.ip_interface('::1/64') <
+                        ipaddress.ip_interface('::2%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::2/48') <
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1/80') >
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::2/64') >
+                        ipaddress.ip_interface('::1%scope/64'))
+        self.assertTrue(ipaddress.ip_interface('::1/64') >
+                        ipaddress.ip_interface('::2%scope/48'))
+
     def testNetworkComparison(self):
         # ip1 and ip2 have the same network address
         ip1 = ipaddress.IPv4Network('1.1.1.0/24')
@@ -1669,6 +2065,7 @@
                         ipaddress.ip_network('1.1.1.2'))
         self.assertFalse(ipaddress.ip_network('1.1.1.2') <=
                         ipaddress.ip_network('1.1.1.1'))
+
         self.assertTrue(ipaddress.ip_network('::1') <=
                         ipaddress.ip_network('::1'))
         self.assertTrue(ipaddress.ip_network('::1') <=
@@ -1679,6 +2076,7 @@
     def testStrictNetworks(self):
         self.assertRaises(ValueError, ipaddress.ip_network, '192.168.1.1/24')
         self.assertRaises(ValueError, ipaddress.ip_network, '::1/120')
+        self.assertRaises(ValueError, ipaddress.ip_network, '::1%scope/120')
 
     def testOverlaps(self):
         other = ipaddress.IPv4Network('1.2.3.0/30')
@@ -1707,13 +2105,28 @@
         self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
                           ipaddress.ip_address('FFFF::c000:201'))
 
+        self.assertEqual(ipaddress.ip_address('::FFFF:192.0.2.1%scope'),
+                          ipaddress.ip_address('::FFFF:c000:201%scope'))
+        self.assertEqual(ipaddress.ip_address('FFFF::192.0.2.1%scope'),
+                          ipaddress.ip_address('FFFF::c000:201%scope'))
+        self.assertNotEqual(ipaddress.ip_address('::FFFF:192.0.2.1%scope'),
+                            ipaddress.ip_address('::FFFF:c000:201'))
+        self.assertNotEqual(ipaddress.ip_address('FFFF::192.0.2.1%scope'),
+                            ipaddress.ip_address('FFFF::c000:201'))
+        self.assertNotEqual(ipaddress.ip_address('::FFFF:192.0.2.1'),
+                          ipaddress.ip_address('::FFFF:c000:201%scope'))
+        self.assertNotEqual(ipaddress.ip_address('FFFF::192.0.2.1'),
+                          ipaddress.ip_address('FFFF::c000:201%scope'))
+
     def testIPVersion(self):
         self.assertEqual(self.ipv4_address.version, 4)
         self.assertEqual(self.ipv6_address.version, 6)
+        self.assertEqual(self.ipv6_scoped_address.version, 6)
 
     def testMaxPrefixLength(self):
         self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
         self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
+        self.assertEqual(self.ipv6_scoped_interface.max_prefixlen, 128)
 
     def testPacked(self):
         self.assertEqual(self.ipv4_address.packed,
@@ -1728,6 +2141,14 @@
                             + b'\x00' * 6)
         self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0').packed,
                          b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8)
+        self.assertEqual(self.ipv6_scoped_address.packed,
+                         b'\x20\x01\x06\x58\x02\x2a\xca\xfe'
+                         b'\x02\x00\x00\x00\x00\x00\x00\x01')
+        self.assertEqual(ipaddress.IPv6Interface('ffff:2:3:4:ffff::%scope').packed,
+                         b'\xff\xff\x00\x02\x00\x03\x00\x04\xff\xff'
+                            + b'\x00' * 6)
+        self.assertEqual(ipaddress.IPv6Interface('::1:0:0:0:0%scope').packed,
+                         b'\x00' * 6 + b'\x00\x01' + b'\x00' * 8)
 
     def testIpType(self):
         ipv4net = ipaddress.ip_network('1.2.3.4')