def METHOD_NAME(geometry, method):
    # Method to test partial discretization (aimed at finite volume methods) under
    # fracture propagation. The test is based on first discretizing, and then do one
    # or several fracture propagation steps. after each step, we do a partial
    # update of the discretization scheme, and compare with a full discretization on
    # the newly split grid. The test fails unless all discretization matrices generated
    # are identical.
    #
    # NOTE: Only the highest-dimensional grid in the MixedDimensionalGrid is used.
    # Get MixedDimensionalGrid and splitting schedule
    mdg, faces_to_split = geometry()
    sd_top = mdg.subdomains(dim=mdg.dim_max())[0]
    g_1, g_2 = mdg.subdomains(dim=1)
    # Make the splitting schedule on the format expected by fracture propagation
    split_faces = []
    for face in faces_to_split:
        split_faces.append({g_1: face[0], g_2: face[1]})
    def set_param(sd, data):
        # Helper method to set parameters.
        # For Mpfa and Mpsa, some of the data is redundant, but that should be fine;
        # it allows us to use a single parameter function
        data[pp.PARAMETERS] = {}
        data[pp.PARAMETERS]["flow"] = {
            "bc": pp.BoundaryCondition(sd),
            "bc_values": np.zeros(sd.num_faces),
            "second_order_tensor": pp.SecondOrderTensor(np.ones(sd.num_cells)),
            "biot_alpha": 1,
            "mass_weight": np.ones(sd.num_cells),
        }
        data[pp.PARAMETERS]["mechanics"] = {
            "bc": pp.BoundaryConditionVectorial(sd),
            "bc_values": np.zeros(sd.num_faces * sd.dim),
            "fourth_order_tensor": pp.FourthOrderTensor(
                np.ones(sd.num_cells), np.ones(sd.num_cells)
            ),
            "biot_alpha": 1,
        }
    # Populate parameters
    data = mdg.subdomain_data(sd_top)
    data[pp.DISCRETIZATION_MATRICES] = {"flow": {}, "mechanics": {}}
    set_param(sd_top, data)
    # Discretize
    method.discretize(sd_top, data)
    # Loop over propagation steps
    for split in split_faces:
        # Split the face
        pp.propagate_fracture.propagate_fractures(mdg, split)
        # Make parameters for the new grid
        data = mdg.subdomain_data(sd_top)
        set_param(sd_top, data)
        # Transfer information on new faces and cells from the format used
        # by self.evaluate_propagation to the format needed for update of
        # discretizations (see Discretization.update_discretization()).
        new_faces = data.get("new_faces", np.array([], dtype=int))
        split_faces = data.get("split_faces", np.array([], dtype=int))
        modified_faces = np.hstack((new_faces, split_faces))
        update_info = {
            "map_cells": data["cell_index_map"],
            "map_faces": data["face_index_map"],
            "modified_cells": data.get("new_cells", np.array([], dtype=int)),
            "modified_faces": modified_faces,
        }
        data["update_discretization"] = update_info
        # Update the discretization
        method.update_discretization(sd_top, data)
        # Create a new data dictionary, populate
        new_d = {}
        new_d[pp.DISCRETIZATION_MATRICES] = {"flow": {}, "mechanics": {}}
        set_param(sd_top, new_d)
        # Full discretization
        method.discretize(sd_top, new_d)
        # Compare discretization matrices
        for eq_type in ["flow", "mechanics"]:  # We know which keywords were used
            for key in data[pp.DISCRETIZATION_MATRICES][eq_type]:
                assert key in new_d[pp.DISCRETIZATION_MATRICES][eq_type]
            for key in new_d[pp.DISCRETIZATION_MATRICES][eq_type]:
                assert key in data[pp.DISCRETIZATION_MATRICES][eq_type]
            for key, mat in data[pp.DISCRETIZATION_MATRICES][eq_type].items():
                mat2 = new_d[pp.DISCRETIZATION_MATRICES][eq_type][key]
                assert mat.shape == mat2.shape
                diff = mat - mat2
                if diff.data.size > 0:
                    assert np.max(np.abs(diff.data)) < 1e-10