imas-python 0.1.dev1618__py3-none-any.whl

imas/test/test_nc_validation.py

@@ -0,0 +1,197 @@
+import netCDF4
+import numpy as np
+import pytest
+
+from imas.backends.netcdf.ids2nc import IDS2NC
+from imas.backends.netcdf.nc2ids import NC2IDS
+from imas.backends.netcdf.nc_validate import validate_netcdf_file
+from imas.exception import InvalidNetCDFEntry, UnknownDDVersion
+from imas.ids_defs import IDS_TIME_MODE_HOMOGENEOUS
+from imas.ids_factory import IDSFactory
+
+
+@pytest.fixture()
+def memfile():
+    with netCDF4.Dataset("-", "w", diskless=True) as memfile:
+        yield memfile
+
+
+@pytest.fixture()
+def factory():
+    return IDSFactory("4.0.0")
+
+
+@pytest.fixture()
+def memfile_with_ids(memfile, factory):
+    ids = factory.core_profiles()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    ids.time = [1.0, 2.0, 3.0]
+    ids.profiles_1d.resize(3)
+    for i in range(3):
+        ids.profiles_1d[i].grid.rho_tor_norm = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]
+    ids.profiles_1d[0].zeff = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+    IDS2NC(ids, memfile).run()
+    # This one is valid:
+    NC2IDS(memfile, factory.core_profiles()).run()
+    return memfile
+
+
+def test_invalid_homogeneous_time(memfile, factory):
+    empty_group = memfile.createGroup("empty_group")
+    # Invalid dtype
+    invalid_dtype = memfile.createGroup("invalid_dtype")
+    invalid_dtype.createVariable("ids_properties.homogeneous_time", float, ())[()] = 0
+    # Invalid shape: 1D instead of 0D
+    invalid_shape = memfile.createGroup("invalid_shape")
+    invalid_shape.createDimension("dim")
+    invalid_shape.createVariable("ids_properties.homogeneous_time", "i4", ("dim",))
+    # Invalid value: not 0, 1 or 2
+    invalid_value = memfile.createGroup("invalid_value")
+    invalid_value.createVariable("ids_properties.homogeneous_time", "i4", ())
+
+    ids = factory.core_profiles()
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(empty_group, ids)  # ids_properties.homogeneous_time does not exist
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(invalid_dtype, ids)
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(invalid_shape, ids)
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(invalid_value, ids)
+
+
+def test_invalid_units(memfile_with_ids, factory):
+    memfile_with_ids["time"].units = "hours"
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_invalid_documentation(memfile_with_ids, factory, caplog):
+    with caplog.at_level("WARNING"):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+    assert not caplog.records
+    # Invalid docstring logs a warning
+    memfile_with_ids["time"].documentation = "https://en.wikipedia.org/wiki/Time"
+    with caplog.at_level("WARNING"):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+    assert len(caplog.records) == 1
+
+
+def test_invalid_dimension_name(memfile_with_ids, factory):
+    memfile_with_ids.renameDimension("time", "T")
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_invalid_coordinates(memfile_with_ids, factory):
+    memfile_with_ids["profiles_1d.grid.rho_tor_norm"].coordinates = "xyz"
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_invalid_ancillary_variables(memfile_with_ids, factory):
+    memfile_with_ids["time"].ancillary_variables = "xyz"
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_extra_attributes(memfile_with_ids, factory):
+    memfile_with_ids["time"].new_attribute = [1, 2, 3]
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_shape_array_without_data(memfile_with_ids, factory):
+    memfile_with_ids.createVariable("profiles_1d.t_i_average:shape", int, ())
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_shape_array_without_sparse_data(memfile_with_ids, factory):
+    memfile_with_ids.createVariable("profiles_1d.grid.rho_tor_norm:shape", int, ())
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, factory.core_profiles()).run()
+
+
+def test_shape_array_with_invalid_dimensions(memfile_with_ids, factory):
+    cp = factory.core_profiles()
+    t_i_average_meta = cp.metadata["profiles_1d.t_i_average"]
+    t_i_average = memfile_with_ids.createVariable(
+        "profiles_1d.t_i_average", float, ("time", "profiles_1d.grid.rho_tor_norm:i")
+    )
+    t_i_average.units = t_i_average_meta.units
+    t_i_average.documentation = t_i_average_meta.documentation
+    t_i_average.sparse = "Contents don't matter"
+    memfile_with_ids.createVariable(
+        "profiles_1d.t_i_average:shape",
+        np.int32,
+        ("time", "profiles_1d.grid.rho_tor_norm:i"),
+    )
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, cp).run()
+
+
+def test_shape_array_with_invalid_dtype(memfile_with_ids, factory):
+    cp = factory.core_profiles()
+    t_i_average_meta = cp.metadata["profiles_1d.t_i_average"]
+    t_i_average = memfile_with_ids.createVariable(
+        "profiles_1d.t_i_average", float, ("time", "profiles_1d.grid.rho_tor_norm:i")
+    )
+    t_i_average.units = t_i_average_meta.units
+    t_i_average.documentation = t_i_average_meta.documentation
+    t_i_average.sparse = "Contents don't matter"
+    memfile_with_ids.createVariable(
+        "profiles_1d.t_i_average:shape", float, ("time", "1D")
+    )
+    with pytest.raises(InvalidNetCDFEntry):
+        NC2IDS(memfile_with_ids, cp).run()
+
+
+def test_validate_nc(tmpdir):
+    fname = str(tmpdir / "test.nc")
+
+    # Wrong extension
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file("test.h5")  # invalid extension
+
+    # Empty file
+    netCDF4.Dataset(fname, "w").close()
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file(fname)
+
+    # Invalid DD version
+    with netCDF4.Dataset(fname, "w") as dataset:
+        dataset.data_dictionary_version = "invalid"
+        dataset.createGroup("core_profiles")
+    with pytest.raises(UnknownDDVersion):
+        validate_netcdf_file(fname)
+
+    # Invalid group
+    with netCDF4.Dataset(fname, "w") as dataset:
+        dataset.data_dictionary_version = "4.0.0"
+        dataset.createGroup("X")
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file(fname)
+
+    # Invalid occurrence
+    with netCDF4.Dataset(fname, "w") as dataset:
+        dataset.data_dictionary_version = "4.0.0"
+        dataset.createGroup("core_profiles/a")
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file(fname)
+
+    # Invalid variable in root group
+    with netCDF4.Dataset(fname, "w") as dataset:
+        dataset.data_dictionary_version = "4.0.0"
+        dataset.createVariable("core_profiles", int, ())
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file(fname)
+
+    # Missing ids_properties.homogeneous_time
+    with netCDF4.Dataset(fname, "w") as dataset:
+        dataset.data_dictionary_version = "4.0.0"
+        dataset.createGroup("core_profiles/1")
+    with pytest.raises(InvalidNetCDFEntry):
+        validate_netcdf_file(fname)
+
+    # All other validations are handled by NC2IDS and tested above

