@mat3ra/made 2026.8.13-0 → 2026.8.26-0

package/tests/py/unit/test_material.py

@@ -1,158 +0,0 @@
-import json
-from pathlib import Path
-
-import numpy as np
-import pytest
-from mat3ra.made.basis import Basis, Coordinates
-from mat3ra.made.lattice import Lattice
-from mat3ra.made.material import Material
-from mat3ra.utils import assertion as assertion_utils
-from unit.fixtures.bulk import BULK_Si_PRIMITIVE
-from unit.fixtures.slab import BULK_Si_CONVENTIONAL
-from unit.utils import assert_two_entities_deep_almost_equal
-
-FIXTURES_DIR = Path(__file__).parents[2] / "fixtures"
-HASH_KEY = "hash"
-SCALED_HASH_KEY = "scaledHash"
-
-
-def load_fixture(name: str) -> dict:
-    with open(FIXTURES_DIR / name) as f:
-        return json.load(f)
-
-
-def test_create_default():
-    material = Material.create_default()
-    assert isinstance(material.basis, Basis)
-    assert isinstance(material.basis.coordinates, Coordinates)
-    assert isinstance(material.lattice, Lattice)
-    assert material.name == Material.__default_config__["name"]
-
-
-def test_create():
-    material = Material.create(BULK_Si_CONVENTIONAL)
-    assert isinstance(material.basis, Basis)
-    assert isinstance(material.basis.coordinates, Coordinates)
-    assert isinstance(material.lattice, Lattice)
-    assert_two_entities_deep_almost_equal(material, BULK_Si_CONVENTIONAL)
-
-
-def test_create_with_cell_as_list():
-    # The key cell should be ignored and Basis.Cell created from Lattice by Material
-    cell = [
-        [1.0, 0.0, 0.0],
-        [0.0, 1.0, 0.0],
-        [0.0, 0.0, 1.0],
-    ]
-    config = {**Material.__default_config__, "basis": {**Material.__default_config__["basis"], "cell": cell}}
-
-    material = Material.create(config)
-    assert isinstance(material.basis, Basis)
-    assert material.basis.cell.vector_arrays == material.lattice.vector_arrays
-
-
-def test_material_to_json():
-    material = Material.create_default()
-    # Remove all keys that are null in the config
-    assert_two_entities_deep_almost_equal(material, Material.__default_config__)
-
-
-def test_material_clone():
-    material = Material.create_default()
-    clone = material.clone()
-    assert_two_entities_deep_almost_equal(material, clone)
-
-
-def test_material_to_from_cartesian():
-    material = Material.create_default()
-    assert material.basis.is_in_crystal_units is True
-    assert material.basis.is_in_cartesian_units is False
-    material.to_cartesian()
-    assert material.basis.is_in_crystal_units is False
-    assert material.basis.is_in_cartesian_units is True
-    assert np.allclose(material.basis.coordinates.values[1], [1.1163, 0.7893, 1.9335], atol=1e-4)
-    material.to_crystal()
-    assert material.basis.is_in_crystal_units is True
-    assert material.basis.is_in_cartesian_units is False
-    assert np.allclose(material.basis.coordinates.values[1], [0.25, 0.25, 0.25], atol=1e-4)
-    assert_two_entities_deep_almost_equal(material, Material.__default_config__)
-
-
-def test_material_to_cartesian_to_crystal_repeated():
-    material = Material.create_default()
-    material.to_cartesian()
-    material.to_cartesian()
-    assert np.allclose(material.basis.coordinates.values[1], [1.1163, 0.7893, 1.9335], atol=1e-4)
-    material.to_crystal()
-    material.to_crystal()
-    assert_two_entities_deep_almost_equal(material, Material.__default_config__)
-
-
-def test_basis_to_json():
-    material = Material.create_default()
-    basis = material.basis
-    assert_two_entities_deep_almost_equal(basis, Material.__default_config__["basis"])
-
-
-def test_basis_cell_lattice_sync():
-    """Test synchronization between basis.cell and material.lattice"""
-    material = Material.create_default()
-    # Change lattice vectors
-    new_vectors = [[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 3.0]]
-    new_lattice = Lattice.from_vectors_array(new_vectors)
-    material.set_lattice(new_lattice)
-    # Verify basis.cell matches new lattice vectors
-    assertion_utils.assert_deep_almost_equal(new_vectors, material.basis.cell.vector_arrays)
-    assertion_utils.assert_deep_almost_equal(new_vectors, material.lattice.vector_arrays)
-    # Verify basis coordinates are still correct
-
-
-@pytest.mark.parametrize(
-    "initial_labels, reset_labels, expected_final",
-    [
-        # Test resetting with empty list
-        ([1, 2], [], []),
-        # Test resetting with None
-        ([1, 2], None, []),
-        # Test normal behavior with non-empty lists
-        ([], [1, 2], [1, 2]),
-    ],
-)
-def test_set_labels_from_list(initial_labels, reset_labels, expected_final):
-    material = Material.create(BULK_Si_PRIMITIVE)
-
-    if initial_labels:
-        material.basis.set_labels_from_list(initial_labels)
-        assert len(material.basis.labels.values) == len(initial_labels)
-        assert material.basis.labels.values == initial_labels
-
-    material.basis.set_labels_from_list(reset_labels)
-
-    assert len(material.basis.labels.values) == len(expected_final)
-    assert material.basis.labels.values == expected_final
-
-
-@pytest.mark.parametrize("fixture_file", ["si-standata.json", "Graphene.json"])
-def test_calculate_hash(fixture_file):
-    fixture = load_fixture(fixture_file)
-    material = Material.create(fixture)
-    assert material.hash == fixture["hash"]
-    assert material.scaled_hash == fixture["scaledHash"]
-
-
-def test_calculate_hash_feo_standata():
-    from mat3ra.standata.materials import Materials
-
-    expected_hashes = load_fixture("hashes.json")["FeO"]
-    data = Materials.get_by_name_first_match("FeO")
-    material = Material.create(data)
-    assert material.hash == expected_hashes["hash"]
-    assert material.scaled_hash == expected_hashes["scaledHash"]
-
-
-def test_model_dump_includes_hashes():
-    material = Material.create_default()
-    serialized_material = material.model_dump()
-
-    assert serialized_material[HASH_KEY] == material.hash
-    assert serialized_material[SCALED_HASH_KEY] == material.scaled_hash

