feat: Add new gcloud commands, API clients, and third-party libraries across various services.

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_idna.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+
+import unittest
+
+import idna
+
+
+class IDNATests(unittest.TestCase):
+    def setUp(self):
+        self.tld_strings = [
+            ["\u6d4b\u8bd5", b"xn--0zwm56d"],
+            ["\u092a\u0930\u0940\u0915\u094d\u0937\u093e", b"xn--11b5bs3a9aj6g"],
+            ["\ud55c\uad6d", b"xn--3e0b707e"],
+            ["\u09ad\u09be\u09b0\u09a4", b"xn--45brj9c"],
+            ["\u09ac\u09be\u0982\u09b2\u09be", b"xn--54b7fta0cc"],
+            [
+                "\u0438\u0441\u043f\u044b\u0442\u0430\u043d\u0438\u0435",
+                b"xn--80akhbyknj4f",
+            ],
+            ["\u0441\u0440\u0431", b"xn--90a3ac"],
+            ["\ud14c\uc2a4\ud2b8", b"xn--9t4b11yi5a"],
+            [
+                "\u0b9a\u0bbf\u0b99\u0bcd\u0b95\u0baa\u0bcd\u0baa\u0bc2\u0bb0\u0bcd",
+                b"xn--clchc0ea0b2g2a9gcd",
+            ],
+            ["\u05d8\u05e2\u05e1\u05d8", b"xn--deba0ad"],
+            ["\u4e2d\u56fd", b"xn--fiqs8s"],
+            ["\u4e2d\u570b", b"xn--fiqz9s"],
+            ["\u0c2d\u0c3e\u0c30\u0c24\u0c4d", b"xn--fpcrj9c3d"],
+            ["\u0dbd\u0d82\u0d9a\u0dcf", b"xn--fzc2c9e2c"],
+            ["\u6e2c\u8a66", b"xn--g6w251d"],
+            ["\u0aad\u0abe\u0ab0\u0aa4", b"xn--gecrj9c"],
+            ["\u092d\u093e\u0930\u0924", b"xn--h2brj9c"],
+            ["\u0622\u0632\u0645\u0627\u06cc\u0634\u06cc", b"xn--hgbk6aj7f53bba"],
+            ["\u0baa\u0bb0\u0bbf\u0b9f\u0bcd\u0b9a\u0bc8", b"xn--hlcj6aya9esc7a"],
+            ["\u0443\u043a\u0440", b"xn--j1amh"],
+            ["\u9999\u6e2f", b"xn--j6w193g"],
+            ["\u03b4\u03bf\u03ba\u03b9\u03bc\u03ae", b"xn--jxalpdlp"],
+            ["\u0625\u062e\u062a\u0628\u0627\u0631", b"xn--kgbechtv"],
+            ["\u53f0\u6e7e", b"xn--kprw13d"],
+            ["\u53f0\u7063", b"xn--kpry57d"],
+            ["\u0627\u0644\u062c\u0632\u0627\u0626\u0631", b"xn--lgbbat1ad8j"],
+            ["\u0639\u0645\u0627\u0646", b"xn--mgb9awbf"],
+            ["\u0627\u06cc\u0631\u0627\u0646", b"xn--mgba3a4f16a"],
+            ["\u0627\u0645\u0627\u0631\u0627\u062a", b"xn--mgbaam7a8h"],
+            ["\u067e\u0627\u06a9\u0633\u062a\u0627\u0646", b"xn--mgbai9azgqp6j"],
+            ["\u0627\u0644\u0627\u0631\u062f\u0646", b"xn--mgbayh7gpa"],
+            ["\u0628\u06be\u0627\u0631\u062a", b"xn--mgbbh1a71e"],
+            ["\u0627\u0644\u0645\u063a\u0631\u0628", b"xn--mgbc0a9azcg"],
+            ["\u0627\u0644\u0633\u0639\u0648\u062f\u064a\u0629", b"xn--mgberp4a5d4ar"],
+            ["\u10d2\u10d4", b"xn--node"],
+            ["\u0e44\u0e17\u0e22", b"xn--o3cw4h"],
+            ["\u0633\u0648\u0631\u064a\u0629", b"xn--ogbpf8fl"],
+            ["\u0440\u0444", b"xn--p1ai"],
+            ["\u062a\u0648\u0646\u0633", b"xn--pgbs0dh"],
+            ["\u0a2d\u0a3e\u0a30\u0a24", b"xn--s9brj9c"],
+            ["\u0645\u0635\u0631", b"xn--wgbh1c"],
+            ["\u0642\u0637\u0631", b"xn--wgbl6a"],
+            ["\u0b87\u0bb2\u0b99\u0bcd\u0b95\u0bc8", b"xn--xkc2al3hye2a"],
+            ["\u0b87\u0ba8\u0bcd\u0ba4\u0bbf\u0baf\u0bbe", b"xn--xkc2dl3a5ee0h"],
+            ["\u65b0\u52a0\u5761", b"xn--yfro4i67o"],
+            ["\u0641\u0644\u0633\u0637\u064a\u0646", b"xn--ygbi2ammx"],
+            ["\u30c6\u30b9\u30c8", b"xn--zckzah"],
+            ["\u049b\u0430\u0437", b"xn--80ao21a"],
+            ["\u0645\u0644\u064a\u0633\u064a\u0627", b"xn--mgbx4cd0ab"],
+            ["\u043c\u043e\u043d", b"xn--l1acc"],
+            ["\u0633\u0648\u062f\u0627\u0646", b"xn--mgbpl2fh"],
+        ]
+
+    def testIDNTLDALabels(self):
+        for ulabel, alabel in self.tld_strings:
+            self.assertEqual(alabel, idna.alabel(ulabel))
+
+    def testIDNTLDULabels(self):
+        for ulabel, alabel in self.tld_strings:
+            self.assertEqual(ulabel, idna.ulabel(alabel))
+
+    def test_valid_label_length(self):
+        self.assertTrue(idna.valid_label_length("a" * 63))
+        self.assertFalse(idna.valid_label_length("a" * 64))
+        self.assertRaises(idna.IDNAError, idna.encode, "a" * 64)
+
+    def test_check_bidi(self):
+        la = "\u0061"
+        r = "\u05d0"
+        al = "\u0627"
+        an = "\u0660"
+        en = "\u0030"
+        es = "\u002d"
+        cs = "\u002c"
+        et = "\u0024"
+        on = "\u0021"
+        bn = "\u200c"
+        nsm = "\u0610"
+        ws = "\u0020"
+
+        # RFC 5893 Rule 1
+        self.assertTrue(idna.check_bidi(la))
+        self.assertTrue(idna.check_bidi(r))
+        self.assertTrue(idna.check_bidi(al))
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, an)
+
+        # RFC 5893 Rule 2
+        self.assertTrue(idna.check_bidi(r + al))
+        self.assertTrue(idna.check_bidi(r + al))
+        self.assertTrue(idna.check_bidi(r + an))
+        self.assertTrue(idna.check_bidi(r + en))
+        self.assertTrue(idna.check_bidi(r + es + al))
+        self.assertTrue(idna.check_bidi(r + cs + al))
+        self.assertTrue(idna.check_bidi(r + et + al))
+        self.assertTrue(idna.check_bidi(r + on + al))
+        self.assertTrue(idna.check_bidi(r + bn + al))
+        self.assertTrue(idna.check_bidi(r + nsm))
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, r + la)
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, r + ws)
+
+        # RFC 5893 Rule 3
+        self.assertTrue(idna.check_bidi(r + al))
+        self.assertTrue(idna.check_bidi(r + en))
+        self.assertTrue(idna.check_bidi(r + an))
+        self.assertTrue(idna.check_bidi(r + nsm))
+        self.assertTrue(idna.check_bidi(r + nsm + nsm))
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, r + on)
+
+        # RFC 5893 Rule 4
+        self.assertTrue(idna.check_bidi(r + en))
+        self.assertTrue(idna.check_bidi(r + an))
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, r + en + an)
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, r + an + en)
+
+        # RFC 5893 Rule 5
+        self.assertTrue(idna.check_bidi(la + en, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + es + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + cs + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + et + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + on + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + bn + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + nsm, check_ltr=True))
+
+        # RFC 5893 Rule 6
+        self.assertTrue(idna.check_bidi(la + la, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + en, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + en + nsm, check_ltr=True))
+        self.assertTrue(idna.check_bidi(la + en + nsm + nsm, check_ltr=True))
+        self.assertRaises(idna.IDNABidiError, idna.check_bidi, la + cs, check_ltr=True)
+
+    def test_check_initial_combiner(self):
+        m = "\u0300"
+        a = "\u0061"
+
+        self.assertTrue(idna.check_initial_combiner(a))
+        self.assertTrue(idna.check_initial_combiner(a + m))
+        self.assertRaises(idna.IDNAError, idna.check_initial_combiner, m + a)
+
+    def test_check_hyphen_ok(self):
+        self.assertTrue(idna.check_hyphen_ok("abc"))
+        self.assertTrue(idna.check_hyphen_ok("a--b"))
+        self.assertRaises(idna.IDNAError, idna.check_hyphen_ok, "aa--")
+        self.assertRaises(idna.IDNAError, idna.check_hyphen_ok, "a-")
+        self.assertRaises(idna.IDNAError, idna.check_hyphen_ok, "-a")
+
+    def test_valid_contextj(self):
+        zwnj = "\u200c"
+        zwj = "\u200d"
+        virama = "\u094d"
+        latin = "\u0061"
+
+        # RFC 5892 Appendix A.1 (Zero Width Non-Joiner)
+        self.assertFalse(idna.valid_contextj(zwnj, 0))
+        self.assertFalse(idna.valid_contextj(latin + zwnj, 1))  # No preceding Virama
+        self.assertTrue(idna.valid_contextj(virama + zwnj, 1))  # Preceding Virama
+
+        # RFC 5892 Appendix A.2 (Zero Width Joiner)
+        self.assertFalse(idna.valid_contextj(zwj, 0))
+        self.assertFalse(idna.valid_contextj(latin + zwj, 1))  # No preceding Virama
+        self.assertTrue(idna.valid_contextj(virama + zwj, 1))  # Preceding Virama
+
+    def test_valid_contexto(self):
+        latin = "\u0061"
+        latin_l = "\u006c"
+        greek = "\u03b1"
+        hebrew = "\u05d0"
+        katakana = "\u30a1"
+        hiragana = "\u3041"
+        han = "\u6f22"
+        arabic_digit = "\u0660"
+        ext_arabic_digit = "\u06f0"
+
+        # RFC 5892 Rule A.3 (Middle Dot)
+        latin_middle_dot = "\u00b7"
+        self.assertTrue(idna.valid_contexto(latin_l + latin_middle_dot + latin_l, 1))
+        self.assertFalse(idna.valid_contexto(latin_middle_dot + latin_l, 1))
+        self.assertFalse(idna.valid_contexto(latin_l + latin_middle_dot, 0))
+        self.assertFalse(idna.valid_contexto(latin_middle_dot, 0))
+        self.assertFalse(idna.valid_contexto(latin_l + latin_middle_dot + latin, 1))
+
+        # RFC 5892 Rule A.4 (Greek Lower Numeral Sign)
+        glns = "\u0375"
+        self.assertTrue(idna.valid_contexto(glns + greek, 0))
+        self.assertFalse(idna.valid_contexto(glns + latin, 0))
+        self.assertFalse(idna.valid_contexto(glns, 0))
+        self.assertFalse(idna.valid_contexto(greek + glns, 1))
+
+        # RFC 5892 Rule A.5 (Hebrew Punctuation Geresh)
+        geresh = "\u05f3"
+        self.assertTrue(idna.valid_contexto(hebrew + geresh, 1))
+        self.assertFalse(idna.valid_contexto(latin + geresh, 1))
+
+        # RFC 5892 Rule A.6 (Hebrew Punctuation Gershayim)
+        gershayim = "\u05f4"
+        self.assertTrue(idna.valid_contexto(hebrew + gershayim, 1))
+        self.assertFalse(idna.valid_contexto(latin + gershayim, 1))
+
+        # RFC 5892 Rule A.7 (Katakana Middle Dot)
+        ja_middle_dot = "\u30fb"
+        self.assertTrue(idna.valid_contexto(katakana + ja_middle_dot + katakana, 1))
+        self.assertTrue(idna.valid_contexto(hiragana + ja_middle_dot + hiragana, 1))
+        self.assertTrue(idna.valid_contexto(han + ja_middle_dot + han, 1))
+        self.assertTrue(idna.valid_contexto(han + ja_middle_dot + latin, 1))
+        self.assertTrue(idna.valid_contexto("\u6f22\u30fb\u5b57", 1))
+        self.assertFalse(idna.valid_contexto("\u0061\u30fb\u0061", 1))
+
+        # RFC 5892 Rule A.8 (Arabic-Indic Digits)
+        self.assertTrue(idna.valid_contexto(arabic_digit + arabic_digit, 0))
+        self.assertFalse(idna.valid_contexto(arabic_digit + ext_arabic_digit, 0))
+
+        # RFC 5892 Rule A.9 (Extended Arabic-Indic Digits)
+        self.assertTrue(idna.valid_contexto(ext_arabic_digit + ext_arabic_digit, 0))
+        self.assertFalse(idna.valid_contexto(ext_arabic_digit + arabic_digit, 0))
+
+    def test_encode(self, encode=None, skip_bytes=False):
+        if encode is None:
+            encode = idna.encode
+
+        self.assertEqual(encode("xn--zckzah.xn--zckzah"), b"xn--zckzah.xn--zckzah")
+        self.assertEqual(encode("\u30c6\u30b9\u30c8.xn--zckzah"), b"xn--zckzah.xn--zckzah")
+        self.assertEqual(encode("\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8"), b"xn--zckzah.xn--zckzah")
+        self.assertEqual(encode("abc.abc"), b"abc.abc")
+        self.assertEqual(encode("xn--zckzah.abc"), b"xn--zckzah.abc")
+        self.assertEqual(encode("\u30c6\u30b9\u30c8.abc"), b"xn--zckzah.abc")
+        self.assertEqual(
+            encode("\u0521\u0525\u0523-\u0523\u0523-----\u0521\u0523\u0523\u0523.aa"),
+            b"xn---------90gglbagaar.aa",
+        )
+        if encode is idna.encode:
+            self.assertRaises(
+                idna.IDNAError,
+                encode,
+                "\u0521\u0524\u0523-\u0523\u0523-----\u0521\u0523\u0523\u0523.aa",
+                uts46=False,
+            )
+        self.assertEqual(encode("a" * 63), b"a" * 63)
+        self.assertRaises(idna.IDNAError, encode, "a" * 64)
+        self.assertRaises(idna.core.InvalidCodepoint, encode, "*")
+        if not skip_bytes:
+            self.assertRaises(idna.IDNAError, encode, b"\x0a\x33\x81")
+
+    def test_decode(self, decode=None, skip_str=False):
+        if decode is None:
+            decode = idna.decode
+        self.assertEqual(decode(b"xn--zckzah.xn--zckzah"), "\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8")
+        self.assertEqual(
+            decode(b"xn--d1acufc.xn--80akhbyknj4f"),
+            "\u0434\u043e\u043c\u0435\u043d.\u0438\u0441\u043f\u044b\u0442\u0430\u043d\u0438\u0435",
+        )
+        if not skip_str:
+            self.assertEqual(
+                decode("\u30c6\u30b9\u30c8.xn--zckzah"),
+                "\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8",
+            )
+            self.assertEqual(
+                decode("\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8"),
+                "\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8",
+            )
+            self.assertEqual(decode("abc.abc"), "abc.abc")
+        self.assertEqual(
+            decode(b"xn---------90gglbagaar.aa"),
+            "\u0521\u0525\u0523-\u0523\u0523-----\u0521\u0523\u0523\u0523.aa",
+        )
+        self.assertRaises(idna.IDNAError, decode, b"XN---------90GGLBAGAAC.AA")
+        self.assertRaises(idna.IDNAError, decode, b"xn---------90gglbagaac.aa")
+        self.assertRaises(idna.IDNAError, decode, b"xn--")
+        self.assertRaises(idna.IDNAError, decode, b"\x8d\xd2")
+        self.assertRaises(
+            idna.IDNAError,
+            decode,
+            b"A.A.0.a.a.A.0.a.A.A.0.a.A.0A.2.a.A.A.0.a.A.0.A.a.A0.a.a.A.0.a.fB.A.A.a.A.A.B.A.A.a.A.A.B.A.A.a.A.A.0.a.A.a.a.A.A.0.a.A.0.A.a.A0.a.a.A.0.a.fB.A.A.a.A.A.B.0A.A.a.A.A.B.A.A.a.A.A.a.A.A.B.A.A.a.A.0.a.B.A.A.a.A.B.A.a.A.A.5.a.A.0.a.Ba.A.B.A.A.a.A.0.a.Xn--B.A.A.A.a",
+        )
+        self.assertRaises(idna.IDNAError, decode, b"xn--ukba655qaaaa14431eeaaba.c")
+
+
+if __name__ == "__main__":
+    unittest.main()

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_idna_codec.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+
+import codecs
+import io
+import unittest
+
+import idna.codec
+
+CODEC_NAME = "idna2008"
+
+
+class IDNACodecTests(unittest.TestCase):
+    def setUp(self):
+        from . import test_idna
+
+        self.idnatests = test_idna.IDNATests()
+        self.idnatests.setUp()
+
+    def testCodec(self):
+        self.assertIs(codecs.lookup(CODEC_NAME).incrementalencoder, idna.codec.IncrementalEncoder)
+
+    def testDirectDecode(self):
+        self.idnatests.test_decode(decode=lambda obj: codecs.decode(obj, CODEC_NAME))
+
+    def testIndirectDecode(self):
+        self.idnatests.test_decode(decode=lambda obj: obj.decode(CODEC_NAME), skip_str=True)
+
+    def testDirectEncode(self):
+        self.idnatests.test_encode(encode=lambda obj: codecs.encode(obj, CODEC_NAME))
+
+    def testIndirectEncode(self):
+        self.idnatests.test_encode(encode=lambda obj: obj.encode(CODEC_NAME), skip_bytes=True)
+
+    def testStreamReader(self):
+        def decode(obj):
+            if isinstance(obj, str):
+                obj = bytes(obj, "ascii")
+            buffer = io.BytesIO(obj)
+            stream = codecs.getreader(CODEC_NAME)(buffer)
+            return stream.read()
+
+        return self.idnatests.test_decode(decode=decode, skip_str=True)
+
+    def testStreamWriter(self):
+        def encode(obj):
+            buffer = io.BytesIO()
+            stream = codecs.getwriter(CODEC_NAME)(buffer)
+            stream.write(obj)
+            stream.flush()
+            return buffer.getvalue()
+
+        return self.idnatests.test_encode(encode=encode)
+
+    def testIncrementalDecoder(self):
+        # Tests derived from Python standard library test/test_codecs.py
+
+        incremental_tests = (
+            ("python.org", b"python.org"),
+            ("python.org.", b"python.org."),
+            ("pyth\xf6n.org", b"xn--pythn-mua.org"),
+            ("pyth\xf6n.org.", b"xn--pythn-mua.org."),
+        )
+
+        for decoded, encoded in incremental_tests:
+            self.assertEqual(
+                "".join(codecs.iterdecode((bytes([c]) for c in encoded), CODEC_NAME)),
+                decoded,
+            )
+
+        decoder = codecs.getincrementaldecoder(CODEC_NAME)()
+        self.assertEqual(
+            decoder.decode(
+                b"xn--xam",
+            ),
+            "",
+        )
+        self.assertEqual(
+            decoder.decode(
+                b"ple-9ta.o",
+            ),
+            "\xe4xample.",
+        )
+        self.assertEqual(decoder.decode(b"rg"), "")
+        self.assertEqual(decoder.decode(b"", True), "org")
+
+        decoder.reset()
+        self.assertEqual(
+            decoder.decode(
+                b"xn--xam",
+            ),
+            "",
+        )
+        self.assertEqual(
+            decoder.decode(
+                b"ple-9ta.o",
+            ),
+            "\xe4xample.",
+        )
+        self.assertEqual(decoder.decode(b"rg."), "org.")
+        self.assertEqual(decoder.decode(b"", True), "")
+
+    def testIncrementalEncoder(self):
+        # Tests derived from Python standard library test/test_codecs.py
+
+        incremental_tests = (
+            ("python.org", b"python.org"),
+            ("python.org.", b"python.org."),
+            ("pyth\xf6n.org", b"xn--pythn-mua.org"),
+            ("pyth\xf6n.org.", b"xn--pythn-mua.org."),
+        )
+        for decoded, encoded in incremental_tests:
+            self.assertEqual(b"".join(codecs.iterencode(decoded, CODEC_NAME)), encoded)
+
+        encoder = codecs.getincrementalencoder(CODEC_NAME)()
+        self.assertEqual(encoder.encode("\xe4x"), b"")
+        self.assertEqual(encoder.encode("ample.org"), b"xn--xample-9ta.")
+        self.assertEqual(encoder.encode("", True), b"org")
+
+        encoder.reset()
+        self.assertEqual(encoder.encode("\xe4x"), b"")
+        self.assertEqual(encoder.encode("ample.org."), b"xn--xample-9ta.org.")
+        self.assertEqual(encoder.encode("", True), b"")
+
+
+if __name__ == "__main__":
+    unittest.main()

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_idna_compat.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+
+import unittest
+
+import idna.compat
+
+
+class IDNACompatTests(unittest.TestCase):
+    def testToASCII(self):
+        self.assertEqual(
+            idna.compat.ToASCII("\u30c6\u30b9\u30c8.xn--zckzah"),
+            b"xn--zckzah.xn--zckzah",
+        )
+
+    def testToUnicode(self):
+        self.assertEqual(
+            idna.compat.ToUnicode(b"xn--zckzah.xn--zckzah"),
+            "\u30c6\u30b9\u30c8.\u30c6\u30b9\u30c8",
+        )
+
+    def test_nameprep(self):
+        self.assertRaises(NotImplementedError, idna.compat.nameprep, "a")
+
+
+if __name__ == "__main__":
+    unittest.main()

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_idna_other.py