imas/test/test_snippets.py

@@ -0,0 +1,25 @@
+import os
+import runpy
+from pathlib import Path
+
+import pytest
+
+courses = Path(__file__, "../../../", "docs/source/courses").resolve()
+course_snippets = []
+for course in ["basic", "advanced"]:
+    course_snippets.extend((courses / course).glob("*snippets/*.py"))
+
+
+@pytest.mark.skip(reason="skipping hli test")
+@pytest.mark.filterwarnings("ignore:The input coordinates to pcolormesh:UserWarning")
+@pytest.mark.parametrize("snippet", course_snippets)
+def test_script_execution(snippet, monkeypatch, tmp_path, requires_imas):
+    monkeypatch.chdir(tmp_path)
+    # Prevent showing plots in a GUI
+    monkeypatch.delenv("DISPLAY", raising=False)
+    if "IMAS_HOME" not in os.environ:
+        # Only execute those snippets that don't need access to the public IMAS DB
+        script_text = snippet.read_text()
+        if '"public"' in script_text:  # ugly hack :(
+            pytest.skip("Snippet requires the public IMAS DB, which is not available")
+    runpy.run_path(str(snippet))

imas/test/test_static_ids.py

@@ -0,0 +1,39 @@
+# Testing static IDS behavior as defined in IMAS-3330
+
+import logging
+
+import pytest
+
+import imas
+from imas.ids_defs import IDS_TIME_MODE_HETEROGENEOUS, IDS_TIME_MODE_INDEPENDENT
+from imas.ids_metadata import IDSType
+
+
+def test_ids_valid_type():
+    factory = imas.IDSFactory()
+    ids_types = set()
+    for ids_name in factory:
+        ids = factory.new(ids_name)
+        ids_types.add(ids.metadata.type)
+
+    # For DD versions <4, `type` is never set at IDS top levels.
+    # For DD versions >=4, `type` may be CONSTANT (i.e. no root time node) or DYNAMIC
+    assert ids_types in ({IDSType.NONE}, {IDSType.CONSTANT, IDSType.DYNAMIC})
+
+
+def test_constant_ids(caplog):
+    ids = imas.IDSFactory().new("amns_data")
+    if ids.metadata.type is IDSType.NONE:
+        pytest.skip("IDS definition has no constant IDSs")
+
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    dbe = imas.DBEntry(imas.ids_defs.MEMORY_BACKEND, "test", 0, 0)
+    dbe.create()
+
+    caplog.clear()
+    with caplog.at_level(logging.WARNING, logger="imas"):
+        dbe.put(ids)
+    assert ids.ids_properties.homogeneous_time == IDS_TIME_MODE_INDEPENDENT
+    assert len(caplog.records) == 1
+    msg = caplog.records[0].message
+    assert "ids_properties/homogeneous_time has been set to 2" in msg

