arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

tests/integration_tests/validation/download_conformance_suites.py

@@ -1,47 +0,0 @@
-import logging
-import os
-import urllib.request
-import zipfile
-from tests.integration_tests.validation.conformance_suite_config import ConformanceSuiteConfig
-
-logger = logging.getLogger("arelle")
-
-DOWNLOADED_PATHS = set()
-
-
-def _download_file(source: str, destination: str, overwrite: bool) -> None:
-    if destination in DOWNLOADED_PATHS:
-        return
-    if not overwrite and os.path.exists(destination):
-        return
-    logger.info(f"Downloading public conformance suite file.\n\tFrom: {source}\n\tTo: {destination}")
-    urllib.request.urlretrieve(source, destination)
-    DOWNLOADED_PATHS.add(destination)
-
-
-def download_conformance_suite(config: ConformanceSuiteConfig, overwrite: bool = False) -> None:
-    destination_path = config.prefixed_local_filepath
-    zip_directory = os.path.dirname(destination_path)
-    os.makedirs(zip_directory, exist_ok=True)
-    if config.public_download_url:
-        _download_file(config.public_download_url, destination_path, overwrite)
-    elif not os.path.exists(destination_path):
-        membership_messages = [f"[{config.name}] No public download available."]
-        if config.membership_url:
-            membership_messages.append(f"\tMembership required (Join here: {config.membership_url}).")
-        membership_messages.append(f"\tMore info: {config.info_url}")
-        logger.warning("\n".join(membership_messages))
-    if config.additional_downloads:
-        for source, destination in config.additional_downloads.items():
-            _download_file(source, destination, overwrite)
-
-
-def extract_conformance_suite(config: ConformanceSuiteConfig) -> None:
-    destination_path = config.prefixed_local_filepath
-    extract_path = config.prefixed_extract_filepath
-    if extract_path:
-        assert os.path.exists(destination_path), 'Can not extract conformance suite file: ZIP file does not exist.'
-        if not os.path.exists(extract_path):
-            logger.info(f"[{config.name}] Extracting conformance suite file.\n\tFrom: {destination_path}\n\tTo: {extract_path}")
-            with zipfile.ZipFile(destination_path, 'r') as zip_ref:
-                zip_ref.extractall(extract_path)

tests/integration_tests/validation/run_conformance_suites.py