@@ -0,0 +1,11 @@
+"""Tests for other functions"""
+
+import unittest
+
+import idna
+
+
+class OtherUTS46Tests(unittest.TestCase):
+    def test_std3(self):
+        self.assertEqual(idna.uts46_remap("A_", std3_rules=False), "a_")
+        self.assertRaises(idna.InvalidCodepoint, idna.uts46_remap, "A_", std3_rules=True)

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_idna_uts46.py

@@ -0,0 +1,220 @@
+"""Tests for TR46 code."""
+
+import os.path
+import re
+import unittest
+
+import idna
+
+_RE_UNICODE = re.compile("\\\\u([0-9a-fA-F]{4})")
+_RE_SURROGATE = re.compile("[\ud800-\udbff][\udc00-\udfff]")
+_SKIP_TESTS = [
+    # These are strings that are illegal in IDNA 2008. Older versions of the UTS-46 test suite
+    # had these denoted with the 'NV8' marker but this has been removed, so we need to manually
+    # review exceptions and add them here to skip them as text vectors if they are invalid.
+    "\U000102f7\u3002\u200d",
+    "\U0001d7f5\u9681\u2bee\uff0e\u180d\u200c",
+    "9\u9681\u2bee.\u180d\u200c",
+    "\u00df\u200c\uaaf6\u18a5.\u22b6\u2d21\u2d16",
+    "ss\u200c\uaaf6\u18a5.\u22b6\u2d21\u2d16",
+    "\u00df\u200c\uaaf6\u18a5\uff0e\u22b6\u2d21\u2d16",
+    "ss\u200c\uaaf6\u18a5\uff0e\u22b6\u2d21\u2d16",
+    "\U00010a57\u200d\u3002\u2d09\u2d15",
+    "\U00010a57\u200d\uff61\u2d09\u2d15",
+    "\U0001d7cf\U0001da19\u2e16.\u200d",
+    "1\U0001da19\u2e16.\u200d",
+    "\U0001d7e04\U000e01d7\U0001d23b\uff0e\u200d\U000102f5\u26e7\u200d",
+    "84\U000e01d7\U0001d23b.\u200d\U000102f5\u26e7\u200d",
+    "\u00a1",
+    "xn--7a",
+    "\u19da",
+    "xn--pkf",
+    "\u2615",
+    "xn--53h",
+    "\U0001e937.\U00010b90\U0001e881\U00010e60\u0624",
+    "\U0001e937.\U00010b90\U0001e881\U00010e60\u0648\u0654",
+    "\U0001e915.\U00010b90\U0001e881\U00010e60\u0648\u0654",
+    "\U0001e915.\U00010b90\U0001e881\U00010e60\u0624",
+    "xn--ve6h.xn--jgb1694kz0b2176a",
+    "\u00df\u3002\U000102f3\u2d0c\u0fb8",
+    "ss\u3002\U000102f3\u2d0c\u0fb8",
+    "ss.xn--lgd921mvv0m",
+    "ss.\U000102f3\u2d0c\u0fb8",
+    "xn--zca.xn--lgd921mvv0m",
+    "\u00df.\U000102f3\u2d0c\u0fb8",
+    "\u00df\uff61\U000102f3\u2d0c\u0fb8",
+    "ss\uff61\U000102f3\u2d0c\u0fb8",
+    "\u16ad\uff61\U0001d320\u00df\U00016af1",
+    "\u16ad\u3002\U0001d320\u00df\U00016af1",
+    "\u16ad\u3002\U0001d320SS\U00016af1",
+    "\u16ad\u3002\U0001d320ss\U00016af1",
+    "\u16ad\u3002\U0001d320Ss\U00016af1",
+    "xn--hwe.xn--ss-ci1ub261a",
+    "\u16ad.\U0001d320ss\U00016af1",
+    "\u16ad.\U0001d320SS\U00016af1",
+    "\u16ad.\U0001d320Ss\U00016af1",
+    "xn--hwe.xn--zca4946pblnc",
+    "\u16ad.\U0001d320\u00df\U00016af1",
+    "\u16ad\uff61\U0001d320SS\U00016af1",
+    "\u16ad\uff61\U0001d320ss\U00016af1",
+    "\u16ad\uff61\U0001d320Ss\U00016af1",
+    "\u2d1a\U000102f8\U000e0104\u30025\ud7f6\u103a",
+    "xn--ilj2659d.xn--5-dug9054m",
+    "\u2d1a\U000102f8.5\ud7f6\u103a",
+    "\u2d1a\U000102f8\U000e0104\u3002\U0001d7dd\ud7f6\u103a",
+    "xn--9-mfs8024b.",
+    "9\u9681\u2bee.",
+    "xn--ss-4epx629f.xn--ifh802b6a",
+    "ss\uaaf6\u18a5.\u22b6\u2d21\u2d16",
+    "xn--pt9c.xn--0kjya",
+    "\U00010a57.\u2d09\u2d15",
+    "\ua5f7\U00011180.\u075d\U00010a52",
+    "xn--ju8a625r.xn--hpb0073k",
+    "\u03c2.\u0641\u0645\u064a\U0001f79b1.",
+    "\u03a3.\u0641\u0645\u064a\U0001f79b1.",
+    "\u03c3.\u0641\u0645\u064a\U0001f79b1.",
+    "xn--4xa.xn--1-gocmu97674d.",
+    "xn--3xa.xn--1-gocmu97674d.",
+    "xn--1-5bt6845n.",
+    "1\U0001da19\u2e16.",
+    "xn--84-s850a.xn--59h6326e",
+    "84\U0001d23b.\U000102f5\u26e7",
+    "xn--r97c.",
+    "\U000102f7.",
+    # These appear to be errors in the test vectors. All relate to incorrectly applying
+    # bidi rules across label boundaries. Appears independently confirmed
+    # at http://www.alvestrand.no/pipermail/idna-update/2017-January/007946.html
+    "0\u00e0.\u05d0",
+    "0a\u0300.\u05d0",
+    "0A\u0300.\u05d0",
+    "0\u00c0.\u05d0",
+    "xn--0-sfa.xn--4db",
+    "\u00e0\u02c7.\u05d0",
+    "a\u0300\u02c7.\u05d0",
+    "A\u0300\u02c7.\u05d0",
+    "\u00c0\u02c7.\u05d0",
+    "xn--0ca88g.xn--4db",
+    "0A.\u05d0",
+    "0a.\u05d0",
+    "0a.xn--4db",
+    "c.xn--0-eha.xn--4db",
+    "c.0\u00fc.\u05d0",
+    "c.0u\u0308.\u05d0",
+    "C.0U\u0308.\u05d0",
+    "C.0\u00dc.\u05d0",
+    "C.0\u00fc.\u05d0",
+    "C.0\u0075\u0308.\u05d0",
+    "\u06b6\u06df\u3002\u2087\ua806",
+    "\u06b6\u06df\u30027\ua806",
+    "xn--pkb6f.xn--7-x93e",
+    "\u06b6\u06df.7\ua806",
+    "1.\uac7e6.\U00010c41\u06d0",
+    "1.\u1100\u1165\u11b56.\U00010c41\u06d0",
+    "1.xn--6-945e.xn--glb1794k",
+]
+
+
+def unicode_fixup(string):
+    """Replace backslash-u-XXXX with appropriate unicode characters."""
+    return _RE_SURROGATE.sub(
+        lambda match: chr((ord(match.group(0)[0]) - 0xD800) * 0x400 + ord(match.group(0)[1]) - 0xDC00 + 0x10000),
+        _RE_UNICODE.sub(lambda match: chr(int(match.group(1), 16)), string),
+    )
+
+
+def parse_idna_test_table(inputstream):
+    """Parse IdnaTestV2.txt and return a list of tuples."""
+    for lineno, line in enumerate(inputstream):
+        line = line.decode("utf-8").strip()
+        if "#" in line:
+            line = line.split("#", 1)[0]
+        if not line:
+            continue
+        yield ((lineno + 1, tuple(field.strip() for field in line.split(";"))))
+
+
+class TestIdnaTest(unittest.TestCase):
+    """Run one of the IdnaTestV2.txt test lines."""
+
+    def __init__(self, lineno=None, fields=None):
+        super().__init__()
+        self.lineno = lineno
+        self.fields = fields
+
+    def id(self):
+        return "{}.{}".format(super().id(), self.lineno)
+
+    def shortDescription(self):
+        if not self.fields:
+            return ""
+        return "IdnaTestV2.txt line {}: {}".format(self.lineno, "; ".join(self.fields))
+
+    def runTest(self):
+        if not self.fields:
+            return
+        (
+            source,
+            to_unicode,
+            to_unicode_status,
+            to_ascii,
+            to_ascii_status,
+            to_ascii_t,
+            to_ascii_t_status,
+        ) = self.fields
+        if source in _SKIP_TESTS:
+            return
+        if not to_unicode:
+            to_unicode = source
+        if not to_unicode_status:
+            to_unicode_status = "[]"
+        if not to_ascii:
+            to_ascii = to_unicode
+        if not to_ascii_status:
+            to_ascii_status = to_unicode_status
+        if not to_ascii_t:
+            to_ascii_t = to_ascii
+        if not to_ascii_t_status:
+            to_ascii_t_status = to_ascii_status
+
+        try:
+            output = idna.decode(source, uts46=True, strict=True)
+            if to_unicode_status != "[]":
+                self.fail("decode() did not emit required error {} for {}".format(to_unicode, repr(source)))
+            self.assertEqual(output, to_unicode, "unexpected decode() output")
+        except (idna.IDNAError, UnicodeError, ValueError) as exc:
+            if str(exc).startswith("Unknown"):
+                raise unittest.SkipTest("Test requires support for a newer" " version of Unicode than this Python supports")
+            if to_unicode_status == "[]":
+                raise
+
+        try:
+            output = idna.encode(source, uts46=True, strict=True).decode("ascii")
+            if to_ascii_status != "[]":
+                self.fail("encode() did not emit required error {} for {}".format(to_ascii_status, repr(source)))
+            self.assertEqual(output, to_ascii, "unexpected encode() output")
+        except (idna.IDNAError, UnicodeError, ValueError) as exc:
+            if str(exc).startswith("Unknown"):
+                raise unittest.SkipTest("Test requires support for a newer" " version of Unicode than this Python supports")
+            if to_ascii_status == "[]":
+                raise
+
+        try:
+            output = idna.encode(source, uts46=True, strict=True, transitional=True).decode("ascii")
+            if to_ascii_t_status != "[]":
+                self.fail(
+                    "encode(transitional=True) did not emit required error {} for {}".format(to_ascii_t_status, repr(source))
+                )
+            self.assertEqual(output, to_ascii_t, "unexpected encode() output")
+        except (idna.IDNAError, UnicodeError, ValueError) as exc:
+            if str(exc).startswith("Unknown"):
+                raise unittest.SkipTest("Test requires support for a newer" " version of Unicode than this Python supports")
+            if to_ascii_t_status == "[]":
+                raise
+
+
+def load_tests(loader, tests, pattern):
+    """Create a suite of all the individual tests."""
+    suite = unittest.TestSuite()
+    with open(os.path.join(os.path.dirname(__file__), "IdnaTestV2.txt"), "rb") as tests_file:
+        suite.addTests(TestIdnaTest(lineno, fields) for lineno, fields in parse_idna_test_table(tests_file))
+    return suite