package/tests/py/unit/test_operations.py

@@ -1,126 +0,0 @@
-import math
-
-import numpy as np
-import pytest
-from mat3ra.esse.models.core.abstract.matrix_3x3 import Matrix3x3Schema
-from mat3ra.esse.models.core.reusable.axis_enum import AxisEnum
-from mat3ra.made.material import Material
-from mat3ra.made.tools.build_components.operations.core.modifications.perturb import (
-    SineWavePerturbationFunctionHolder,
-)
-from mat3ra.made.tools.operations.core.binary import stack_two_materials
-from mat3ra.made.tools.operations.core.unary import perturb, strain, translate_atoms
-from mat3ra.made.tools.operations.reusable.unary import transform_material_by_matrix
-from unit.fixtures.bulk import BULK_Si_CONVENTIONAL
-from unit.fixtures.strain import BULK_Si_CONVENTIONAL_STRAINED
-from unit.utils import assert_two_entities_deep_almost_equal
-
-from .fixtures.bulk import BULK_Si_PRIMITIVE
-from .fixtures.nanoribbon.nanoribbon import GRAPHENE_ZIGZAG_NANORIBBON
-from .fixtures.slab import SI_CONVENTIONAL_SLAB_001
-
-STRAIN_TEST_CASES = [
-    (BULK_Si_CONVENTIONAL, [[1.1, 0, 0], [0, 1.1, 0], [0, 0, 1.0]], BULK_Si_CONVENTIONAL_STRAINED),
-]
-
-
-@pytest.mark.parametrize("material_config, strain_matrix, expected_material_config", STRAIN_TEST_CASES)
-def test_strain(material_config, strain_matrix, expected_material_config):
-    material = Material.create(material_config)
-    strain_matrix_obj = Matrix3x3Schema(root=strain_matrix)
-    expected_material = Material.create(expected_material_config)
-
-    strained_material = strain(material, strain_matrix_obj)
-
-    assert_two_entities_deep_almost_equal(strained_material, expected_material)
-
-
-@pytest.mark.parametrize(
-    "material1_config, material2_config, stacking_axis, expected_a, expected_b, expected_c",
-    [
-        (BULK_Si_PRIMITIVE, BULK_Si_PRIMITIVE, AxisEnum.z, 3.867, 3.867, 7.734),
-        (BULK_Si_PRIMITIVE, BULK_Si_PRIMITIVE, AxisEnum.x, 7.734, 3.867, 3.867),
-    ],
-)
-def test_stack_two_materials(
-    material1_config: dict,
-    material2_config: dict,
-    stacking_axis: AxisEnum,
-    expected_a: float,
-    expected_b: float,
-    expected_c: float,
-):
-    material1 = Material.create(material1_config)
-    material2 = Material.create(material2_config)
-
-    original_atom_count1 = len(material1.basis.coordinates.values)
-    original_atom_count2 = len(material2.basis.coordinates.values)
-
-    stacked_material = stack_two_materials(material1, material2, stacking_axis)
-
-    assert len(stacked_material.basis.coordinates.values) == original_atom_count1 + original_atom_count2
-
-    assert math.isclose(stacked_material.lattice.a, expected_a)
-    assert math.isclose(stacked_material.lattice.b, expected_b)
-    assert math.isclose(stacked_material.lattice.c, expected_c)
-
-
-@pytest.mark.parametrize(
-    "material_config, perturbation_function, expected_coord_changes",
-    [
-        (
-            GRAPHENE_ZIGZAG_NANORIBBON,
-            SineWavePerturbationFunctionHolder(amplitude=0.1, wavelength=1.0, phase=0.0, axis="x"),
-            [0.0, 0.0, -0.0383],
-        ),
-    ],
-)
-def test_perturb(material_config, perturbation_function, expected_coord_changes):
-    material = Material.create(material_config)
-    original_coords = [coord[:] for coord in material.basis.coordinates.values]
-
-    perturbed_material = perturb(material, perturbation_function)
-    actual_delta = np.array(original_coords[0]) - np.array(perturbed_material.basis.coordinates.values[0])
-    assert np.isclose(actual_delta, expected_coord_changes, atol=1e-4).all()
-
-
-@pytest.mark.parametrize(
-    "matrix, expected_a, expected_b, expected_c",
-    [
-        (np.eye(3), 5.468763846, 5.468763846, 15.937527692),
-        (np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]]), 5.468763846, 5.468763846, 15.937527692),
-        (np.array([[1, 0, 0], [0, 0, 1], [0, 1, 0]]), 5.468763846, 15.937527692, 5.468763846),
-        (np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]]), 15.937527692, 5.468763846, 5.468763846),
-    ],
-)
-def test_transform_material_by_matrix(matrix, expected_a, expected_b, expected_c):
-    material = Material.create(SI_CONVENTIONAL_SLAB_001)
-    transformed_material = transform_material_by_matrix(material, matrix)
-
-    assert len(transformed_material.basis.coordinates.values) == len(material.basis.coordinates.values)
-    assert len(transformed_material.basis.elements.values) == len(material.basis.elements.values)
-    assert transformed_material.lattice.a == pytest.approx(expected_a, abs=1e-6)
-    assert transformed_material.lattice.b == pytest.approx(expected_b, abs=1e-6)
-    assert transformed_material.lattice.c == pytest.approx(expected_c, abs=1e-6)
-
-
-@pytest.mark.parametrize(
-    "material_config, atom_ids, vector, expected_coord_change",
-    [
-        (SI_CONVENTIONAL_SLAB_001, [3], [0.0, 0.0, -1.5], [0.0, 0.0, -1.5]),
-    ],
-)
-def test_translate_atoms(material_config, atom_ids, vector, expected_coord_change):
-    material = Material.create(material_config)
-    original_coords = [coord[:] for coord in material.basis.coordinates.values]
-
-    translated_material = translate_atoms(material, atom_ids, vector)
-    lattice_vectors = np.array(material.lattice.vector_arrays)
-
-    actual_delta = (
-        np.array(translated_material.basis.coordinates.values[atom_ids[0]]) - np.array(original_coords[atom_ids[0]])
-    ) @ lattice_vectors
-    assert np.isclose(actual_delta, expected_coord_change, atol=1e-4).all()
-
-    untouched_id = atom_ids[0] - 1
-    assert np.allclose(translated_material.basis.coordinates.values[untouched_id], original_coords[untouched_id])