@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-import sys
-from argparse import ArgumentParser, Namespace
-from tests.integration_tests.validation.validation_util import get_conformance_suite_test_results
-from tests.integration_tests.validation.conformance_suite_config import ConformanceSuiteConfig
-from tests.integration_tests.validation.conformance_suite_configs import (
-    ALL_CONFORMANCE_SUITE_CONFIGS,
-    PUBLIC_CONFORMANCE_SUITE_CONFIGS
-)
-from tests.integration_tests.validation.download_conformance_suites import (
-    download_conformance_suite, extract_conformance_suite
-)
-from typing import Any, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from _pytest.mark import ParameterSet
-
-
-ARGUMENTS: list[dict[str, Any]] = [
-    {
-        "name": "--all",
-        "action": "store_true",
-        "help": "Select all configured conformance suites"
-    },
-    {
-        "name": "--build-cache",
-        "action": "store_true",
-        "help": "Use CacheBuilder plugin to build cache from conformance suite usage"
-    },
-    {
-        "name": "--download-overwrite",
-        "action": "store_true",
-        "help": "Download (and overwrite) selected conformance suite files"
-    },
-    {
-        "name": "--download-missing",
-        "action": "store_true",
-        "help": "Download missing selected conformance suite files"
-    },
-    {
-        "name": "--list",
-        "action": "store_true",
-        "help": "List names of all configured conformance suites"
-    },
-    {
-        "name": "--log-to-file",
-        "action": "store_true",
-        "help": "Writes logs and results to .txt and .csv files"
-    },
-    {
-        "name": "--name",
-        "action": "store",
-        "help": "Select only conformance suites with given names, comma delimited"
-    },
-    {
-        "name": "--offline",
-        "action": "store_true",
-        "help": "Run without loading anything from the internet (local files and cache only)"
-    },
-    {
-        "name": "--public",
-        "action": "store_true",
-        "help": "Select all public conformance suites"
-    },
-    {
-        "name": "--shard",
-        "action": "store",
-        "help": "0-indexed shard to run",
-        "type": int,
-    },
-    {
-        "name": "--test",
-        "action": "store_true",
-        "help": "Run selected conformance suite tests"
-    },
-]
-DOWNLOAD_MISSING = 'missing'
-DOWNLOAD_OVERWRITE = 'overwrite'
-SELECT_ALL = 'all'
-SELECT_PUBLIC = 'public'
-
-
-def _get_conformance_suite_names(select_option: str) -> tuple[ConformanceSuiteConfig, ...]:
-    if select_option == SELECT_ALL:
-        return ALL_CONFORMANCE_SUITE_CONFIGS
-    elif select_option == SELECT_PUBLIC:
-        return PUBLIC_CONFORMANCE_SUITE_CONFIGS
-    elif select_option:
-        filter_list = select_option.split(',')
-        names = []
-        for filter_item in filter_list:
-            match_configs = [c for c in ALL_CONFORMANCE_SUITE_CONFIGS if c.name == filter_item]
-            if not match_configs:
-                raise ValueError(f'Provided name "{filter_item}" did not match any configured conformance suite names.')
-            names.extend(match_configs)
-        return tuple(names)
-    else:
-        raise ValueError('Please use --all, --public, or --name to specify which conformance suites to use.')
-
-
-def run_conformance_suites(
-        select_option: str,
-        test_option: bool,
-        shard: int | None,
-        build_cache: bool = False,
-        download_option: str | None = None,
-        log_to_file: bool = False,
-        offline_option: bool = False) -> list[ParameterSet]:
-    conformance_suite_configs = _get_conformance_suite_names(select_option)
-    if download_option:
-        overwrite = download_option == DOWNLOAD_OVERWRITE
-        for conformance_suite_config in conformance_suite_configs:
-            download_conformance_suite(conformance_suite_config, overwrite=overwrite)
-    for conformance_suite_config in conformance_suite_configs:
-        extract_conformance_suite(conformance_suite_config)
-    all_results = []
-    if test_option:
-        for config in conformance_suite_configs:
-            results = get_conformance_suite_test_results(config, shard=shard, build_cache=build_cache, log_to_file=log_to_file, offline=offline_option)
-            all_results.extend(results)
-    return all_results
-
-
-def run_conformance_suites_options(options: Namespace) -> list[ParameterSet]:
-    select_option = get_select_option(options)
-    download_option = get_download_option(options)
-    assert download_option or options.test, \
-        'Specify at least one of download, list, or test.'
-    return run_conformance_suites(
-        select_option=select_option,
-        test_option=options.test,
-        shard=options.shard,
-        build_cache=options.build_cache,
-        download_option=download_option,
-        log_to_file=options.log_to_file,
-        offline_option=options.offline
-    )
-
-
-def get_download_option(options: Namespace) -> Optional[str]:
-    if options.download_overwrite:
-        return DOWNLOAD_OVERWRITE
-    elif options.download_missing:
-        return DOWNLOAD_MISSING
-    return None
-
-
-def get_select_option(options: Namespace) -> str:
-    if options.all:
-        return SELECT_ALL
-    elif options.public:
-        return SELECT_PUBLIC
-    assert isinstance(options.name, str)
-    return options.name
-
-
-def run() -> None:
-    parser = ArgumentParser(prog=sys.argv[0])
-    for arg in ARGUMENTS:
-        arg_without_name = {k: v for k, v in arg.items() if k != "name"}
-        parser.add_argument(arg["name"], **arg_without_name)
-    options = parser.parse_args(sys.argv[1:])
-    if options.list:
-        for config in ALL_CONFORMANCE_SUITE_CONFIGS:
-            print(f'{config.name}\n'
-                  f'\tInfo:       {config.info_url}\n'
-                  f'\tDownload:   {config.public_download_url or config.membership_url}\n'
-                  f'\tLocal Path: {config.prefixed_local_filepath}')
-    else:
-        run_conformance_suites_options(options)
-
-
-if __name__ == "__main__":
-    run()