gcloud auth application-default login/google-cloud-sdk/platform/gsutil/third_party/idna/tests/test_intranges.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+import unittest
+
+from idna.intranges import _encode_range, intranges_contain, intranges_from_list
+
+
+class IntrangeTests(unittest.TestCase):
+    def test_ranging(self):
+        self.assertEqual(
+            intranges_from_list(list(range(293, 499)) + list(range(4888, 9876))),
+            (
+                _encode_range(293, 499),
+                _encode_range(4888, 9876),
+            ),
+        )
+
+    def test_ranging_2(self):
+        self.assertEqual(intranges_from_list([111]), (_encode_range(111, 112),))
+
+    def test_skips(self):
+        self.assertEqual(
+            intranges_from_list(
+                [
+                    0,
+                    2,
+                    4,
+                    6,
+                    9,
+                    10,
+                    11,
+                    13,
+                    15,
+                ]
+            ),
+            (
+                _encode_range(0, 1),
+                _encode_range(2, 3),
+                _encode_range(4, 5),
+                _encode_range(6, 7),
+                _encode_range(9, 12),
+                _encode_range(13, 14),
+                _encode_range(15, 16),
+            ),
+        )
+
+    def test_empty_range(self):
+        self.assertEqual(intranges_from_list([]), ())
+
+
+class IntrangeContainsTests(unittest.TestCase):
+    def _test_containment(self, ints, disjoint_ints):
+        ranges = intranges_from_list(ints)
+        for int_ in ints:
+            assert intranges_contain(int_, ranges)
+        for int_ in disjoint_ints:
+            assert not intranges_contain(int_, ranges)
+
+    def test_simple(self):
+        self._test_containment(range(10, 20), [2, 3, 68, 3893])
+
+    def test_skips(self):
+        self._test_containment(
+            [
+                0,
+                2,
+                4,
+                6,
+                9,
+                10,
+                11,
+                13,
+                15,
+            ],
+            [-1, 1, 3, 5, 7, 4898],
+        )
+
+    def test_singleton(self):
+        self._test_containment([111], [110, 112])
+
+    def test_empty(self):
+        self._test_containment([], range(100))