package/tests/py/unit/test_primitive_cell.py

@@ -1,118 +0,0 @@
-import math
-import pytest
-
-from mat3ra.made.cell.primitive_cell import get_primitive_lattice_vectors_from_config
-from mat3ra.made.lattice import Lattice, LatticeTypeEnum
-from unit.utils import assert_two_entities_deep_almost_equal
-
-EXPECTED_PRIMITIVE_CELL_NA4CL4 = [
-    [5.691694, 0.0, 0.0],
-    [0.0, 5.691694, 0.0],
-    [0.0, 0.0, 5.691694],
-]
-
-
-def test_primitive_lattice_vectors_na4cl4():
-    """
-    Replicates the TypeScript test for Na4Cl4 (CUB cell).
-    Translates from: tests/js/cell/primitive_cell.ts
-    """
-    lattice = Lattice(type=LatticeTypeEnum.CUB, a=5.691694)
-    actual_primitive_cell = get_primitive_lattice_vectors_from_config(lattice)
-
-    assert_two_entities_deep_almost_equal(EXPECTED_PRIMITIVE_CELL_NA4CL4, actual_primitive_cell)
-
-
-@pytest.mark.parametrize(
-    "l_type, kwargs, expected",
-    [
-        (LatticeTypeEnum.CUB, {"a": 2.0}, [[2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]]),
-        (LatticeTypeEnum.FCC, {"a": 2.0}, [[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0]]),
-        (LatticeTypeEnum.BCC, {"a": 2.0}, [[-1.0, 1.0, 1.0], [1.0, -1.0, 1.0], [1.0, 1.0, -1.0]]),
-        (LatticeTypeEnum.TET, {"a": 2.0, "c": 3.0}, [[2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 3.0]]),
-        (LatticeTypeEnum.BCT, {"a": 2.0, "c": 3.0}, [[-1.0, 1.0, 1.5], [1.0, -1.0, 1.5], [1.0, 1.0, -1.5]]),
-        (LatticeTypeEnum.ORC, {"a": 2.0, "b": 3.0, "c": 4.0}, [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]]),
-        (
-            LatticeTypeEnum.ORCF,
-            {"a": 2.0, "b": 3.0, "c": 4.0},
-            [[0.0, 1.5, 2.0], [1.0, 0.0, 2.0], [1.0, 1.5, 0.0]],
-        ),
-        (
-            LatticeTypeEnum.ORCI,
-            {"a": 2.0, "b": 3.0, "c": 4.0},
-            [[-1.0, 1.5, 2.0], [1.0, -1.5, 2.0], [1.0, 1.5, -2.0]],
-        ),
-        (
-            LatticeTypeEnum.ORCC,
-            {"a": 2.0, "b": 3.0, "c": 4.0},
-            [[1.0, 1.5, 0.0], [-1.0, 1.5, 0.0], [0.0, 0.0, 4.0]],
-        ),
-        (
-            LatticeTypeEnum.HEX,
-            {"a": 2.0, "c": 3.0},
-            [[1.0, -math.sqrt(3), 0.0], [1.0, math.sqrt(3), 0.0], [0.0, 0.0, 3.0]],
-        ),
-        (
-            LatticeTypeEnum.RHL,
-            {"a": 2.0, "alpha": 60.0},
-            [[1.7320508, -1.0, 0.0], [1.7320508, 1.0, 0.0], [1.1547005, 0.0, 1.6329931]],
-        ),
-        (
-            LatticeTypeEnum.MCL,
-            {"a": 2.0, "b": 3.0, "c": 4.0, "alpha": 60.0},
-            [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 2.0, 3.4641016]],
-        ),
-        (
-            LatticeTypeEnum.MCLC,
-            {"a": 2.0, "b": 3.0, "c": 4.0, "alpha": 60.0},
-            [[1.0, 1.5, 0.0], [-1.0, 1.5, 0.0], [0.0, 2.0, 3.4641016]],
-        ),
-        (
-            LatticeTypeEnum.TRI,
-            {"a": 2.0, "b": 3.0, "c": 4.0, "alpha": 90.0, "beta": 90.0, "gamma": 90.0},
-            [[2.0, 0.0, 0.0], [0.0, 3.0, 0.0], [0.0, 0.0, 4.0]],
-        ),
-    ],
-)
-def test_primitive_lattice_generators(l_type, kwargs, expected):
-    """Validates the math generators for all 14 Bravais lattice scenarios."""
-    lattice = Lattice(type=l_type, **kwargs)
-    result = get_primitive_lattice_vectors_from_config(lattice)
-    assert_two_entities_deep_almost_equal(expected, result)
-
-
-def test_fallback_to_tri_when_type_is_none():
-    """Tests default fallback to 'TRI' when lattice_config.type is None."""
-    # Use a simple dummy class to bypass Pydantic's strict validation
-    # and simulate a malformed or incomplete Lattice config.
-    class MockLattice:
-        type = None
-        a, b, c = 2.0, 2.0, 2.0
-        alpha, beta, gamma = 90.0, 90.0, 90.0
-
-    lattice = MockLattice()
-    result = get_primitive_lattice_vectors_from_config(lattice)
-    expected = [[2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]]
-
-    assert_two_entities_deep_almost_equal(expected, result)
-
-
-def test_unsupported_lattice_type_raises_value_error():
-    """Ensures a ValueError is raised for an unknown lattice type mapping."""
-    # Using a MagicMock specifically here to force an invalid type value
-    # since LatticeTypeEnum won't allow arbitrary strings
-    class MockType:
-        value = "INVALID_TYPE"
-
-    class MockLattice:
-        type = MockType()
-        # Provide dummy parameters just in case
-        a, b, c = 2.0, 2.0, 2.0
-        alpha, beta, gamma = 90.0, 90.0, 90.0
-
-    lattice = MockLattice()
-
-    with pytest.raises(ValueError) as exc_info:
-        get_primitive_lattice_vectors_from_config(lattice)
-
-    assert "Unsupported lattice type 'INVALID_TYPE'" in str(exc_info.value)