tests/integration_tests/validation/test_conformance_suites.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-
-def test_conformance_suite(conformance_suite_results: dict[str, Any]) -> None:
-    """
-    See conftest.py for context around the parameterization of conformance suite results.
-    It is critical that this file is not imported or referenced by other modules to ensure that it is not evaluated
-    before pytest can evaluate conformance suite results via the pytest_configure hook.
-    """
-    assert conformance_suite_results.get('status') == 'pass', \
-        'Expected these validation suffixes: {}, but received these validations: {}'.format(
-            conformance_suite_results.get('expected'), conformance_suite_results.get('actual')
-        )

tests/integration_tests/validation/validation_util.py

@@ -1,271 +0,0 @@
-from __future__ import annotations
-import os.path
-import pytest
-import tempfile
-from collections import Counter, defaultdict
-from contextlib import nullcontext
-from dataclasses import dataclass
-from heapq import heapreplace
-from lxml import etree
-from pathlib import PurePath, PurePosixPath
-from typing import Any, Callable, ContextManager, TYPE_CHECKING, cast
-from unittest.mock import patch
-from zipfile import ZipFile
-
-from arelle import ModelDocument, PackageManager, PluginManager
-from arelle.CntlrCmdLine import parseAndRun
-from arelle.FileSource import archiveFilenameParts
-from arelle.WebCache import WebCache
-
-from tests.integration_tests.validation.conformance_suite_config import ConformanceSuiteConfig
-
-if TYPE_CHECKING:
-    from _pytest.mark import ParameterSet
-
-
-def get_document_id(doc: ModelDocument.ModelDocument) -> str:
-    file_source = doc.modelXbrl.fileSource
-    basepath = getattr(file_source, 'basefile', None)
-    if basepath is None:
-        # Try and find a basepath from referenced documents
-        ref_file_source = next(iter(file_source.referencedFileSources.values()), None)
-        if ref_file_source is not None:
-            basepath = ref_file_source.basefile
-    if basepath is None:
-        # Try and find a basepath based on archive in path
-        archivePathParts = archiveFilenameParts(doc.filepath)
-        if archivePathParts is not None:
-            return archivePathParts[1]
-    if basepath is None:
-        # Use file source URL as fallback if basepath not found
-        basepath = os.path.dirname(file_source.url) + os.sep
-    return PurePath(doc.filepath).relative_to(basepath).as_posix()
-
-def get_test_data(
-        args: list[str],
-        expected_failure_ids: frozenset[str] = frozenset(),
-        expected_empty_testcases: frozenset[str] = frozenset(),
-        expected_model_errors: frozenset[str] = frozenset()) -> list[ParameterSet]:
-    """
-    Produces a list of Pytest Params that can be fed into a parameterized pytest function
-
-    :param args: The args to be parsed by arelle in order to correctly produce the desired result set
-    :param expected_failure_ids: The set of string test IDs that are expected to fail
-    :param expected_empty_testcases: The set of paths of empty testcases, relative to the suite zip
-    :param expected_model_errors: The set of error codes expected to be in the ModelXbrl errors
-    :return: A list of PyTest Params that can be used to run a parameterized pytest function
-    """
-    cntlr = parseAndRun(args)  # type: ignore[no-untyped-call]
-    try:
-        results = []
-        test_cases_with_no_variations = set()
-        test_cases_with_unrecognized_type = {}
-        model_document = cntlr.modelManager.modelXbrl.modelDocument
-        test_cases: list[ModelDocument.ModelDocument] = []
-        if model_document.type in (ModelDocument.Type.TESTCASE, ModelDocument.Type.REGISTRYTESTCASE):
-            test_cases.append(model_document)
-        elif model_document.type == ModelDocument.Type.TESTCASESINDEX:
-            referenced_documents = model_document.referencesDocument.keys()
-            child_document_types = {doc.type for doc in referenced_documents}
-            assert len(child_document_types) == 1, f'Multiple child document types found in {model_document.uri}: {child_document_types}.'
-            [child_document_type] = child_document_types
-            # the formula function registry conformance suite points to a list of registries, so we need to search one level deeper.
-            if child_document_type == ModelDocument.Type.REGISTRY:
-                referenced_documents = [case for doc in referenced_documents for case in doc.referencesDocument.keys()]
-            test_cases = sorted(referenced_documents, key=lambda doc: doc.uri)
-        elif model_document.type == ModelDocument.Type.INSTANCE:
-            test_id = get_document_id(model_document)
-            model_errors = sorted(cntlr.modelManager.modelXbrl.errors)
-            expected_model_errors_list = sorted(expected_model_errors)
-            param = pytest.param(
-                {
-                    'status': 'pass' if model_errors == expected_model_errors_list else 'fail',
-                    'expected': expected_model_errors_list,
-                    'actual': model_errors
-                },
-                id=test_id,
-                marks=[pytest.mark.xfail()] if test_id in expected_failure_ids else []
-            )
-            results.append(param)
-        else:
-            raise Exception('Unhandled model document type: {}'.format(model_document.type))
-        for test_case in test_cases:
-            test_case_file_id = get_document_id(test_case)
-            if test_case.type not in (ModelDocument.Type.TESTCASE, ModelDocument.Type.REGISTRYTESTCASE):
-                test_cases_with_unrecognized_type[test_case_file_id] = test_case.type
-            if not getattr(test_case, "testcaseVariations", None):
-                test_cases_with_no_variations.add(test_case_file_id)
-            else:
-                for mv in test_case.testcaseVariations:
-                    test_id = f'{test_case_file_id}:{mv.id}'
-                    param = pytest.param(
-                        {
-                            'status': mv.status,
-                            'expected': mv.expected,
-                            'actual': mv.actual
-                        },
-                        id=test_id,
-                        marks=[pytest.mark.xfail()] if test_id in expected_failure_ids else []
-                    )
-                    results.append(param)
-        if test_cases_with_unrecognized_type:
-            raise Exception(f"Some test cases have an unrecognized document type: {sorted(test_cases_with_unrecognized_type.items())}.")
-        unrecognized_expected_empty_testcases = expected_empty_testcases.difference(map(get_document_id, test_cases))
-        if unrecognized_expected_empty_testcases:
-            raise Exception(f"Some expected empty test cases weren't found: {sorted(unrecognized_expected_empty_testcases)}.")
-        unexpected_empty_testcases = test_cases_with_no_variations - expected_empty_testcases
-        if unexpected_empty_testcases:
-            raise Exception(f"Some test cases don't have any variations: {sorted(unexpected_empty_testcases)}.")
-        test_id_frequencies = Counter(cast(str, p.id) for p in results)
-        nonunique_test_ids = {test_id: count for test_id, count in test_id_frequencies.items() if count > 1}
-        if nonunique_test_ids:
-            raise Exception(f'Some test IDs are not unique.  Frequencies of nonunique test IDs: {nonunique_test_ids}.')
-        nonexistent_expected_failure_ids = expected_failure_ids - test_id_frequencies.keys()
-        if nonexistent_expected_failure_ids:
-            raise Exception(f"Some expected failure IDs don't match any test cases: {sorted(nonexistent_expected_failure_ids)}.")
-        return results
-    finally:
-        cntlr.modelManager.close()
-        PackageManager.close()  # type: ignore[no-untyped-call]
-        PluginManager.close()  # type: ignore[no-untyped-call]
-
-
-original_normalize_url_function = WebCache.normalizeUrl
-
-
-def normalize_url_function(config: ConformanceSuiteConfig) -> Callable[[WebCache, str, str | None], str]:
-    def normalize_url(self: WebCache, url: str, base: str | None = None) -> str:
-        assert config.url_replace is not None
-        if url.startswith(config.url_replace):
-            return url.replace(config.url_replace, f'{config.prefixed_local_filepath}/')
-        return cast(str, original_normalize_url_function(self, url, base))
-    return normalize_url
-
-
-def get_test_shards(config: ConformanceSuiteConfig) -> list[tuple[list[str], frozenset[str]]]:
-    test_path_prefix = PurePosixPath(config.file).parent
-    with ZipFile(config.prefixed_local_filepath) as zip_file:
-        tree = etree.parse(zip_file.open(config.file))
-        testcases_element = tree.getroot() if tree.getroot().tag == 'testcases' else tree.find('testcases')
-        assert testcases_element is not None
-        test_root = testcases_element.get('root', '')
-        # replace backslashes with forward slashes, e.g. in
-        # 616-definition-syntax/616-14-RXP-definition-link-validations\616-14-RXP-definition-link-validations-testcase.xml
-        path_strs = sorted(str(test_path_prefix / test_root / cast(str, e.get('uri')).replace('\\', '/'))
-            for e in testcases_element.findall('testcase'))
-    assert path_strs
-
-    @dataclass(frozen=True)
-    class Path:
-        path: str
-        plugins: tuple[str, ...]
-        runtime: float
-    paths_by_plugins: dict[tuple[str, ...], list[Path]] = defaultdict(list)
-    for path_str in path_strs:
-        path_plugins: set[str] = set()
-        for prefix, additional_plugins in config.additional_plugins_by_prefix:
-            if path_str.startswith(prefix):
-                path_plugins.update(additional_plugins)
-        paths_by_plugins[tuple(path_plugins)].append(
-            Path(path=path_str, plugins=tuple(path_plugins), runtime=config.approximate_relative_timing.get(path_str, 1)))
-    paths_in_runtime_order: list[Path] = sorted((path for paths in paths_by_plugins.values() for path in paths),
-        key=lambda path: path.runtime, reverse=True)
-    runtime_by_plugins: dict[tuple[str, ...], float] = {plugins: sum(path.runtime for path in paths)
-        for plugins, paths in paths_by_plugins.items()}
-    total_runtime = sum(runtime_by_plugins.values())
-    shards_by_plugins: dict[tuple[str, ...], list[tuple[float, list[str]]]] = {}
-    remaining_shards = config.shards
-    for i, (plugins, _) in enumerate(paths_by_plugins.items()):
-        n_shards = (remaining_shards
-            if i == len(paths_by_plugins) - 1
-            else 1 + round(runtime_by_plugins[plugins] / total_runtime * (config.shards - len(paths_by_plugins))))
-        remaining_shards -= n_shards
-        shards_by_plugins[plugins] = [(0, []) for _ in range(n_shards)]
-    assert remaining_shards == 0
-    for path in paths_in_runtime_order:
-        shards_for_plugins = shards_by_plugins[path.plugins]
-        shard_runtime, shard = shards_for_plugins[0]
-        shard.append(path.path)
-        heapreplace(shards_for_plugins, (shard_runtime + path.runtime, shard))
-    assert shards_by_plugins.keys() == {()} | {tuple(plugins) for _, plugins in config.additional_plugins_by_prefix}
-    shards = [(paths, frozenset(plugins))
-        for plugins, runtimes_paths in shards_by_plugins.items()
-        for _, paths in runtimes_paths]
-    assert sorted(path for paths, _ in shards for path in paths) == path_strs
-    return shards
-
-
-def get_conformance_suite_test_results(
-        config: ConformanceSuiteConfig,
-        shard: int | None,
-        build_cache: bool = False,
-        log_to_file: bool = False,
-        offline: bool = False) -> list[ParameterSet]:
-    file_path = os.path.join(config.prefixed_local_filepath, config.file)
-    assert shard is None or config.shards != 1, \
-        'Conformance suite configuration must specify shards if --shard is passed'
-    use_shards = shard is not None
-    testcase_file_cm: Callable[[], ContextManager[Any]] = \
-        (lambda: tempfile.NamedTemporaryFile(dir='.', mode='wb', suffix='.xml')) if use_shards else nullcontext  # type: ignore[assignment]
-    with testcase_file_cm() as testcase_file:
-        if use_shards:
-            assert shard is not None
-            shards = get_test_shards(config)
-            test_paths, additional_plugins = shards[shard]
-            zip_path = config.prefixed_local_filepath
-            all_test_paths = {path for test_paths, _ in shards for path in test_paths}
-            unrecognized_expected_empty_testcases = config.expected_empty_testcases - all_test_paths
-            assert not unrecognized_expected_empty_testcases, f'Unrecognized expected empty testcases: {unrecognized_expected_empty_testcases}'
-            expected_empty_testcases = config.expected_empty_testcases.intersection(test_paths)
-            unrecognized_expected_failure_ids = {id.rsplit(':', 1)[0] for id in config.expected_failure_ids} - all_test_paths
-            assert not unrecognized_expected_failure_ids, f'Unrecognized expected failure IDs: {unrecognized_expected_failure_ids}'
-            expected_failure_ids = frozenset(id for id in config.expected_failure_ids if id.rsplit(':', 1)[0] in test_paths)
-
-            root = etree.Element('testcases')
-            tree = etree.ElementTree(root)
-            pathlib_zip_path = PurePath(zip_path)
-            for test_path in test_paths:
-                etree.SubElement(root, 'testcase', uri=str((pathlib_zip_path / test_path).as_posix()))
-            tree.write(testcase_file, encoding='utf-8', pretty_print=True, xml_declaration=True)
-            testcase_file.flush()
-            filename = testcase_file.name
-        else:
-            additional_plugins = frozenset().union(*(plugins for _, plugins in config.additional_plugins_by_prefix))
-            filename = file_path
-            expected_empty_testcases = config.expected_empty_testcases
-            expected_failure_ids = config.expected_failure_ids
-        optional_plugins = set()
-        if build_cache:
-            optional_plugins.add('CacheBuilder')
-        plugins = config.plugins | additional_plugins | optional_plugins
-        args = [
-            '--file', filename,
-            '--keepOpen',
-            '--validate',
-        ]
-        if plugins:
-            args.extend(['--plugins', '|'.join(sorted(plugins))])
-        shard_str = f'-s{shard}' if use_shards else ''
-        if build_cache:
-            args.extend(['--cache-builder-path', f'conf-{config.name}{shard_str}-cache.zip'])
-        if config.capture_warnings:
-            args.append('--testcaseResultsCaptureWarnings')
-        if log_to_file:
-            args.extend([
-                '--csvTestReport', f'conf-{config.name}{shard_str}-report.csv',
-                '--logFile', f'conf-{config.name}{shard_str}-log.txt',
-            ])
-        if offline:
-            args.extend(['--internetConnectivity', 'offline'])
-        context_manager: ContextManager[Any]
-        if config.url_replace:
-            context_manager = patch('arelle.WebCache.WebCache.normalizeUrl', normalize_url_function(config))
-        else:
-            context_manager = nullcontext()
-        with context_manager:
-            return get_test_data(
-                args + config.args,
-                expected_failure_ids=expected_failure_ids,
-                expected_empty_testcases=expected_empty_testcases,
-                expected_model_errors=config.expected_model_errors
-            )

