shepherd-core 2023.12.1__py3-none-any.whl → 2024.4.1__py3-none-any.whl

tests/decoder_waveform/test_decoder.py

@@ -1,34 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core.decoder_waveform import Uart
-
-
-@pytest.fixture
-def example_path() -> Path:
-    return Path(__file__).resolve().parent.parent.parent / "examples"
-
-
-def test_decode_uart(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_symbols()
-    _ = uwd.get_lines()
-    _ = uwd.get_text()
-
-
-def test_decode_speedup(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_symbols(force_redo=True)
-    _ = uwd.get_lines(force_redo=True)
-    _ = uwd.get_text(force_redo=True)
-
-    # these now have cached the result
-    _ = uwd.get_symbols()
-    _ = uwd.get_lines()
-    _ = uwd.get_text()
-
-
-def test_decode_chained(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_text()  # get_symbols() and get_lines() is executed automatically

tests/fw_tools/conftest.py

@@ -1,5 +0,0 @@
-from pathlib import Path
-
-names_elf = ["build_msp.elf", "build_nrf.elf"]
-
-files_elf = [Path(__file__).resolve().with_name(name) for name in names_elf]

tests/fw_tools/test_converter.py

@@ -1,76 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-
-from .conftest import files_elf
-
-
-@pytest.fixture()
-def path_hex(tmp_path: Path) -> Path:
-    path_elf = files_elf[0]
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    return fw_tools.elf_to_hex(path_elf, path_hex)
-
-
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_to_hex(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_gen = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert path_hex.exists()
-    assert path_hex.as_posix() == path_gen.as_posix()
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_firmware_to_hex_w_elf(path_elf: Path) -> None:
-    path_gen = fw_tools.firmware_to_hex(path_elf)
-    assert path_gen.exists
-    assert path_gen.suffix.lower() == ".hex"
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_firmware_to_hex_w_hex(path_hex: Path) -> None:
-    path_gen = fw_tools.firmware_to_hex(path_hex)
-    assert path_gen.exists
-    assert path_gen.suffix.lower() == ".hex"
-    assert path_gen.as_posix() == path_hex.as_posix()
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_firmware_to_hex_w_fail() -> None:
-    path_some = Path(__file__).parent / "conftest.py"
-    with pytest.raises(ValueError):
-        _ = fw_tools.firmware_to_hex(path_some)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_hash() -> None:
-    hash_a = fw_tools.file_to_hash(files_elf[0])
-    hash_b = fw_tools.file_to_hash(files_elf[1])
-    hash_c = fw_tools.file_to_hash(files_elf[1])
-    assert hash_a != hash_b
-    assert hash_b == hash_c
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_base64(path_elf: Path, tmp_path: Path) -> None:
-    b64_a = fw_tools.file_to_base64(path_elf)
-    path_b = (tmp_path / path_elf.name).resolve()
-    fw_tools.base64_to_file(b64_a, path_b)
-    b64_b = fw_tools.file_to_base64(path_b)
-    assert b64_a == b64_b
-    hash_a = fw_tools.file_to_hash(path_elf)
-    hash_b = fw_tools.file_to_hash(path_b)
-    assert hash_a == hash_b
-
-
-# extract_firmware() is indirectly tested with Firmware-Class

tests/fw_tools/test_patcher.py

@@ -1,66 +0,0 @@
-import shutil
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-
-from .conftest import files_elf
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_finding(path_elf: Path) -> None:
-    assert fw_tools.find_symbol(path_elf, "SHEPHERD_NODE_ID")
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_reading(path_elf: Path) -> None:
-    assert fw_tools.read_symbol(path_elf, "SHEPHERD_NODE_ID")
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_mod(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    sym = "SHEPHERD_NODE_ID"
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_symbol_value(path_new, sym, value, overwrite=False)
-    assert path_gen.is_file()
-    assert path_gen.as_posix() != path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, sym)
-    assert value == value_new
-    value_old = fw_tools.read_symbol(path_elf, sym)
-    assert value_new != value_old
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_mod_overwrite(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    sym = "SHEPHERD_NODE_ID"
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_symbol_value(
-        path_new, sym, value, overwrite=True
-    )  # TODO: WinOS-trouble
-    assert path_gen.is_file()
-    assert path_gen.as_posix() == path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, sym)
-    assert value == value_new
-    value_old = fw_tools.read_symbol(path_elf, sym)
-    assert value_new != value_old
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_id_mod(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_uid(path_new, value)
-    assert path_gen.as_posix() == path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, "SHEPHERD_NODE_ID")
-    assert value == value_new

tests/fw_tools/test_validation.py

@@ -1,56 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-from shepherd_core.data_models import FirmwareDType
-
-from .conftest import files_elf
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_detection(path_elf: Path) -> None:
-    assert fw_tools.is_elf(path_elf)
-    if "nrf" in path_elf.name:
-        assert fw_tools.is_elf_nrf52(path_elf)
-    elif "msp" in path_elf.name:
-        assert fw_tools.is_elf_msp430(path_elf)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_determination(path_elf: Path) -> None:
-    assert fw_tools.determine_type(path_elf) == FirmwareDType.path_elf
-    if "nrf" in path_elf.name:
-        assert fw_tools.determine_arch(path_elf) == "nrf52"
-    elif "msp" in path_elf.name:
-        assert fw_tools.determine_arch(path_elf) == "msp430"
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_hex_detection(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_hex = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert fw_tools.is_hex(path_hex)
-    if "nrf" in path_elf.name:
-        assert fw_tools.is_hex_nrf52(path_hex)
-    elif "msp" in path_elf.name:
-        assert fw_tools.is_hex_msp430(path_hex)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_hex_determination(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_hex = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert fw_tools.determine_type(path_hex) == FirmwareDType.path_hex
-    if "nrf" in path_elf.name:
-        assert fw_tools.determine_arch(path_hex) == "nrf52"
-    elif "msp" in path_elf.name:
-        assert fw_tools.determine_arch(path_hex) == "msp430"

tests/inventory/test_inventory.py

@@ -1,20 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core.inventory import Inventory
-from shepherd_core.inventory import InventoryList
-from shepherd_core.inventory import PythonInventory
-from shepherd_core.inventory import SystemInventory
-from shepherd_core.inventory import TargetInventory
-
-
-@pytest.mark.parametrize("inv", [PythonInventory, SystemInventory, TargetInventory, Inventory])
-def test_collect_data(inv: Inventory) -> None:
-    inv.collect()
-
-
-def test_inventorize(tmp_path: Path) -> None:
-    inv = Inventory.collect()
-    inl = InventoryList(elements=[inv])
-    inl.to_csv(tmp_path / "some.csv")

tests/test_cal_hw.py

@@ -1,34 +0,0 @@
-from typing import Callable
-
-import pytest
-
-from shepherd_core.calibration_hw_def import adc_current_to_raw
-from shepherd_core.calibration_hw_def import adc_raw_to_current
-from shepherd_core.calibration_hw_def import adc_raw_to_voltage
-from shepherd_core.calibration_hw_def import adc_voltage_to_raw
-from shepherd_core.calibration_hw_def import dac_raw_to_voltage
-from shepherd_core.calibration_hw_def import dac_voltage_to_raw
-
-
-@pytest.mark.parametrize("fn", [adc_current_to_raw, adc_voltage_to_raw, dac_voltage_to_raw])
-def test_convert_to_raw(fn: Callable) -> None:
-    values = [-1, -1e-6, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e-0]
-    value_prev = -1
-    for value in values:
-        value_raw = fn(value)
-        assert value_raw >= 0
-        assert value_raw < 2**18
-        assert value_raw >= value_prev
-        value_prev = value_raw
-
-
-@pytest.mark.parametrize("fn", [adc_raw_to_current, adc_raw_to_voltage, dac_raw_to_voltage])
-def test_convert_to_si(fn: Callable) -> None:
-    values = [-100, -1, 0, 1, 2**6, 2**12, 2**18, 2**24]
-    value_prev = -1
-    for value in values:
-        value_si = fn(value)
-        assert value_si >= 0
-        assert value_si <= 6
-        assert value_si >= value_prev
-        value_prev = value_si

tests/test_examples.py

@@ -1,40 +0,0 @@
-import os
-import subprocess
-from pathlib import Path
-
-import pytest
-
-
-@pytest.fixture
-def example_path() -> Path:
-    path = Path(__file__).resolve().parent.parent / "examples"
-    os.chdir(path)
-    return path
-
-
-examples = [
-    "experiment_generic_var1.py",
-    "experiment_models.py",
-    "inventory.py",
-    "uart_decode_waveform.py",
-    "vharvester_simulation.py",
-    "vsource_simulation.py",
-]
-
-
-@pytest.mark.parametrize("file", examples)
-def test_example_scripts(example_path: Path, file: str) -> None:
-    subprocess.check_call(f"python {example_path / file}", shell=True)
-
-
-examples_fw = [
-    "firmware_model.py",
-    "firmware_modification.py",
-]
-
-
-@pytest.mark.converter
-@pytest.mark.elf
-@pytest.mark.parametrize("file", examples_fw)
-def test_example_scripts_fw(example_path: Path, file: str) -> None:
-    subprocess.check_call(f"python {example_path / file}", shell=True)

tests/test_logger.py

@@ -1,15 +0,0 @@
-import pytest
-
-from shepherd_core import get_verbose_level
-from shepherd_core import increase_verbose_level
-
-
-@pytest.mark.parametrize("log_level", range(-5, 10))
-def test_log_levels(log_level: int) -> None:
-    increase_verbose_level(log_level)
-    if log_level <= 2:
-        assert get_verbose_level() == 2
-    elif log_level <= 3:
-        assert get_verbose_level() == log_level
-    else:
-        assert get_verbose_level() == 3

tests/test_reader.py

@@ -1,283 +0,0 @@
-import sys
-from pathlib import Path
-
-import h5py
-import pytest
-import yaml
-
-from shepherd_core import Reader
-from shepherd_core import Writer
-
-
-def test_reader_metadata(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.energy() > 0
-        assert sfr.is_valid()
-
-        meta_data_a = sfr.save_metadata()
-        meta_path = data_h5.resolve().with_suffix(".yaml")
-        assert meta_path.exists()
-        with meta_path.open() as meta_file:
-            meta_data_b = yaml.safe_load(meta_file)
-            assert len(meta_data_b) == len(meta_data_a)
-            assert sys.getsizeof(meta_data_b) == sys.getsizeof(meta_data_a)
-
-
-def test_reader_items(data_h5: Path) -> None:
-    """Access internal"""
-    with Reader(data_h5, verbose=True) as sfr:
-        _ = sfr["data"]  # group
-        _ = sfr["mode"]  # attribute
-        with pytest.raises(KeyError):
-            _ = sfr["non-existing"]
-
-
-def test_reader_open(tmp_path: Path) -> None:
-    with pytest.raises(TypeError):
-        Reader(file_path=None)
-
-    tmp_file = (tmp_path / "data.h5").resolve()
-
-    with pytest.raises(FileNotFoundError):
-        Reader(file_path=tmp_file)
-
-    with tmp_file.open("w") as tf:
-        tf.write("abc def ghi")
-    with pytest.raises(TypeError):
-        Reader(file_path=tmp_file)
-
-
-def test_reader_meta_repr(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        print(sfr)
-        print(sfr.get_calibration_data())
-        print(sfr.get_hrv_config())
-
-
-def test_reader_read_open_end(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers():
-            print(len(buf[0]))
-
-
-def test_reader_read_5(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(end_n=5):
-            print(len(buf[0]))
-
-
-def test_reader_read_start_late(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(start_n=2):
-            print(len(buf[0]))
-
-
-def test_reader_read_raw(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        for buf in sfr.read_buffers(is_raw=True):
-            print(len(buf[0]))
-
-
-def test_reader_non_valid(tmp_path: Path) -> None:
-    data_h5 = tmp_path / "data.h5"
-    with h5py.File(data_h5, "w") as h5f:
-        grp_data = h5f.create_group("data")
-        grp_data.create_dataset("time", (0,))
-        grp_data.create_dataset("current", (0,))
-        grp_data.create_dataset("voltage", (0,))
-        grp_data["time"].attrs["gain"] = 1
-        grp_data["current"].attrs["gain"] = 1
-        grp_data["voltage"].attrs["gain"] = 1
-        grp_data["time"].attrs["offset"] = 0
-        grp_data["current"].attrs["offset"] = 0
-        grp_data["voltage"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        # try getting metadata -> no exception but safe defaults
-        sfr.get_window_samples()
-        sfr.get_mode()
-        sfr.get_mode()
-        sfr.get_hostname()
-        sfr.get_datatype()
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_path(tmp_path: Path) -> None:
-    with pytest.raises(FileNotFoundError):
-        Reader(tmp_path, verbose=True)
-
-
-def test_reader_fault_no_data(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_mode(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file.attrs["mode"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_fake_mode(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file.attrs["mode"] = "burning"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_no_window_samples(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"].attrs["window_samples"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_no_datatype(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"].attrs["datatype"]
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_datatype(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"].attrs["datatype"] = "apples"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_window1(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw["data"].attrs["datatype"] = "ivcurve"
-        sfw["data"].attrs["window_samples"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.is_valid()
-
-
-def test_reader_fault_wrong_window2(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw["data"].attrs["datatype"] = "ivsample"
-        sfw["data"].attrs["window_samples"] = 1111
-    with Reader(data_h5, verbose=True) as sfr:
-        # only triggers warning
-        assert sfr.is_valid()
-
-
-def test_reader_fault_no_current(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["current"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_voltage(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["voltage"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_gain(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["time"].attrs["gain"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_no_offset(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        del sfw.h5file["data"]["time"].attrs["offset"]
-    with pytest.raises(KeyError):
-        Reader(data_h5, verbose=True)
-
-
-def test_reader_fault_non_eq_time(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"]["time"].resize((0,))
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_unaligned(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        new_size = sfw.samples_per_buffer / 2
-        sfw.h5file["data"]["time"].resize((new_size,))
-        sfw.h5file["data"]["voltage"].resize((new_size,))
-        sfw.h5file["data"]["current"].resize((new_size,))
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_strange_compression(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        time = sfw.h5file["data"]["time"][:]
-        del sfw.h5file["data"]["time"]
-        sfw.h5file["data"].create_dataset(
-            "time",
-            (0,),
-            dtype="u8",
-            maxshape=(None,),
-            compression="lzf",  # something like szip wanted
-        )
-        sfw.h5file["data"]["time"].resize(time.shape)
-        sfw.h5file["data"]["time"][0 : time.shape[0]] = time[: time.shape[0]]
-        sfw.h5file["data"]["time"].attrs["gain"] = 1
-        sfw.h5file["data"]["time"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_slow_compression(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        time = sfw.h5file["data"]["time"][:]
-        del sfw.h5file["data"]["time"]
-        sfw.h5file["data"].create_dataset(
-            "time",
-            (0,),
-            dtype="u8",
-            maxshape=(None,),
-            compression="gzip",
-            compression_opts=9,
-        )
-        sfw.h5file["data"]["time"].resize(time.shape)
-        sfw.h5file["data"]["time"][0 : time.shape[0]] = time[: time.shape[0]]
-        sfw.h5file["data"]["time"].attrs["gain"] = 1
-        sfw.h5file["data"]["time"].attrs["offset"] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_no_hostname(data_h5: Path) -> None:
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file.attrs["hostname"] = "unknown"
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.is_valid()
-        # soft-criteria ... reader just complains
-
-
-def test_reader_fault_jumps_timestamp(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.check_timediffs()
-    with Writer(data_h5, modify_existing=True) as sfw:
-        sfw.h5file["data"]["time"][sfw.samples_per_buffer] = 0
-    with Reader(data_h5, verbose=True) as sfr:
-        assert not sfr.check_timediffs()
-
-
-def test_reader_save_meta(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        assert sfr.save_metadata() != {}
-        # yaml now already exists
-        assert sfr.save_metadata() == {}
-
-
-def test_reader_save_meta_fail(data_h5: Path) -> None:
-    with Reader(data_h5, verbose=True) as sfr:
-        sfr.file_path = None
-        assert sfr.save_metadata() == {}