test_esipp_network.py

            # ValueError('The number of capacity values must match the number of
            # options.')

            arc_tech = Arcs(
                name="hey",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                static_loss=None,
                capacity=tuple(1 + o for o in range(number_options + 1)),
                minimum_cost=tuple(1 + o for o in range(number_options + 1)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                validate=True,
            )

            error_triggered = False
            try:
                arc_tech.validate_sizes(
                    number_options=number_options,
                    number_scenarios=number_scenarios,
                    number_intervals=[
                        number_time_intervals for _ in range(number_scenarios)
                    ],
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # ValueError: The minimum cost values are inconsistent with the number
            # of options.

            arc_tech = Arcs(
                name="hey",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                static_loss=None,
                capacity=tuple(1 + o for o in range(number_options + 1)),
                minimum_cost=tuple(1 + o for o in range(number_options + 1)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=capacity_is_instantaneous,
                validate=True,
            )

            error_triggered = False
            try:
                arc_tech.validate_sizes(
                    number_options=number_options,
                    number_scenarios=number_scenarios,
                    number_intervals=[
                        number_time_intervals for _ in range(number_scenarios)
                    ],
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('Efficiency values must be provided as numeric types.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency={
                        key: str(value) for key, value in efficiency_dict.items()
                    },
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options)),
                    minimum_cost=tuple(1 + o for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('Efficiency values must be positive.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency={
                        key: -value * random.randint(0, 1)
                        for key, value in efficiency_dict.items()
                    },
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options)),
                    minimum_cost=tuple(1 + o for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('Capacity values must be provided as numeric types.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(str(1 + o) for o in range(number_options)),
                    minimum_cost=tuple(1 + o for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('Capacity values must be positive.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(
                        -random.randint(0, 1) for o in range(number_options)
                    ),
                    minimum_cost=tuple(1 + o for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

            # TypeError('Minimum cost values must be provided as numeric types.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options)),
                    minimum_cost=tuple(str(1 + o) for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except TypeError:
                error_triggered = True
            assert error_triggered

            # ValueError('Minimum cost values must be positive or zero.')

            error_triggered = False
            try:
                _ = Arcs(
                    name="hey",
                    efficiency=efficiency_dict,
                    efficiency_reverse=None,
                    static_loss=None,
                    capacity=tuple(1 + o for o in range(number_options)),
                    minimum_cost=tuple(-1 for o in range(number_options)),
                    specific_capacity_cost=1,
                    capacity_is_instantaneous=capacity_is_instantaneous,
                    validate=True,
                )
            except ValueError:
                error_triggered = True
            assert error_triggered

        # TypeError('The information about capacities being instantaneous or not
        # should be given as a boolean variable.')

        error_triggered = False
        try:
            _ = Arcs(
                name="hey",
                efficiency=efficiency_dict,
                efficiency_reverse=None,
                static_loss=None,
                capacity=tuple(1 + o for o in range(number_options)),
                minimum_cost=tuple(1 + o for o in range(number_options)),
                specific_capacity_cost=1,
                capacity_is_instantaneous=1,
                validate=True,
            )
        except TypeError:
            error_triggered = True
        assert error_triggered

        # *********************************************************************
        # *********************************************************************

        # Network

        arc_tech_AB = Arcs(
            name="AB",
            efficiency=efficiency_dict,
            efficiency_reverse=None,
            static_loss=None,
            capacity=tuple(1 + o for o in range(number_options)),
            minimum_cost=tuple(1 + o for o in range(number_options)),
            specific_capacity_cost=1,
            capacity_is_instantaneous=False,
            validate=True,
        )

        arc_tech_AB.options_selected[0] = True

        assert arc_tech_AB.number_options() == number_options

        net = Network()

        # add undirected arc

        net.add_undirected_arc(node_key_a="A", node_key_b="B", arcs=arc_tech_AB)

        # add directed arc

        net.add_directed_arc(node_key_a="A", node_key_b="B", arcs=arc_tech_AB)

        # add infinite capacity arc

        net.add_infinite_capacity_arc(
            node_key_a="C",
            node_key_b="D",
            efficiency={(i, j): 1 for i in range(3) for j in range(4)},
            static_loss=None,
        )

        # add pre-existing directed arc

        net.add_preexisting_directed_arc(
            node_key_a="E",
            node_key_b="F",
            efficiency=efficiency_dict,
            static_loss=None,
            capacity=3,
            capacity_is_instantaneous=True,
        )

        # add pre-existing undirected arc

        net.add_preexisting_undirected_arc(
            node_key_a="A",
            node_key_b="C",
            efficiency=efficiency_dict,
            efficiency_reverse=efficiency_dict,
            static_loss=None,
            capacity=3,
            capacity_is_instantaneous=True,
        )

        net.modify_network_arc(
            node_key_a="A",
            node_key_b="C",
            arc_key_ab="AC",
            data_dict={net.KEY_ARC_TECH: arc_tech_AB, net.KEY_ARC_UND: False},
        )

        # *********************************************************************
        # *********************************************************************

        # add import node

        imp_resource_price = ResourcePrice(
            prices=[random.random() for k in range(number_time_intervals)],
            volumes=[
                *[random.random() for k in range(number_time_intervals - 1)],
                None,
            ],
        )

        net.add_import_node(node_key="G", prices={(0, 0, 0): imp_resource_price})

        # add export node

        exp_resource_price = ResourcePrice(
            prices=[random.random() for k in range(number_time_intervals)],
            volumes=[
                *[random.random() for k in range(number_time_intervals - 1)],
                None,
            ],
        )

        net.add_export_node(node_key="H", prices={(0, 0, 0): exp_resource_price})

        net.add_waypoint_node(node_key="Z")

        base_flow = {(i, j): random.random() for i in range(3) for j in range(4)}

        net.add_source_sink_node(node_key="Y", base_flow=base_flow)

        base_flow[(2, 3)] = random.random()

        net.modify_network_node(
            node_key="Y", node_data={net.KEY_NODE_BASE_FLOW: base_flow}
        )

        net.identify_node_types()

        assert "Z" in net.waypoint_nodes

        assert "G" in net.import_nodes

        assert "H" in net.export_nodes

        assert "Y" in net.source_sink_nodes

    # *************************************************************************
    # *************************************************************************

    def test_arcs_without_losses(self):
        # test arc without (static and proportional) losses

        arc_tech = ArcsWithoutLosses(
            name="AB",
            capacity=(1, 2, 3),
            minimum_cost=(4, 5, 6),
            specific_capacity_cost=6,
            capacity_is_instantaneous=False,
            validate=True,
        )

        assert not arc_tech.has_proportional_losses()

        assert not arc_tech.has_static_losses()

        assert not arc_tech.is_infinite_capacity()

        assert arc_tech.has_constant_efficiency()

        # test arc without static losses

        arc_tech = ArcsWithoutStaticLosses(
            name="AB",
            efficiency={(0, 0): 1, (0, 1): 0.9, (0, 2): 0.8},
            efficiency_reverse=None,
            capacity=(1, 2, 3),
            minimum_cost=(4, 5, 6),
            specific_capacity_cost=6,
            capacity_is_instantaneous=False,
            validate=True,
        )

        assert arc_tech.has_proportional_losses()

        assert not arc_tech.has_static_losses()

        assert not arc_tech.is_infinite_capacity()

        assert not arc_tech.has_constant_efficiency()

        # test arc without proportional losses

        arc_tech = ArcsWithoutProportionalLosses(
            name="AB",
            static_loss={
                (0, 0, 0): 0.1,
                (0, 0, 1): 0.2,
                (0, 0, 2): 0.3,
                (1, 0, 0): 0.15,
                (1, 0, 1): 0.25,
                (1, 0, 2): 0.35,
                (2, 0, 0): 0.16,
                (2, 0, 1): 0.26,
                (2, 0, 2): 0.36,
            },
            capacity=(1, 2, 3),
            minimum_cost=(4, 5, 6),
            specific_capacity_cost=6,
            capacity_is_instantaneous=False,
            validate=True,
        )

        assert not arc_tech.has_proportional_losses()

        assert arc_tech.has_static_losses()

        assert not arc_tech.is_infinite_capacity()

        assert arc_tech.has_constant_efficiency()

    # *************************************************************************
    # *************************************************************************

    def test_modifying_nodes(self):
        # *********************************************************************

        net = Network()

        number_intervals = 3

        resource_price = ResourcePrice(
            prices=[random.random() for k in range(number_intervals)],
            volumes=[*[random.random() for k in range(number_intervals - 1)], None],
        )

        base_flow = {(0, k): random.random() for k in range(number_intervals)}

        arc_tech = ArcsWithoutLosses(
            name="hello",
            capacity=[5],
            minimum_cost=[3],
            specific_capacity_cost=3,
            capacity_is_instantaneous=False,
        )

        # add isolated import node

        net.add_import_node(node_key="I_iso", prices={(0, 0, 0): resource_price})

        # add import node with outgoing arcs

        net.add_import_node(node_key="I", prices={(0, 0, 0): resource_price})

        # add isolated export node

        net.add_import_node(node_key="E_iso", prices={(0, 0, 0): resource_price})

        # add export node with incoming arcs

        net.add_export_node(node_key="E", prices={(0, 0, 0): resource_price})

        # add isolated normal node

        net.add_source_sink_node(node_key="A_iso", base_flow=base_flow)

        # add normal node with incoming arcs

        net.add_source_sink_node(node_key="A_in", base_flow=base_flow)

        # add normal node with outgoing arcs

        net.add_source_sink_node(node_key="A_out", base_flow=base_flow)

        # add normal node with incoming and outgoing arcs

        net.add_source_sink_node(node_key="A", base_flow=base_flow)

        # *********************************************************************

        # arcs

        net.add_directed_arc(node_key_a="I", node_key_b="A_in", arcs=arc_tech)

        net.add_directed_arc(node_key_a="I", node_key_b="A", arcs=arc_tech)

        net.add_directed_arc(node_key_a="A_out", node_key_b="E", arcs=arc_tech)

        net.add_directed_arc(node_key_a="A", node_key_b="E", arcs=arc_tech)

        # *********************************************************************

        # change I_iso to regular: okay

        net.modify_network_node(
            node_key="I_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="I_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change I_iso to export: okay

        net.modify_network_node(
            node_key="I_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="I_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change I_iso to waypoint: okay

        net.modify_network_node(
            node_key="I_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="I_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # *********************************************************************

        # change E_iso to regular: okay

        net.modify_network_node(
            node_key="E_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="E_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change E_iso to import: okay

        net.modify_network_node(
            node_key="E_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="E_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change E_iso to waypoint: okay

        net.modify_network_node(
            node_key="E_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="E_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # *********************************************************************

        # change A_iso to export: okay

        net.modify_network_node(
            node_key="A_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # change A_iso to import: okay

        net.modify_network_node(
            node_key="A_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # change A_iso to waypoint: okay

        net.modify_network_node(
            node_key="A_iso", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_iso",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # *********************************************************************

        # change I to regular: okay

        net.modify_network_node(
            node_key="I",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="I",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change I to waypoint: okay

        net.modify_network_node(
            node_key="I", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="I",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # *********************************************************************

        # change E to regular: okay

        net.modify_network_node(
            node_key="E",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="E",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # change E to waypoint: okay

        net.modify_network_node(
            node_key="E", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="E",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # *********************************************************************

        # change A_in to export: okay

        net.modify_network_node(
            node_key="A_in",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_in",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # change A_in to waypoint: okay

        net.modify_network_node(
            node_key="A_in", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_in",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # *********************************************************************

        # change A_out to import: okay

        net.modify_network_node(
            node_key="A_out",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                net.KEY_NODE_PRICES: resource_price,
            },
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_out",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # change A_out to waypoint: okay

        net.modify_network_node(
            node_key="A_out", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
        )

        # reverse: okay

        net.modify_network_node(
            node_key="A_out",
            node_data={
                net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_SOURCE_SINK,
                net.KEY_NODE_BASE_FLOW: base_flow,
            },
        )

        # *********************************************************************

        # change I to export: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="I",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # change E to import: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="E",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # change A_out to export: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="A_out",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # change A_in to import: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="A_in",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # change A to export: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="A",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_EXP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # change A to import: fail

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="A",
                node_data={
                    net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_IMP,
                    net.KEY_NODE_PRICES: resource_price,
                },
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # *********************************************************************

        # try to modify a non-existent node

        error_triggered = False
        try:
            net.modify_network_node(
                node_key="ABCD", node_data={net.KEY_NODE_TYPE: net.KEY_NODE_TYPE_WAY}
            )
        except ValueError:
            error_triggered = True
        assert error_triggered

        # *********************************************************************

    # *************************************************************************
    # *************************************************************************

    def test_network_disallowed_cases(self):

        net = Network()

        number_intervals = 3

        resource_price = ResourcePrice(
            prices=[random.random() for k in range(number_intervals)],
            volumes=[*[random.random() for k in range(number_intervals - 1)], None],
        )

        base_flow = {(0, k): random.random() for k in range(number_intervals)}

        lossless_arcs = ArcsWithoutLosses(
            name="hello",
            capacity=[5],
            minimum_cost=[3],
            specific_capacity_cost=3,
            capacity_is_instantaneous=False,
        )

        lossy_arcs = ArcsWithoutProportionalLosses(
            name="hello back",
            static_loss={(0, 0, k): random.random() for k in range(number_intervals)},
            capacity=(1,),
            minimum_cost=(5,),
            specific_capacity_cost=0,
            capacity_is_instantaneous=False,
        )

        # add import node I

        net.add_import_node(node_key="I", prices={(0, 0, 0): resource_price})

        # add export node E

        net.add_export_node(node_key="E", prices={(0, 0, 0): resource_price})

        # add regular node A

        net.add_source_sink_node(node_key="A", base_flow=base_flow)

        # add regular node B

        net.add_source_sink_node(node_key="B", base_flow=base_flow)

        # add a valid import-export arc

        net.add_directed_arc(node_key_a="I", node_key_b="E", arcs=lossless_arcs)

        # identify the nodes and validate

        net.identify_node_types()

        # *********************************************************************
        # *********************************************************************

        # trigger errors using pre-identified nodes

        # directed arcs cannot start in an export node: E -> B

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="E", node_key_b="B", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # directed arcs cannot end on an import node: A -> I

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="A", node_key_b="I", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # import-export nodes cannot have static losses

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="I", node_key_b="E", arcs=lossy_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # undirected arcs cannot involve import nor export nodes

        error_triggered = False
        try:
            net.add_undirected_arc(node_key_a="I", node_key_b="A", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # undirected arcs cannot involve import nor export nodes

        error_triggered = False
        try:
            net.add_undirected_arc(node_key_a="B", node_key_b="E", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # undirected arcs cannot involve import nor export nodes