tests/resources/conformance_suites/nl_nt16/br_kvk/2-04-invalid-period.xbrl

@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xbrl
-  xml:lang="en"
-  xmlns="http://www.xbrl.org/2003/instance"
-  xmlns:bzk-wnt-i="http://www.nltaxonomie.nl/nt16/bzk/20211208/dictionary/bzk-wnt-data"
-  xmlns:iso4217="http://www.xbrl.org/2003/iso4217"
-  xmlns:jenv-bw2-dim="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-axes"
-  xmlns:jenv-bw2-dm="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-domains"
-  xmlns:jenv-bw2-i="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-data"
-  xmlns:kvk-i="http://www.nltaxonomie.nl/nt16/kvk/20211208/dictionary/kvk-data"
-  xmlns:link="http://www.xbrl.org/2003/linkbase"
-  xmlns:nl-cd="http://www.nltaxonomie.nl/nt16/sbr/20210301/dictionary/nl-common-data"
-  xmlns:rj-dim="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-axes"
-  xmlns:rj-dm="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-domains"
-  xmlns:rj-i="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-data"
-  xmlns:xbrldi="http://xbrl.org/2006/xbrldi"
-  xmlns:xbrli="http://www.xbrl.org/2003/instance"
-  xmlns:xlink="http://www.w3.org/1999/xlink">
-    <link:schemaRef
-      xlink:href="http://www.nltaxonomie.nl/nt16/kvk/20211208/entrypoints/kvk-rpt-jaarverantwoording-2021-nlgaap-klein-publicatiestukken.xsd"
-      xlink:type="simple"/>
-    <context id="ctx-1">
-        <entity>
-            <identifier scheme="http://www.kvk.nl/kvk-id">12345678</identifier>
-        </entity>
-        <period>
-            <startDate>2021-01-01</startDate>
-            <endDate>2022-01-01</endDate>
-        </period>
-    </context>
-    <nl-cd:LegalEntityName contextRef="ctx-1" xml:lang="en">Testing Entity Name</nl-cd:LegalEntityName>
-    <jenv-bw2-i:LegalEntityRegisteredOffice contextRef="ctx-1" xml:lang="en">Address</jenv-bw2-i:LegalEntityRegisteredOffice>
-    <nl-cd:ChamberOfCommerceRegistrationNumber contextRef="ctx-1" xml:lang="en">12345678</nl-cd:ChamberOfCommerceRegistrationNumber>
-    <kvk-i:BusinessNames contextRef="ctx-1" xml:lang="en">Testing Entity Name</kvk-i:BusinessNames>
-    <kvk-i:LegalSizeCriteriaClassificationSmall contextRef="ctx-1" xml:lang="en">Klein</kvk-i:LegalSizeCriteriaClassificationSmall>
-    <jenv-bw2-i:FinancialReportingPeriodCurrentStartDate contextRef="ctx-1">2021-01-01</jenv-bw2-i:FinancialReportingPeriodCurrentStartDate>
-    <jenv-bw2-i:FinancialReportingPeriodCurrentEndDate contextRef="ctx-1">2021-12-31</jenv-bw2-i:FinancialReportingPeriodCurrentEndDate>
-    <jenv-bw2-i:FinancialReportingPeriodPreviousStartDate contextRef="ctx-1">2020-01-01</jenv-bw2-i:FinancialReportingPeriodPreviousStartDate>
-    <jenv-bw2-i:FinancialReportingPeriodPreviousEndDate contextRef="ctx-1">2020-12-31</jenv-bw2-i:FinancialReportingPeriodPreviousEndDate>
-    <jenv-bw2-i:DocumentAdoptionDate contextRef="ctx-1">2022-01-01</jenv-bw2-i:DocumentAdoptionDate>
-    <jenv-bw2-i:DocumentAdoptionStatus contextRef="ctx-1">Ja</jenv-bw2-i:DocumentAdoptionStatus>
-    <kvk-i:DocumentResubmissionDueToUnsurmountableInaccuracies contextRef="ctx-1">Ja</kvk-i:DocumentResubmissionDueToUnsurmountableInaccuracies>
-    <kvk-i:DocumentResubmissionDueToUnsurmountableInaccuraciesExplanation contextRef="ctx-1">
-        Explanation
-    </kvk-i:DocumentResubmissionDueToUnsurmountableInaccuraciesExplanation>
-
-    <xbrli:unit id="usd">
-        <xbrli:measure>iso4217:USD</xbrli:measure>
-    </xbrli:unit>
-    <xbrli:unit id="pure">
-        <xbrli:measure>xbrli:pure</xbrli:measure>
-    </xbrli:unit>
-    <context id="ctx-2">
-        <entity>
-            <identifier scheme="http://www.kvk.nl/kvk-id">12345678</identifier>
-        </entity>
-        <period>
-            <instant>2021-01-01</instant>
-        </period>
-    </context>
-    <jenv-bw2-i:RightsGrantedExercisePrice contextRef="ctx-2" xml:lang="en" decimals="2" unitRef="usd">100.00</jenv-bw2-i:RightsGrantedExercisePrice>
-    <jenv-bw2-i:ShareCapitalInTheCurrencyOfDenominationWhenDifferentPresentationCurrencyExchangeRateUsed contextRef="ctx-2" xml:lang="en" decimals="INF" unitRef="pure">1.1</jenv-bw2-i:ShareCapitalInTheCurrencyOfDenominationWhenDifferentPresentationCurrencyExchangeRateUsed>
-</xbrl>