package/tests/py/unit/test_reciprocal_lattice.py

@@ -1,86 +0,0 @@
-"""Tests for the ReciprocalLattice class."""
-
-from mat3ra.made.reciprocal import ReciprocalLattice
-from mat3ra.utils import assertion as assertion_utils
-
-
-def test_reciprocal_lattice_symmetry_points_cub():
-    """CUB lattice should have Γ, R, X, M symmetry points."""
-    lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    points = lattice.symmetry_points
-    labels = [p["point"] for p in points]
-    assert labels == ["Γ", "R", "X", "M"]
-
-
-def test_reciprocal_lattice_default_kpoint_path_cub():
-    lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    path = lattice.default_kpoint_path
-    labels = [p["point"] for p in path]
-    assert labels == ["Γ", "X", "M", "Γ", "R", "X", "M", "R"]
-
-
-def test_reciprocal_lattice_default_kpoint_path_bct():
-    """BCT with c < a should use BCT-1 path."""
-    lattice = ReciprocalLattice(a=4.0, b=4.0, c=2.0, type="BCT")
-    path = lattice.default_kpoint_path
-    labels = [p["point"] for p in path]
-    assert "Z1" in labels  # BCT-1 specific
-
-
-def test_reciprocal_lattice_extract_kpoint_path():
-    lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    data_points = [[0, 0, 0], [0.5, 0.5, 0.5]]
-    result = lattice.extract_kpoint_path(data_points)
-    assert len(result) == 2
-    assert result[0]["point"] == "Γ"
-    assert result[0]["steps"] == 0
-    assert result[1]["point"] == "R"
-    assert result[1]["steps"] == 1
-
-
-def test_reciprocal_lattice_extract_kpoint_path_empty():
-    lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    result = lattice.extract_kpoint_path([])
-    assert result == []
-
-
-def test_reciprocal_lattice_cartesian_coordinates():
-    lattice = ReciprocalLattice(a=5.64, b=5.64, c=5.64, type="CUB")
-    cart = lattice.cartesian_coordinates([0.5, 0.5, 0.5])
-    assert len(cart) == 3
-    assert all(isinstance(c, float) for c in cart)
-
-
-def test_reciprocal_lattice_dimensions_from_points_count():
-    """Test grid dimension calculation from total k-point count."""
-    lattice = ReciprocalLattice(a=2.0, b=3.0, c=4.0, type="ORC")
-    dims = lattice.get_dimensions_from_points_count(500)
-    assert len(dims) == 3
-    assert all(d >= 1 for d in dims)
-    # Product should be close to 500
-    product = dims[0] * dims[1] * dims[2]
-    assert product >= 500  # Should be at least 500 due to ceiling
-
-
-def test_reciprocal_lattice_dimensions_from_spacing():
-    lattice = ReciprocalLattice(a=2.0, b=3.0, c=4.0, type="ORC")
-    dims = lattice.get_dimensions_from_spacing(0.1)
-    assert len(dims) == 3
-    assert all(d >= 1 for d in dims)
-
-
-def test_reciprocal_lattice_spacing_from_dimensions():
-    lattice = ReciprocalLattice(a=2.0, b=3.0, c=4.0, type="ORC")
-    dims = [10, 7, 5]
-    spacing = lattice.get_spacing_from_dimensions(dims)
-    assert isinstance(spacing, float)
-    assert spacing > 0
-
-
-def test_reciprocal_lattice_reciprocal_vectors_inherited():
-    """ReciprocalLattice should inherit reciprocal_vectors from Lattice."""
-    lattice = ReciprocalLattice(a=2.0, b=3.0, c=4.0, type="ORC")
-    vecs = lattice.reciprocal_vectors
-    assert len(vecs) == 3
-    expected = [[0.5, 0.0, 0.0], [0.0, 1 / 3, 0.0], [0.0, 0.0, 0.25]]
-    assertion_utils.assert_deep_almost_equal(vecs, expected)