imas/test/test_str_1d.py

@@ -0,0 +1,99 @@
+# A minimal testcase loading an IDS file and checking that the structure built is ok
+import string
+
+from imas.ids_defs import IDS_TIME_MODE_INDEPENDENT, MEMORY_BACKEND
+from imas.test.test_helpers import open_dbentry
+
+
+def test_str_1d_empty(backend, ids_minimal_types, worker_id, tmp_path):
+    """Write and then read again a string on our minimal IDS."""
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal = dbentry.factory.new("minimal")
+    minimal.str_1d = []
+
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+
+    dbentry2 = open_dbentry(
+        backend, "a", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal2 = dbentry2.get("minimal")
+    assert list(minimal2.str_1d.value) == []
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+def test_str_1d_long_single(backend, ids_minimal_types, worker_id, tmp_path):
+    """Write and then read again a string on our minimal IDS."""
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal = dbentry.factory.new("minimal")
+    minimal.str_1d = [string.ascii_uppercase * 100]
+
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+
+    dbentry2 = open_dbentry(
+        backend, "a", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal2 = dbentry2.get("minimal")
+    assert minimal2.str_1d.value == [string.ascii_uppercase * 100]
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+def test_str_1d_multiple(backend, ids_minimal_types, worker_id, tmp_path):
+    """Write and then read again a string on our minimal IDS."""
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal = dbentry.factory.new("minimal")
+    minimal.str_1d = [string.ascii_uppercase, string.ascii_lowercase]
+
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+
+    dbentry2 = open_dbentry(
+        backend, "a", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal2 = dbentry2.get("minimal")
+    assert minimal2.str_1d.value == [
+        string.ascii_uppercase,
+        string.ascii_lowercase,
+    ]
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+def test_str_1d_long_multiple(backend, ids_minimal_types, worker_id, tmp_path):
+    """Write and then read again a string on our minimal IDS."""
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal = dbentry.factory.new("minimal")
+    minimal.str_1d = [string.ascii_uppercase * 100, string.ascii_lowercase * 100]
+
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+
+    dbentry2 = open_dbentry(
+        backend, "a", worker_id, tmp_path, xml_path=ids_minimal_types
+    )
+    minimal2 = dbentry2.get("minimal")
+    assert minimal2.str_1d.value == [
+        string.ascii_uppercase * 100,
+        string.ascii_lowercase * 100,
+    ]
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()

imas/test/test_time_slicing.py

@@ -0,0 +1,182 @@
+"""A testcase checking if writing and then reading works for the latest full
+data dictionary version.
+"""
+
+import logging
+import os
+
+import numpy as np
+import pytest
+
+from imas.backends.imas_core.mdsplus_model import ensure_data_dir, mdsplus_model_dir
+from imas.ids_defs import (
+    ASCII_BACKEND,
+    CLOSEST_INTERP,
+    IDS_TIME_MODE_HETEROGENEOUS,
+    IDS_TIME_MODE_HOMOGENEOUS,
+    MDSPLUS_BACKEND,
+)
+from imas.ids_factory import IDSFactory
+from imas.test.test_helpers import open_dbentry
+
+# import IMAS HLI, skip module when this is an install without IMAS
+imas = pytest.importorskip("imas")
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(params=(IDS_TIME_MODE_HOMOGENEOUS, IDS_TIME_MODE_HETEROGENEOUS))
+def time_mode(request):
+    return request.param
+
+
+def test_write_read_time(backend, worker_id, tmp_path, time_mode):
+    """Write some data to an IDS and then check that all slices match."""
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    eq = IDSFactory().new("equilibrium")
+    eq.ids_properties.homogeneous_time = time_mode
+
+    eq.time = np.array([0.0, 0.1, 0.2])
+    dbentry.put(eq)
+
+    eq = dbentry.get("equilibrium")
+    assert np.array_equal(eq.time, [0.0, 0.1, 0.2])
+    dbentry.close()
+
+
+def test_time_slicing_get(backend, worker_id, tmp_path, time_mode):
+    """Write some data to an IDS and then check that all slices match."""
+    if backend == ASCII_BACKEND:
+        pytest.skip("ASCII backend does not support slice mode")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    eq = IDSFactory().new("equilibrium")
+    eq.ids_properties.homogeneous_time = time_mode
+
+    # eq.time is the time coordinate for b0 in heterogeneous mode as well
+    eq.time = np.array([0.0, 0.1, 0.2])
+    eq.vacuum_toroidal_field.b0 = np.array([3.0, 4.0, 5.0])
+    dbentry.put(eq)
+
+    for time in range(3):
+        eq = dbentry.get_slice("equilibrium", time * 0.1, CLOSEST_INTERP)
+        assert eq.vacuum_toroidal_field.b0.value == time + 3.0
+    dbentry.close()
+
+
+def test_time_slicing_put(backend, worker_id, tmp_path, request, time_mode):
+    """Write some slices to an IDS and then check that they are all there"""
+    if backend == ASCII_BACKEND:
+        pytest.skip("ASCII backend does not support slice mode")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    eq = IDSFactory().new("equilibrium")
+    eq.ids_properties.homogeneous_time = time_mode
+
+    for time in range(3):
+        # eq.time is the time coordinate for b0 in heterogeneous mode as well
+        eq.time = [time * 0.1]
+        eq.vacuum_toroidal_field.b0 = [time + 3.0]
+        dbentry.put_slice(eq)
+
+    eq = dbentry.get("equilibrium")
+
+    assert np.allclose(eq.vacuum_toroidal_field.b0.value, [3.0, 4.0, 5.0])
+    assert np.allclose(eq.time.value, [0.0, 0.1, 0.2])
+    dbentry.close()
+
+
+@pytest.mark.skip(reason="skipping hli test")
+def test_hli_time_slicing_put(backend, worker_id, tmp_path, time_mode):
+    """Write some slices to an IDS and then check that they are all there"""
+    if backend == ASCII_BACKEND:
+        pytest.skip("ASCII backend does not support slice mode")
+
+    ids = imas.equilibrium()
+
+    if worker_id == "master":
+        pulse = 1
+    else:
+        pulse = int(worker_id[2:]) + 1
+
+    # ensure presence of mdsplus model dir
+    if backend == MDSPLUS_BACKEND:
+        os.environ["ids_path"] = mdsplus_model_dir(IDSFactory())
+        ensure_data_dir(str(tmp_path), "test", "3", 9999)
+    db_entry = imas.DBEntry(backend, "test", pulse, 9999, user_name=str(tmp_path))
+    status, ctx = db_entry.create()
+    if status != 0:
+        logger.error("Error opening db entry %s", status)
+
+    ids.ids_properties.homogeneous_time = time_mode
+
+    for time in range(3):
+        ids.vacuum_toroidal_field.b0 = np.asarray([time + 3.0])
+        # eq.time is the time coordinate for b0 in heterogeneous mode as well
+        ids.time = np.asarray([time * 0.1])
+        ids.putSlice(0, db_entry)
+
+    ids.get(0, db_entry)
+
+    db_entry.close()
+
+    assert np.allclose(ids.vacuum_toroidal_field.b0, [3.0, 4.0, 5.0])
+    assert np.allclose(ids.time, [0.0, 0.1, 0.2])
+
+
+def test_time_slicing_put_two(backend, worker_id, tmp_path, time_mode):
+    """Write some slices to an IDS and then check that they are all there"""
+    if backend == ASCII_BACKEND:
+        pytest.skip("ASCII backend does not support slice mode")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    eq = IDSFactory().new("equilibrium")
+    eq.ids_properties.homogeneous_time = time_mode
+
+    for time in range(3):
+        eq.vacuum_toroidal_field.b0 = [time + 3.0, time + 3.5]
+        # eq.time is the time coordinate for b0 in heterogeneous mode as well
+        eq.time = [time * 0.1, (time + 0.5) * 0.1]
+        dbentry.put_slice(eq)
+
+    eq = dbentry.get("equilibrium")
+
+    assert np.array_equal(
+        eq.vacuum_toroidal_field.b0.value, [3.0, 3.5, 4.0, 4.5, 5.0, 5.5]
+    )
+    # Use allclose instead of array_equal since 0.15000000000000002 != 0.15
+    assert np.allclose(eq.time.value, [0.0, 0.05, 0.1, 0.15, 0.2, 0.25])
+    dbentry.close()
+
+
+def test_time_slicing_time_mode(backend, worker_id, tmp_path, time_mode):
+    """Write data to controllers IDS to test heterogeneous time mode."""
+    if backend == ASCII_BACKEND:
+        pytest.skip("ASCII backend does not support slice mode")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    ctrls = IDSFactory().new("controllers")
+    ctrls.ids_properties.homogeneous_time = time_mode
+
+    ctrls.time = [0.1, 0.2, 0.3]
+    ctrls.linear_controller.resize(2)
+    # This time base is ignored for IDS_TIME_MODE_HOMOGENEOUS
+    ctrls.linear_controller[0].inputs.time = [0.0, 0.1, 0.2]
+    ctrls.linear_controller[0].inputs.data = [[0.0, 1.0, 2.0]]
+    # This time base is ignored for IDS_TIME_MODE_HOMOGENEOUS
+    ctrls.linear_controller[1].inputs.time = [0.2, 0.3, 0.4]
+    ctrls.linear_controller[1].inputs.data = [[0.0, 1.0, 2.0]]
+    # code.output_flag always uses /time as timebase
+    ctrls.code.output_flag = [0, 1, 2]
+
+    dbentry.put(ctrls)
+    ctrls = dbentry.get_slice("controllers", 0.2, CLOSEST_INTERP)
+    assert np.array_equal(ctrls.time.value, [0.2])
+    if time_mode == IDS_TIME_MODE_HETEROGENEOUS:
+        assert np.array_equal(ctrls.linear_controller[0].inputs.time.value, [0.2])
+        assert np.array_equal(ctrls.linear_controller[0].inputs.data.value, [[2.0]])
+        assert np.array_equal(ctrls.linear_controller[1].inputs.time.value, [0.2])
+        assert np.array_equal(ctrls.linear_controller[1].inputs.data.value, [[0.0]])
+    else:  # HOMOGENEOUS_TIME
+        # Note: don't test time arrays of linear_controller inputs, as they shouldn't be
+        # used in homogeneous time mode
+        assert np.array_equal(ctrls.linear_controller[0].inputs.data.value, [[1.0]])
+        assert np.array_equal(ctrls.linear_controller[1].inputs.data.value, [[1.0]])
+    assert np.array_equal(ctrls.code.output_flag.value, [1])
+    dbentry.close()

imas/test/test_uda_support.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+from zlib import crc32
+
+from imas import dd_zip
+from imas.backends.imas_core.uda_support import extract_idsdef
+
+
+def test_extract_idsdef():
+    fname = extract_idsdef("4.0.0")
+    expected_crc = dd_zip.get_dd_xml_crc("4.0.0")
+    actual_crc = crc32(Path(fname).read_bytes())
+    assert expected_crc == actual_crc