tests/resources/conformance_suites/nl_nt16/br_kvk/2-04-testcase.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<?xml-stylesheet type="text/xsl" href="../testcase.xsl"?>
-<testcase
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xmlns="http://xbrl.org/2005/conformance"
-  name="NL.BR-KVK-2.04"
-  description="The period in the context MUST correspond to the period of the current or previous financial reporting period, or one day before the start of the comparative financial where the context must be instant."
-  outpath=''
-  owner="support@arelle.org"
-  xsi:schemaLocation="http://xbrl.org/2005/conformance https://www.xbrl.org/2005/conformance.xsd">
-  <variation id="invalid-period" name="Invalid Period">
-    <description>
-        The instance has invalid period values relative to the reporting dates.
-    </description>
-    <data>
-        <instance readMeFirst="true">2-04-invalid-period.xbrl</instance>
-    </data>
-    <result>
-      <error>NL.BR-KVK-2.04</error>
-    </result>
-  </variation>
-</testcase>

tests/resources/conformance_suites/nl_nt16/br_kvk/3-01-missing.xbrl

@@ -1,53 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xbrl
-  xml:lang="en"
-  xmlns="http://www.xbrl.org/2003/instance"
-  xmlns:bzk-wnt-i="http://www.nltaxonomie.nl/nt16/bzk/20211208/dictionary/bzk-wnt-data"
-  xmlns:iso4217="http://www.xbrl.org/2003/iso4217"
-  xmlns:jenv-bw2-dim="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-axes"
-  xmlns:jenv-bw2-dm="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-domains"
-  xmlns:jenv-bw2-i="http://www.nltaxonomie.nl/nt16/jenv/20211208/dictionary/jenv-bw2-data"
-  xmlns:kvk-i="http://www.nltaxonomie.nl/nt16/kvk/20211208/dictionary/kvk-data"
-  xmlns:link="http://www.xbrl.org/2003/linkbase"
-  xmlns:nl-cd="http://www.nltaxonomie.nl/nt16/sbr/20210301/dictionary/nl-common-data"
-  xmlns:rj-dim="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-axes"
-  xmlns:rj-dm="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-domains"
-  xmlns:rj-i="http://www.nltaxonomie.nl/nt16/rj/20211208/dictionary/rj-data"
-  xmlns:xbrldi="http://xbrl.org/2006/xbrldi"
-  xmlns:xbrli="http://www.xbrl.org/2003/instance"
-  xmlns:xlink="http://www.w3.org/1999/xlink">
-    <link:schemaRef
-      xlink:href="http://www.nltaxonomie.nl/nt16/kvk/20211208/entrypoints/kvk-rpt-jaarverantwoording-2021-nlgaap-klein-publicatiestukken.xsd"
-      xlink:type="simple"/>
-    <context id="ctx-1">
-        <entity>
-            <identifier scheme="http://www.kvk.nl/kvk-id">12345678</identifier>
-        </entity>
-        <period>
-            <startDate>2021-01-01</startDate>
-            <endDate>2021-12-31</endDate>
-        </period>
-    </context>
-    <nl-cd:LegalEntityName contextRef="ctx-1" xml:lang="en">Testing Entity Name</nl-cd:LegalEntityName>
-    <jenv-bw2-i:LegalEntityRegisteredOffice contextRef="ctx-1" xml:lang="en">Address</jenv-bw2-i:LegalEntityRegisteredOffice>
-    <nl-cd:ChamberOfCommerceRegistrationNumber contextRef="ctx-1" xml:lang="en">12345678</nl-cd:ChamberOfCommerceRegistrationNumber>
-    <kvk-i:BusinessNames contextRef="ctx-1" xml:lang="en">Testing Entity Name</kvk-i:BusinessNames>
-    <kvk-i:LegalSizeCriteriaClassificationSmall contextRef="ctx-1" xml:lang="en">Klein</kvk-i:LegalSizeCriteriaClassificationSmall>
-    <jenv-bw2-i:FinancialReportingPeriodCurrentStartDate contextRef="ctx-1">2021-01-01</jenv-bw2-i:FinancialReportingPeriodCurrentStartDate>
-    <jenv-bw2-i:FinancialReportingPeriodCurrentEndDate contextRef="ctx-1">2021-12-31</jenv-bw2-i:FinancialReportingPeriodCurrentEndDate>
-    <jenv-bw2-i:FinancialReportingPeriodPreviousStartDate contextRef="ctx-1">2020-01-01</jenv-bw2-i:FinancialReportingPeriodPreviousStartDate>
-    <jenv-bw2-i:FinancialReportingPeriodPreviousEndDate contextRef="ctx-1">2020-12-31</jenv-bw2-i:FinancialReportingPeriodPreviousEndDate>
-
-    <xbrli:unit id="pure">
-        <xbrli:measure>xbrli:pure</xbrli:measure>
-    </xbrli:unit>
-    <context id="ctx-2">
-        <entity>
-            <identifier scheme="http://www.kvk.nl/kvk-id">12345678</identifier>
-        </entity>
-        <period>
-            <instant>2021-12-31</instant>
-        </period>
-    </context>
-    <jenv-bw2-i:ShareCapitalInTheCurrencyOfDenominationWhenDifferentPresentationCurrencyExchangeRateUsed contextRef="ctx-2" xml:lang="en" decimals="INF" unitRef="pure">1.1</jenv-bw2-i:ShareCapitalInTheCurrencyOfDenominationWhenDifferentPresentationCurrencyExchangeRateUsed>
-</xbrl>