package/tests/py/unit/test_reciprocal_paths.py

@@ -1,64 +0,0 @@
-"""Tests for reciprocal paths data."""
-
-from mat3ra.made.reciprocal import RECIPROCAL_PATHS
-
-EXPECTED_KEYS = [
-    "CUB",
-    "BCC",
-    "FCC",
-    "TET",
-    "BCT-1",
-    "BCT-2",
-    "ORC",
-    "ORCF-1",
-    "ORCF-2",
-    "ORCF-3",
-    "ORCI",
-    "ORCC",
-    "HEX",
-    "RHL-1",
-    "RHL-2",
-    "MCL",
-    "MCLC-1",
-    "MCLC-2",
-    "MCLC-3",
-    "MCLC-4",
-    "MCLC-5",
-    "TRI",
-]
-
-
-def test_reciprocal_paths_all_keys_present():
-    for key in EXPECTED_KEYS:
-        assert key in RECIPROCAL_PATHS, f"Missing path key: {key}"
-
-
-def test_reciprocal_paths_count():
-    assert len(RECIPROCAL_PATHS) == len(EXPECTED_KEYS)
-
-
-def test_reciprocal_paths_entry_structure():
-    for key, path in RECIPROCAL_PATHS.items():
-        assert isinstance(path, list), f"Path {key} should be a list"
-        for entry in path:
-            assert "point" in entry, f"Entry in {key} missing 'point'"
-            assert "steps" in entry, f"Entry in {key} missing 'steps'"
-            assert entry["steps"] == 10, f"Entry in {key} should have steps=10"
-
-
-def test_reciprocal_paths_cub():
-    path = RECIPROCAL_PATHS["CUB"]
-    labels = [p["point"] for p in path]
-    assert labels == ["Γ", "X", "M", "Γ", "R", "X", "M", "R"]
-
-
-def test_reciprocal_paths_fcc():
-    path = RECIPROCAL_PATHS["FCC"]
-    labels = [p["point"] for p in path]
-    assert labels == ["Γ", "X", "W", "K", "Γ", "L", "U", "W", "L", "U", "X"]
-
-
-def test_reciprocal_paths_hex():
-    path = RECIPROCAL_PATHS["HEX"]
-    labels = [p["point"] for p in path]
-    assert labels == ["Γ", "M", "K", "Γ", "A", "L", "H", "A", "L", "M", "K", "H"]