aas-core-codegen 0.0.16__py3-none-any.whl

dev/tests/java/test_main.py

@@ -0,0 +1,234 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+
+import tests.common
+
+_TYPES = [
+    "AdministrativeInformation",
+    "AnnotatedRelationshipElement",
+    "AssetAdministrationShell",
+    "AssetInformation",
+    "BasicEventElement",
+    "Blob",
+    "Capability",
+    "ConceptDescription",
+    "DataSpecificationIec61360",
+    "EmbeddedDataSpecification",
+    "Entity",
+    "Environment",
+    "EventPayload",
+    "Extension",
+    "File",
+    "Key",
+    "LangStringDefinitionTypeIec61360",
+    "LangStringNameType",
+    "LangStringPreferredNameTypeIec61360",
+    "LangStringShortNameTypeIec61360",
+    "LangStringTextType",
+    "LevelType",
+    "MultiLanguageProperty",
+    "Operation",
+    "OperationVariable",
+    "Property",
+    "Qualifier",
+    "Range",
+    "ReferenceElement",
+    "Reference",
+    "RelationshipElement",
+    "Resource",
+    "SpecificAssetId",
+    "SubmodelElementCollection",
+    "SubmodelElementList",
+    "Submodel",
+    "ValueList",
+    "ValueReferencePair",
+]
+
+_CONSTANTS = [pathlib.Path("constants/Constants.java")]
+_COPYING = [pathlib.Path("copying/Copying.java")]
+_ENHANCING = [pathlib.Path(f"enhancing/Enhanced{t}.java") for t in _TYPES] + [
+    pathlib.Path("enhancing/Enhanced.java"),
+    pathlib.Path("enhancing/Enhancer.java"),
+    pathlib.Path("enhancing/Unwrapper.java"),
+    pathlib.Path("enhancing/Wrapper.java"),
+]
+# NOTE (empwilli 2024-03-26): we create generators only for types that have
+# non-mandatory attributes.
+_GENERATION = [
+    pathlib.Path(f"generation/{t}Builder.java")
+    for t in _TYPES
+    if t
+    not in (
+        "EmbeddedDataSpecification",
+        "Key",
+        "LangStringDefinitionTypeIec61360",
+        "LangStringNameType",
+        "LangStringPreferredNameTypeIec61360",
+        "LangStringShortNameTypeIec61360",
+        "LangStringTextType",
+        "LevelType",
+        "OperationVariable",
+        "ValueList",
+        "ValueReferencePair",
+    )
+]
+_JSONIZATION = [pathlib.Path("jsonization/Jsonization.java")]
+_REPORTING = [pathlib.Path("reporting/Reporting.java")]
+_STRINGIFICATION = [pathlib.Path("stringification/Stringification.java")]
+_VERIFICATION = [pathlib.Path("verification/Verification.java")]
+_STRUCTURE = (
+    [
+        pathlib.Path("types/enums/AasSubmodelElements.java"),
+        pathlib.Path("types/enums/AssetKind.java"),
+        pathlib.Path("types/enums/DataTypeDefXsd.java"),
+        pathlib.Path("types/enums/DataTypeIec61360.java"),
+        pathlib.Path("types/enums/Direction.java"),
+        pathlib.Path("types/enums/EntityType.java"),
+        pathlib.Path("types/enums/KeyTypes.java"),
+        pathlib.Path("types/enums/ModellingKind.java"),
+        pathlib.Path("types/enums/QualifierKind.java"),
+        pathlib.Path("types/enums/ReferenceTypes.java"),
+        pathlib.Path("types/enums/StateOfEvent.java"),
+    ]
+    + [pathlib.Path(f"types/impl/{t}.java") for t in _TYPES]
+    + [pathlib.Path(f"types/model/I{t}.java") for t in _TYPES]
+)
+_VISITATION = [
+    pathlib.Path("visitation/AbstractTransformer.java"),
+    pathlib.Path("visitation/AbstractTransformerWithContext.java"),
+    pathlib.Path("visitation/AbstractVisitor.java"),
+    pathlib.Path("visitation/AbstractVisitorWithContext.java"),
+    pathlib.Path("visitation/ITransformer.java"),
+    pathlib.Path("visitation/ITransformerWithContext.java"),
+    pathlib.Path("visitation/IVisitor.java"),
+    pathlib.Path("visitation/IVisitorWithContext.java"),
+    pathlib.Path("visitation/VisitorThrough.java"),
+]
+XMLIZATION = [pathlib.Path("xmlization/Xmlization.java")]
+
+GENERATED_FILES = (
+    _CONSTANTS
+    + _COPYING
+    + _ENHANCING
+    + _GENERATION
+    + _JSONIZATION
+    + _REPORTING
+    + _STRINGIFICATION
+    + _VERIFICATION
+    + _STRUCTURE
+    + _VISITATION
+)
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_dir = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+
+        parent_case_dir = repo_dir / "dev" / "test_data" / "java" / "test_main"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        for model_pth in tests.common.REAL_META_MODEL_PATHS:
+            case_dir = parent_case_dir / model_pth.stem
+            assert case_dir.is_dir(), case_dir
+
+            snippets_dir = case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = case_dir / "expected_output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = aas_core_codegen.main.Parameters(
+                    model_path=model_pth,
+                    target=aas_core_codegen.main.Target.JAVA,
+                    snippets_dir=snippets_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+
+                return_code = aas_core_codegen.main.execute(
+                    params=params, stdout=stdout, stderr=stderr
+                )
+
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                stdout_pth = expected_output_dir / "stdout.txt"
+                normalized_stdout = stdout.getvalue().replace(
+                    str(output_dir), "<output dir>"
+                )
+
+                if tests.common.RERECORD:
+                    stdout_pth.write_text(normalized_stdout, encoding="utf-8")
+                else:
+                    self.assertEqual(
+                        normalized_stdout,
+                        stdout_pth.read_text(encoding="utf-8"),
+                        stdout_pth,
+                    )
+
+                for relevant_rel_pth in GENERATED_FILES:
+                    expected_pth = expected_output_dir / relevant_rel_pth
+                    output_pth = output_dir / relevant_rel_pth
+
+                    if not output_pth.exists():
+                        raise FileNotFoundError(
+                            f"The output file is missing: {output_pth}"
+                        )
+
+                    try:
+                        output = output_pth.read_text(encoding="utf-8")
+                    except Exception as exception:
+                        raise RuntimeError(
+                            f"Failed to read the output from {output_pth}"
+                        ) from exception
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(output, encoding="utf-8")
+                    else:
+                        try:
+                            expected_output = expected_pth.read_text(encoding="utf-8")
+                        except Exception as exception:
+                            raise RuntimeError(
+                                f"Failed to read the expected output "
+                                f"from {expected_pth}"
+                            ) from exception
+
+                        self.assertEqual(
+                            expected_output,
+                            output,
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/jsonld_context/test_main.py

@@ -0,0 +1,79 @@
+import contextlib
+import pathlib
+import tempfile
+import unittest
+import io
+
+from aas_core_codegen.main import Parameters, Target, execute
+
+import tests.common
+from tests.rdf_shacl.test_main import REPO_DIR
+
+
+class Test_jsonld_context(unittest.TestCase):
+    def test_jsonld_context_generation(self) -> None:
+        for model_pth in tests.common.REAL_META_MODEL_PATHS:
+            case_dir = (
+                REPO_DIR / "dev" / "test_data" / "jsonld_context" / model_pth.stem
+            )
+            expected_output_dir = case_dir / "output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = Parameters(
+                    model_path=model_pth,
+                    target=Target.JSONLD_CONTEXT,
+                    snippets_dir=case_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+                return_code = execute(params=params, stdout=stdout, stderr=stderr)
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                if not tests.common.RERECORD:
+                    generated_jsonld_context_path = output_dir / "context.jsonld"
+                    generated_jsonld_context = generated_jsonld_context_path.read_text(
+                        encoding="utf-8"
+                    )
+
+                    expected_jsonld_context_path = (
+                        expected_output_dir / "context.jsonld"
+                    )
+                    expected_jsonld_context = expected_jsonld_context_path.read_text(
+                        encoding="utf-8"
+                    )
+
+                    self.assertEqual(
+                        generated_jsonld_context,
+                        expected_jsonld_context,
+                        f"The generated and the expected context differ. "
+                        f"The expected JSON-LD context lives "
+                        f"at: {expected_jsonld_context_path}, while the generated one "
+                        f"at: {generated_jsonld_context_path}",
+                    )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/opcua/__init__.py

@@ -0,0 +1,3 @@
+# NOTE (mristin, 2022-04-08):
+# We have to rename this directory so that it does not conflict with ``jsonschema``
+# which is a development dependency.

dev/tests/opcua/test_main.py

@@ -0,0 +1,110 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+import aas_core_codegen.opcua.main
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_against_meta_models(self) -> None:
+        repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+        base_case_dir = repo_root / "dev" / "test_data" / "opcua" / "test_main"
+
+        test_cases = tests.common.test_cases_from_base_case_dir(
+            base_case_dir=base_case_dir
+        ) + tests.common.test_cases_from_real_world_models(
+            base_case_dir=base_case_dir,
+            real_meta_model_paths=tests.common.REAL_META_MODEL_PATHS,
+        )
+
+        for test_case in test_cases:
+            snippets_dir = test_case.case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = test_case.case_dir / "expected_output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = aas_core_codegen.main.Parameters(
+                    model_path=test_case.model_path,
+                    target=aas_core_codegen.main.Target.OPCUA,
+                    snippets_dir=snippets_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+
+                return_code = aas_core_codegen.main.execute(
+                    params=params, stdout=stdout, stderr=stderr
+                )
+
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}\n"
+                        f"for the meta-model: {test_case.model_path}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                stdout_pth = expected_output_dir / "stdout.txt"
+                normalized_stdout = stdout.getvalue().replace(
+                    str(output_dir), "<output dir>"
+                )
+
+                if tests.common.RERECORD:
+                    stdout_pth.write_text(normalized_stdout, encoding="utf-8")
+                else:
+                    self.assertEqual(
+                        normalized_stdout,
+                        stdout_pth.read_text(encoding="utf-8"),
+                        stdout_pth,
+                    )
+
+                for relevant_rel_pth in [
+                    pathlib.Path("nodeset.xml"),
+                ]:
+                    expected_pth = expected_output_dir / relevant_rel_pth
+                    output_pth = output_dir / relevant_rel_pth
+
+                    if not output_pth.exists():
+                        raise FileNotFoundError(
+                            f"The output file is missing: {output_pth}"
+                        )
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(
+                            output_pth.read_text(encoding="utf-8"), encoding="utf-8"
+                        )
+                    else:
+                        self.assertEqual(
+                            expected_pth.read_text(encoding="utf-8"),
+                            output_pth.read_text(encoding="utf-8"),
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/our_jsonschema/__init__.py

@@ -0,0 +1,3 @@
+# NOTE (mristin, 2022-04-08):
+# We have to rename this directory so that it does not conflict with ``jsonschema``
+# which is a development dependency.

dev/tests/our_jsonschema/test_main.py

@@ -0,0 +1,232 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import json
+import os
+import pathlib
+import tempfile
+import unittest
+import warnings
+
+import tests.common
+
+with warnings.catch_warnings():
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+    # NOTE (mristin, 2022-04-08):
+    # We need to disable warnings. Jsonschema package at the latest version (4.4.0) has
+    # a problem with JSON schema draft 2019-09 and crashes with an recursion error,
+    # see: https://github.com/python-jsonschema/jsonschema/issues/847.
+    #
+    # We revert back to jsonschema 3.2.0, which can not handle 2019-09, but still seems
+    # to validate correctly our examples.
+    import jsonschema
+
+import aas_core_codegen.main
+import aas_core_codegen.jsonschema.main
+
+
+class Test_against_recorded(unittest.TestCase):
+    _REPO_DIR = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+    PARENT_CASE_DIR = _REPO_DIR / "dev" / "test_data" / "jsonschema" / "test_main"
+
+    def test_against_meta_models(self) -> None:
+        test_cases = tests.common.test_cases_from_base_case_dir(
+            base_case_dir=Test_against_recorded.PARENT_CASE_DIR
+        ) + tests.common.test_cases_from_real_world_models(
+            base_case_dir=Test_against_recorded.PARENT_CASE_DIR,
+            real_meta_model_paths=tests.common.REAL_META_MODEL_PATHS,
+        )
+
+        for test_case in test_cases:
+            snippets_dir = test_case.case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = test_case.case_dir / "expected_output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = aas_core_codegen.main.Parameters(
+                    model_path=test_case.model_path,
+                    target=aas_core_codegen.main.Target.JSONSCHEMA,
+                    snippets_dir=snippets_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+
+                return_code = aas_core_codegen.main.execute(
+                    params=params, stdout=stdout, stderr=stderr
+                )
+
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                stdout_pth = expected_output_dir / "stdout.txt"
+                normalized_stdout = stdout.getvalue().replace(
+                    str(output_dir), "<output dir>"
+                )
+
+                if tests.common.RERECORD:
+                    stdout_pth.write_text(normalized_stdout, encoding="utf-8")
+                else:
+                    self.assertEqual(
+                        normalized_stdout,
+                        stdout_pth.read_text(encoding="utf-8"),
+                        stdout_pth,
+                    )
+
+                for relevant_rel_pth in [
+                    pathlib.Path("schema.json"),
+                ]:
+                    expected_pth = expected_output_dir / relevant_rel_pth
+                    output_pth = output_dir / relevant_rel_pth
+
+                    if not output_pth.exists():
+                        raise FileNotFoundError(
+                            f"The output file is missing: {output_pth}"
+                        )
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(
+                            output_pth.read_text(encoding="utf-8"), encoding="utf-8"
+                        )
+                    else:
+                        self.assertEqual(
+                            expected_pth.read_text(encoding="utf-8"),
+                            output_pth.read_text(encoding="utf-8"),
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+    def test_on_examples(self) -> None:
+        assert (
+            Test_against_recorded.PARENT_CASE_DIR.exists()
+            and Test_against_recorded.PARENT_CASE_DIR.is_dir()
+        ), f"{Test_against_recorded.PARENT_CASE_DIR=}"
+
+        for case_dir in Test_against_recorded.PARENT_CASE_DIR.iterdir():
+            assert case_dir.is_dir(), case_dir
+
+            schema_pth = case_dir / "expected_output" / "schema.json"
+
+            with schema_pth.open("rt", encoding="utf-8") as fid:
+                schema = json.load(fid)
+
+            for data_pth in sorted(
+                (case_dir / "examples" / "expected").glob("**/*.json")
+            ):
+                with data_pth.open("rt", encoding="utf-8") as fid:
+                    instance = json.load(fid)
+
+                try:
+                    jsonschema.validate(instance=instance, schema=schema)
+                except jsonschema.ValidationError as err:
+                    raise AssertionError(
+                        f"Failed to validate {data_pth} against {schema_pth}"
+                    ) from err
+
+
+class Test_pattern_transpilation(unittest.TestCase):
+    def test_unescaped_above_ascii_character_in_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16("\ud7ff")
+        self.assertEqual("\ud7ff", pattern)
+
+    def test_escaped_above_ascii_character_in_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16("\\ud7ff")
+        self.assertEqual("\\ud7ff", pattern)
+
+    def test_unescaped_range_in_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            "[\x20-\uD7FF]"
+        )
+        self.assertEqual("[\x20-\uD7FF]", pattern)
+
+    def test_escaped_range_in_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            "[\\x20-\\ud7ff]"
+        )
+        self.assertEqual("[\\x20-\\ud7ff]", pattern)
+
+    def test_escaped_range_in_bmp_always_lowercase(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            "[\\x20-\\uD7FF]"
+        )
+        self.assertEqual("[\\x20-\\ud7ff]", pattern)
+
+    def test_unescaped_above_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            "[\U00010000-\U0010FFFF]"
+        )
+        self.assertEqual(
+            "(\\ud800[\\udc00-\\udfff]|[\\ud801-\\udbfe][\\udc00-\\udfff]"
+            "|\\udbff[\\udc00-\\udfff])",
+            pattern,
+        )
+
+    def test_escaped_above_bmp(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            "[\\U00010000-\\U0010FFFF]"
+        )
+        self.assertEqual(
+            "(\\ud800[\\udc00-\\udfff]|[\\ud801-\\udbfe][\\udc00-\\udfff]"
+            "|\\udbff[\\udc00-\\udfff])",
+            pattern,
+        )
+
+    def test_unescaped_special_ascii_characters(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16("[\t\n\r]")
+        self.assertEqual("[\\t\\n\\r]", pattern)
+
+    def test_escaped_special_ascii_characters(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16("[\\t\\n\\r]")
+        self.assertEqual("[\\t\\n\\r]", pattern)
+
+    def test_on_XML_string_pattern(self) -> None:
+        pattern = aas_core_codegen.jsonschema.main.fix_pattern_for_utf16(
+            r"^[\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\U00010000-\U0010FFFF]*$"
+        )
+        self.assertEqual(
+            "^([\\x09\\x0a\\x0d\\x20-\\ud7ff\\ue000-\\ufffd]|\\ud800[\\udc00-\\udfff]"
+            "|[\\ud801-\\udbfe][\\udc00-\\udfff]|\\udbff[\\udc00-\\udfff])*$",
+            pattern,
+        )
+
+        # NOTE (mristin, 2024-05-08):
+        # We also test for the JSON representation to test against a possible bug
+        # reported in:
+        # https://github.com/admin-shell-io/aas-specs/pull/426 and
+        # https://github.com/aas-core-works/aas-core-codegen/issues/485
+
+        pattern_json = json.dumps(pattern)
+        self.assertEqual(
+            # NOTE (mristin, 2024-05-08):
+            # Mind the ``r`` modifier for the string literals!
+            r'"^([\\x09\\x0a\\x0d\\x20-\\ud7ff\\ue000-\\ufffd]'
+            r"|\\ud800[\\udc00-\\udfff]|[\\ud801-\\udbfe][\\udc00-\\udfff]"
+            r'|\\udbff[\\udc00-\\udfff])*$"',
+            pattern_json,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()