def test_probe_building_disabled(self, recwarn): """Test that build methods are not called and that a warning is raised if probe building is disabled. """ # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) p_a = nengo.Probe(a, label="Output") # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define a probe build function build_ens_probe = mock.Mock() # Build the model probe_builders = {nengo.Ensemble: build_ens_probe} with patch.object(model, "builders", new={nengo.Ensemble: ens_build}),\ patch.object(model, "probe_builders", new=probe_builders): model.build(network, build_probes=False) # Assert the probes were NOT built assert p_a not in model.seeds assert build_ens_probe.call_count == 0 # And that a warning was raised w = recwarn.pop() assert "Probes" in str(w.message) assert "disabled" in str(w.message)
def test_removes_sinkless_filters(self): """Test that making a netlist correctly filters out passthrough Nodes with no outgoing connections. """ # Create the first operator object_a = mock.Mock(name="object A") vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator object_b = mock.Mock(name="object B") operator_b = operators.Filter(16) # Shouldn't need building # Create the model, add the items and add an entry to the connection # map. model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection( operator_a, None, SignalParameters(), None, operator_b, None, None ) netlist = model.make_netlist(1) # The netlist should contain vertex a and no nets assert netlist.nets == list() assert netlist.vertices == [vertex_a]
def test_make_connection_no_signal(self, source_getter, sink_getter): """Test that building connections adds a new signal to the model.""" model = Model() class A(object): pass # Create a connection from a to b connection = mock.Mock() connection.pre_obj = A() connection.post_obj = A() # Create a mock network network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Patch the getters, add a null builder with patch.object(model, "source_getters", {A: source_getter}), \ patch.object(model, "sink_getters", {A: sink_getter}), \ patch.object(model, "connection_parameter_builders", {A: mock.Mock()}): # Build the network model.build(network) # Assert that no signal exists assert connection not in model.connections_signals
def test_remove_sinkless_signals(): """Signals with no sink should be removed.""" # Create a netlist including some signals with no sinks, these signals # should be removed. o1 = mock.Mock(name="O1") o2 = mock.Mock(name="O2") # Create 4 signals (2 associated with connections, 2 not) cs1 = Signal(ObjectPort(o1, None), ObjectPort(o2, None), None) cs2 = Signal(ObjectPort(o1, None), [], None) ss1 = Signal(ObjectPort(o1, None), ObjectPort(o2, None), None) ss2 = Signal(ObjectPort(o1, None), [], None) # Create two mock connections c1 = mock.Mock(name="Connection 1") c2 = mock.Mock(name="Connection 2") # Create the model model = Model() model.extra_operators = [o1, o2] model.connections_signals = {c1: cs1, c2: cs2} model.extra_signals = [ss1, ss2] # Remove sinkless signals remove_sinkless_signals(model) # Check that signals were removed as necessary assert model.connections_signals == {c1: cs1} assert model.extra_signals == [ss1]
def test_removes_sinkless_filters(self): """Test that making a netlist correctly filters out passthrough Nodes with no outgoing connections. """ # Create the first operator object_a = mock.Mock(name="object A") vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator object_b = mock.Mock(name="object B") operator_b = operators.Filter(16) # Shouldn't need building # Create the model, add the items and add an entry to the connection # map. model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection(operator_a, None, SignalParameters(), None, operator_b, None, None) netlist = model.make_netlist(1) # The netlist should contain vertex a and no nets assert netlist.nets == list() assert netlist.vertices == [vertex_a]
def test_builds_hierarchy(self): """Test that networks are built hierarchically. """ class A(object): seed = 101 class B(object): pass builders = {A: mock.Mock()} extra_builders = {B: mock.Mock()} a = A() b = B() network_a = mock.Mock() network_a.seed = None network_a.connections = [] network_a.ensembles = [a] network_a.nodes = [] network_a.networks = [] network_a.probes = [] network_a.config = mock.Mock(name="config") network_b = mock.Mock() network_b.seed = None network_b.connections = [] network_b.ensembles = [] network_b.nodes = [b] network_b.networks = [] network_b.probes = [] network_b.config = mock.Mock(name="config") network = mock.Mock() network.seed = None network.connections = [] network.ensembles = [] network.nodes = [] network.networks = [network_a, network_b] network.probes = [] network.config = mock.Mock(name="config") # Patch the default builders with patch.object(Model, "builders", new=builders): # Create a model and build the mock network model = Model() model.build(network, extra_builders=extra_builders) # Assert that the config was stored in the model assert model.config is network.config # Assert that seeds were supplied assert model.seeds[a] == a.seed assert model.seeds[b] is not None # Assert the builders got called builders[A].assert_called_once_with(model, a) extra_builders[B].assert_called_once_with(model, b)
def test_single_vertices(self): """Test that operators which produce single vertices work correctly and that all functions and signals are correctly collected and included in the final netlist. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec(vertex_b, load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connections_signals[None] = signal_ab netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b] assert net.keyspace is keyspace assert net.weight == signal_ab.weight assert set(netlist.vertices) == set([vertex_a, vertex_b]) assert netlist.keyspaces is model.keyspaces assert netlist.groups == list() assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_extra_operators_and_signals(self): """Test the operators and signals in the extra_operators and extra_signals lists are included when building netlists. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec(vertex_b, load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.extra_operators = [operator_a, operator_b] model.extra_signals = [signal_ab] netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b] assert net.keyspace is keyspace assert net.weight == signal_ab.weight assert set(netlist.vertices) == set([vertex_a, vertex_b]) assert netlist.keyspaces is model.keyspaces assert netlist.groups == list() assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_make_vertices(self): """Check that the SDPReceiver make_vertices method looks at the signals and connections to make one sdp-rx vertex per outgoing connection and stores these as dictionaries. """ # Create the SDPReceiver, check that it currently has no connections # mapped to vertices. sdp_rx = SDPReceiver() assert sdp_rx.connection_vertices == dict() # Create a model containing some signals and connections originating # from sdp_rx, when calling make_vertices check that one vertex is # created per connection and that the dictionary is updated # accordingly. model = Model() conn_a = mock.Mock(name="connection a") conn_a.size_out = 1 conn_a.post_slice = slice(0, 1) conn_a.post_obj.size_in = 3 ks_a = model.keyspaces["nengo"](object=0, connection=0) sig_a = Signal(ObjectPort(sdp_rx, OutputPort.standard), None, ks_a) conn_b = mock.Mock(name="connection b") conn_b.size_out = 2 conn_b.post_slice = slice(None) conn_b.post_obj.size_in = 2 ks_b = model.keyspaces["nengo"](object=0, connection=1) sig_b = Signal(ObjectPort(sdp_rx, OutputPort.standard), None, ks_b) model.connections_signals = { conn_a: sig_a, conn_b: sig_b, } model.params[conn_a] = mock.Mock() model.params[conn_a].transform = np.eye(conn_a.size_out) model.params[conn_b] = mock.Mock() model.params[conn_b].transform = np.eye(conn_b.size_out) # Make the vertices nls = sdp_rx.make_vertices(model, 1) # TODO Remove number of steps assert len(nls.vertices) == 2 assert nls.load_function == sdp_rx.load_to_machine for conn, vx in six.iteritems(sdp_rx.connection_vertices): print(conn, vx) assert conn is conn_a or conn is conn_b assert vx in nls.vertices assert vx.resources[Cores] == 1 assert vx.resources[SDRAM] == 3*4 + 2*4 + 4*conn.size_out assert sdp_rx._sys_regions[vx].size_out == conn.size_out assert vx in sdp_rx._key_regions
def test_builder_dictionaries_are_combined(self, use_make_object): """Test that the builder and extra_builders dictionaries are combined and that a mrolookupdict is used. """ class A(object): seed = 101 class B(object): pass builders = {A: mock.Mock()} extra_builders = {B: mock.Mock()} a = A() b = B() network = mock.Mock() network.seed = None network.connections = [] network.ensembles = [a] network.nodes = [b] network.networks = [] network.probes = [] network.config = mock.Mock(name="config") if not use_make_object: # Patch the default builders with patch.object(Model, "builders", new=builders): # Create a model and build the mock network model = Model() model.build(network, extra_builders=extra_builders) # Assert that the config was stored in the model assert model.config is network.config else: # Create the model model = Model() model.rng = np.random # When using `make_object` directly `_builders` should be defined # and used. model._builders.update(builders) model._builders.update(extra_builders) # Build the objects model.make_object(a) model.make_object(b) # Assert that seeds were supplied assert model.seeds[a] == a.seed assert model.seeds[b] is not None # Assert the builders got called builders[A].assert_called_once_with(model, a) extra_builders[B].assert_called_once_with(model, b)
def test_standard(self, use_arguments, with_slice): # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) if not with_slice: p_a = nengo.Probe(a) else: p_a = nengo.Probe(a[0]) p_n = nengo.Probe(a.neurons) # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define two different probe build functions def build_ens_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_a build_ens_probe = mock.Mock(wraps=build_ens_probe_fn) def build_neurons_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_n build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn) # Build the model probe_builders = {nengo.Ensemble: build_ens_probe, nengo.ensemble.Neurons: build_neurons_probe} with patch.object(model, "builders", new={nengo.Ensemble: ens_build}): if not use_arguments: with patch.object(model, "probe_builders", new=probe_builders): model.build(network) else: with patch.object(model, "probe_builders", new={}): model.build(network, extra_probe_builders=probe_builders) # Assert the probe functions were built assert p_a in model.seeds assert p_n in model.seeds assert build_ens_probe.call_count == 1 assert build_neurons_probe.call_count == 1
def test_calls_add_default_keyspace(self): """Test that creating a netlist assigns from default keyspace to the network. """ # Create a model and patch out the default keyspace and the connection # map. default_ks = mock.Mock() model = Model(keyspaces={"nengo": default_ks}) # Create the netlist, ensure that this results in a call to # `add_default_keyspace' with mock.patch.object(model.connection_map, "add_default_keyspace") as f: model.make_netlist() f.assert_called_once_with(default_ks)
def test_source_is_none(self, no_source, no_sink): """Test that if either the source or sink is none no connection is added to the model. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") obj = mock.Mock(name="Object") obj_port = mock.Mock(name="Port") # Add some build methods m._source_getters = ({ A: lambda m, c: None } if no_source else { A: lambda m, c: ObjectPort(obj, obj_port) }) m._sink_getters = ({ A: lambda m, c: None } if no_sink else { A: lambda m, c: ObjectPort(obj, obj_port) }) m._transmission_parameter_builders = {A: lambda m, c: None} m._reception_parameter_builders = {A: lambda m, c: None} # Make the connection # Set an RNG to build with m.rng = np.random # Build the connection directly m.make_connection(connection) # Assert no call was made to add_connection assert not m.connection_map.add_connection.called
def test_multiple_sink_vertices(self): # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A") operator_a.make_vertices.return_value = \ netlistspec(vertex_a, load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b0 = mock.Mock(name="vertex B0") vertex_b1 = mock.Mock(name="vertex B1") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B") operator_b.make_vertices.return_value = \ netlistspec([vertex_b0, vertex_b1], load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab = Signal(ObjectPort(operator_a, None), ObjectPort(operator_b, None), keyspace=keyspace, weight=3) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connections_signals[None] = signal_ab netlist = model.make_netlist() # Check that the netlist is as expected assert set(netlist.vertices) == set([vertex_a, vertex_b0, vertex_b1]) assert len(netlist.nets) == 1 for net in netlist.nets: assert net.source is vertex_a assert net.sinks == [vertex_b0, vertex_b1] assert net.keyspace is keyspace assert net.weight == signal_ab.weight # Check that the groups are correct assert netlist.groups == [set([vertex_b0, vertex_b1])]
def test_extra_operators_and_signals(self): """Test the operators in the extra_operators list are included when building netlists. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec((vertex_a, ), load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec((vertex_b, ), load_fn_b) # Create the model, add the items and then generate the netlist model = Model() model.extra_operators = [operator_a, operator_b] netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 0 assert netlist.operator_vertices == { operator_a: (vertex_a, ), operator_b: (vertex_b, ), } assert netlist.keyspaces is model.keyspaces assert len(netlist.constraints) == 0 assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_model_init(): """Test initialising a model, should be completely empty.""" model = Model() assert model.dt == 0.001 assert model.machine_timestep == 1000 assert model.params == dict() assert model.seeds == dict() assert dict(model.object_operators) == dict() assert model.extra_operators == list() assert isinstance(model.decoder_cache, NoDecoderCache) assert len(model.keyspaces) == 1
def test_get_object_and_connection_id(): """Test retrieving an object and a connection ID.""" obj_a = mock.Mock(name="object a") conn_a0 = mock.Mock(name="connection a[0]") conn_a1 = mock.Mock(name="connection a[0]") obj_b = mock.Mock(name="object b") conn_b0 = mock.Mock(name="connection b[0]") # Create an empty model model = Model() # The first connection from the first object should get (0, 0), no matter # how many times we ask assert (0, 0) == model._get_object_and_connection_id(obj_a, conn_a0) # The second connection from the first object should get (0, 1) assert (0, 1) == model._get_object_and_connection_id(obj_a, conn_a1) assert (0, 0) == model._get_object_and_connection_id(obj_a, conn_a0) # The first connection from the second object should get (1, 0) assert (1, 0) == model._get_object_and_connection_id(obj_b, conn_b0) assert (0, 1) == model._get_object_and_connection_id(obj_a, conn_a1) assert (0, 0) == model._get_object_and_connection_id(obj_a, conn_a0)
def test_source_is_none(self, no_source, no_sink): """Test that if either the source or sink is none no connection is added to the model. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") obj = mock.Mock(name="Object") obj_port = mock.Mock(name="Port") # Add some build methods m._source_getters = ({A: lambda m, c: None} if no_source else {A: lambda m, c: ObjectPort(obj, obj_port)}) m._sink_getters = ({A: lambda m, c: None} if no_sink else {A: lambda m, c: ObjectPort(obj, obj_port)}) m._transmission_parameter_builders = {A: lambda m, c: None} m._reception_parameter_builders = {A: lambda m, c: None} # Make the connection # Set an RNG to build with m.rng = np.random # Build the connection directly m.make_connection(connection) # Assert no call was made to add_connection assert not m.connection_map.add_connection.called
def test_latching(self, make_source_spec, make_sink_spec): """Test that latching commands are taken from the spec. """ # Create the model with it's default keyspace model = Model() model.keyspaces = {"nengo": mock.Mock()} # Create the connection that we're building pre = mock.Mock("pre") post = mock.Mock("post") post.size_in = 5 connection = mock.Mock(spec_set=nengo.Connection) connection.pre_obj = pre connection.post_obj = post # Create a spec for the source and a spec for the sink source_obj = mock.Mock() source_spec = make_source_spec(source_obj) sink_obj = mock.Mock() sink_spec = make_sink_spec(sink_obj) # Get the Signal signal = _make_signal(model, connection, source_spec, sink_spec) assert signal.latching is True
def test_standard(self, use_arguments, with_slice): # Create test network with nengo.Network() as network: a = nengo.Ensemble(100, 2) if not with_slice: p_a = nengo.Probe(a) else: p_a = nengo.Probe(a[0]) p_n = nengo.Probe(a.neurons) # Create a model model = Model() # Dummy neurons builder ens_build = mock.Mock(name="ensemble builder") # Define two different probe build functions def build_ens_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_a build_ens_probe = mock.Mock(wraps=build_ens_probe_fn) def build_neurons_probe_fn(model, probe): assert ens_build.called assert model is model assert probe is p_n build_neurons_probe = mock.Mock(wraps=build_neurons_probe_fn) # Build the model probe_builders = { nengo.Ensemble: build_ens_probe, nengo.ensemble.Neurons: build_neurons_probe } with patch.object(model, "builders", new={nengo.Ensemble: ens_build}): if not use_arguments: with patch.object(model, "probe_builders", new=probe_builders): model.build(network) else: with patch.object(model, "probe_builders", new={}): model.build(network, extra_probe_builders=probe_builders) # Assert the probe functions were built assert p_a in model.seeds assert p_n in model.seeds assert build_ens_probe.call_count == 1 assert build_neurons_probe.call_count == 1
def test_generic_sink_getter(): """Test the generic sink object getter, this should just return the object that is associated with the connection pre_obj. """ # Create the connection conn = mock.Mock(name="connection", spec_set=["pre_obj", "post_obj"]) conn.pre_obj = mock.Mock(name="pre object") conn.post_obj = mock.Mock(name="post object") # Create the model pre_int = mock.Mock(name="pre intermediate") post_int = mock.Mock(name="post intermediate") model = Model() model.object_operators[conn.pre_obj] = pre_int model.object_operators[conn.post_obj] = post_int # Get the sink spec = generic_sink_getter(model, conn) assert spec.target.obj is post_int assert spec.target.port is InputPort.standard
def test_standard(self, use_make_connection): """Test building a single connection, ensure that all appropriate methods are called and that the signal is added to the connection map. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") m.connection_map.insert_and_stack_interposers = mock.Mock( return_value=([], m.connection_map) # NOP ) source = mock.Mock(name="Source Object") source_port = mock.Mock(name="Source Port") sink = mock.Mock(name="Sink Object") sink_port = mock.Mock(name="Sink Port") # Add some build methods def source_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(source, source_port)) def sink_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(sink, sink_port)) source_getters = {A: mock.Mock(side_effect=source_getter)} sink_getters = {A: mock.Mock(side_effect=sink_getter)} transmission_parameters = mock.Mock(name="Transmission Params") def transmission_builder(model, conn): assert model is m assert conn is connection return transmission_parameters reception_parameters = mock.Mock(name="Reception Params") def reception_builder(model, conn): assert model is m assert conn is connection return reception_parameters transmission_parameter_builders = { A: mock.Mock(side_effect=transmission_builder) } reception_parameter_builders = { A: mock.Mock(side_effect=reception_builder) } # Make the connection if use_make_connection: # Set an RNG to build with m.rng = np.random # Set the builders m._source_getters = source_getters m._sink_getters = sink_getters m._transmission_parameter_builders = \ transmission_parameter_builders m._reception_parameter_builders = reception_parameter_builders # Build the connection directly m.make_connection(connection) else: # Embed the connection in a mock Nengo network and build that # instead. network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Build this (having overridden the builders) with mock.patch.object(m, "source_getters", source_getters), \ mock.patch.object(m, "sink_getters", sink_getters), \ mock.patch.object(m, "transmission_parameter_builders", transmission_parameter_builders), \ mock.patch.object(m, "reception_parameter_builders", reception_parameter_builders): m.build(network) # Assert the connection map received an appropriate call m.connection_map.add_connection.assert_called_once_with( source, source_port, SignalParameters(), transmission_parameters, sink, sink_port, reception_parameters )
def test_remove_childless_filters(): """Filter operators which don't transmit to anything, and their incoming signals, can be removed. """ # Create a netlist including some filters that do and don't transmit to # other objects, check that all the filters which don't connect to anything # are removed. # # -S1--- F3 # / \ S4 ^ \ S5 # / v / v # F1 O1 +S3-> F2 F5 # ^ / | \ ^ # \ / | S4 v / S6 # \-S2--- v F4 # O2 # # F1 should remain, O1 and O2 should be untouched and F2..5 should be # removed. S1 and S2 should be unchanged, S3 should have F2 removed from # its sinks and S4..6 should be removed entirely. # Create the filter operators f1 = mock.Mock(name="F1", spec=Filter) f2 = mock.Mock(name="F2", spec=Filter) f3 = mock.Mock(name="F3", spec=Filter) f4 = mock.Mock(name="F4", spec=Filter) f5 = mock.Mock(name="F5", spec=Filter) # The other operator o1 = mock.Mock(name="O1") o2 = mock.Mock(name="O2") # Create some objects which map to some of the operators oo1 = mock.Mock() of3 = mock.Mock() # Create the signals s1 = Signal(ObjectPort(f1, None), ObjectPort(o1, None), None) s2 = Signal(ObjectPort(o1, None), ObjectPort(f1, None), None) s3 = Signal(ObjectPort(o1, None), [ObjectPort(f2, None), ObjectPort(o2, None)], None) s4 = Signal(ObjectPort(f2, None), [ObjectPort(f3, None), ObjectPort(f4, None)], None) s5 = Signal(ObjectPort(f3, None), ObjectPort(f5, None), None) s6 = Signal(ObjectPort(f4, None), ObjectPort(f5, None), None) # Create some connections which map to the signals cs4 = mock.Mock() cs5 = mock.Mock() # Create the model model = Model() model.object_operators = { oo1: o1, of3: f3, } model.extra_operators = [f1, f2, f4, f5] model.connections_signals = { cs4: s4, cs5: s5, } model.extra_signals = [s1, s2, s3, s6] # Perform the optimisation remove_childless_filters(model) # Check that objects have been removed assert model.object_operators == {oo1: o1} assert model.extra_operators == [f1] assert model.connections_signals == {} assert model.extra_signals == [s1, s2, s3] assert [s.obj for s in s3.sinks] == [o2]
def test_get_signals_and_connections_terminating_at(self): """Test getting the signals and connections which end at a given object. """ # Create some objects and some connections obj_a = mock.Mock(name="object a") obj_b = mock.Mock(name="object b") conn_ab1 = mock.Mock() port_b1 = mock.Mock(name="port B1") sig_ab1 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b1), None) conn_ab2 = mock.Mock() port_b2 = mock.Mock(name="port B2") sig_ab2 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b2), None) sig_ab3 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, port_b2), None) conn_ba1 = mock.Mock() sig_ba1 = Signal(ObjectPort(obj_b, OutputPort.standard), ObjectPort(obj_a, InputPort.standard), None) conn_ba2 = mock.Mock() conn_ba3 = mock.Mock() sig_ba2 = Signal(ObjectPort(obj_b, port_b2), ObjectPort(obj_a, InputPort.standard), None) # Create a model holding all of these items model = Model() model.connections_signals = { conn_ab1: sig_ab1, conn_ab2: sig_ab2, conn_ba1: sig_ba1, conn_ba2: sig_ba2, conn_ba3: sig_ba2, } model.extra_signals = [sig_ab3] # Query it for connections terminating at different objects for port, sigs_conns in iteritems( model.get_signals_connections_to_object(obj_a)): assert port is InputPort.standard for sig, conns in iteritems(sigs_conns): if sig is sig_ba1: assert conns == [conn_ba1] elif sig is sig_ba2: for conn in conns: assert conn in [conn_ba2, conn_ba3] elif sig is sig_ba3: assert len(conns) == 0 else: assert False, "Unexpected signal" assert model.get_signals_connections_to_object(obj_b) == { port_b1: { sig_ab1: [conn_ab1], }, port_b2: { sig_ab2: [conn_ab2], sig_ab3: [], }, }
def test_multiple_source_vertices(self): """Test that each of the vertices associated with a source is correctly included in the sources of a net. """ class MyVertexSlice(VertexSlice): def __init__(self, *args, **kwargs): super(MyVertexSlice, self).__init__(*args, **kwargs) self.args = None def transmits_signal(self, signal_parameters, transmission_parameters): self.args = (signal_parameters, transmission_parameters) return False # Create the first operator vertex_a0 = VertexSlice(slice(0, 1)) vertex_a1 = VertexSlice(slice(1, 2)) vertex_a2 = MyVertexSlice(slice(2, 3)) load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec([vertex_a0, vertex_a1, vertex_a2], load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = Vertex() load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec((vertex_b, ), load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection(operator_a, None, signal_ab_parameters, None, operator_b, None, None) netlist = model.make_netlist() # Check that the netlist is as expected assert netlist.operator_vertices == { operator_a: (vertex_a0, vertex_a1, vertex_a2), operator_b: (vertex_b, ), } assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a0, vertex_a1] assert net.sinks == [vertex_b] assert len(netlist.constraints) == 0 # Check that `transmit_signal` was called correctly sig, tp = vertex_a2.args assert sig.keyspace is keyspace assert tp is None
def test_single_vertices(self): """Test that operators which produce single vertices work correctly and that all functions and signals are correctly collected and included in the final netlist. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") constraint_a = mock.Mock(name="Constraint B") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec((vertex_a, ), load_fn_a, pre_fn_a, post_fn_a, constraint_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") constraint_b = mock.Mock(name="Constraint B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec((vertex_b, ), load_fn_b, constraints=[constraint_b]) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection(operator_a, None, signal_ab_parameters, None, operator_b, None, None) netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a] assert net.sinks == [vertex_b] assert net.weight == signal_ab_parameters.weight assert netlist.operator_vertices == { operator_a: (vertex_a, ), operator_b: (vertex_b, ), } assert netlist.keyspaces is model.keyspaces assert set(netlist.constraints) == set([constraint_a, constraint_b]) assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_get_signals_and_connections_starting_from(self): """Test getting the signals and connections which start from a given object. """ # Create some objects and some connections obj_a = mock.Mock(name="object a") obj_b = mock.Mock(name="object b") conn_ab1 = mock.Mock() sig_ab1 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) conn_ab2 = mock.Mock() sig_ab2 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) sig_ab3 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) sig_ab4 = Signal(ObjectPort(obj_a, OutputPort.standard), ObjectPort(obj_b, InputPort.standard), None) conn_ba1 = mock.Mock() port_b1 = mock.Mock(name="port B1") sig_ba1 = Signal(ObjectPort(obj_b, port_b1), ObjectPort(obj_a, InputPort.standard), None) conn_ba2 = mock.Mock() conn_ba3 = mock.Mock() port_b2 = mock.Mock(name="port B2") sig_ba2 = Signal(ObjectPort(obj_b, port_b2), ObjectPort(obj_a, InputPort.standard), None) port_b3 = mock.Mock(name="port B3") sig_ba3 = Signal(ObjectPort(obj_b, port_b3), ObjectPort(obj_a, InputPort.standard), None) # Create a model holding all of these items model = Model() model.connections_signals = { conn_ab1: sig_ab1, conn_ab2: sig_ab2, conn_ba1: sig_ba1, conn_ba2: sig_ba2, conn_ba3: sig_ba2, } model.extra_signals = [sig_ab3, sig_ab4, sig_ba3] # Query it for connections starting from different objects assert model.get_signals_connections_from_object(obj_a) == { OutputPort.standard: { sig_ab1: [conn_ab1], sig_ab2: [conn_ab2], sig_ab3: [], sig_ab4: [], }, } for port, sigs_conns in iteritems( model.get_signals_connections_from_object(obj_b)): if port is port_b1: assert sigs_conns == { sig_ba1: [conn_ba1], } elif port is port_b2: for sig, conns in iteritems(sigs_conns): assert sig is sig_ba2 for conn in conns: assert conn is conn_ba2 or conn is conn_ba3 elif port is port_b3: assert sigs_conns == {sig_ba3: []} else: assert False, "Unexpected signal"
def test_standard(self, use_make_connection): """Test building a single connection, ensure that all appropriate methods are called and that the signal is added to the connection map. """ class A(object): pass # Create the connection (as a mock) connection_source = A() connection_sink = A() connection = mock.Mock() connection.pre_obj = connection_source connection.post_obj = connection_sink # Create the Model which we'll build with m = Model() # Modify the Model so that we can interpret calls to the connection map m.connection_map = mock.Mock(name="ConnectionMap") m.connection_map.insert_and_stack_interposers = mock.Mock( return_value=([], m.connection_map) # NOP ) source = mock.Mock(name="Source Object") source_port = mock.Mock(name="Source Port") sink = mock.Mock(name="Sink Object") sink_port = mock.Mock(name="Sink Port") # Add some build methods def source_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(source, source_port)) def sink_getter(model, conn): assert model is m assert conn is connection return spec(ObjectPort(sink, sink_port)) source_getters = {A: mock.Mock(side_effect=source_getter)} sink_getters = {A: mock.Mock(side_effect=sink_getter)} transmission_parameters = mock.Mock(name="Transmission Params") def transmission_builder(model, conn): assert model is m assert conn is connection return transmission_parameters reception_parameters = mock.Mock(name="Reception Params") def reception_builder(model, conn): assert model is m assert conn is connection return reception_parameters transmission_parameter_builders = { A: mock.Mock(side_effect=transmission_builder) } reception_parameter_builders = { A: mock.Mock(side_effect=reception_builder) } # Make the connection if use_make_connection: # Set an RNG to build with m.rng = np.random # Set the builders m._source_getters = source_getters m._sink_getters = sink_getters m._transmission_parameter_builders = \ transmission_parameter_builders m._reception_parameter_builders = reception_parameter_builders # Build the connection directly m.make_connection(connection) else: # Embed the connection in a mock Nengo network and build that # instead. network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] # Build this (having overridden the builders) with mock.patch.object(m, "source_getters", source_getters), \ mock.patch.object(m, "sink_getters", sink_getters), \ mock.patch.object(m, "transmission_parameter_builders", transmission_parameter_builders), \ mock.patch.object(m, "reception_parameter_builders", reception_parameter_builders): m.build(network) # Assert the connection map received an appropriate call m.connection_map.add_connection.assert_called_once_with( source, source_port, SignalParameters(), transmission_parameters, sink, sink_port, reception_parameters)
def test_single_vertices(self): """Test that operators which produce single vertices work correctly and that all functions and signals are correctly collected and included in the final netlist. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") constraint_a = mock.Mock(name="Constraint B") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec((vertex_a, ), load_fn_a, pre_fn_a, post_fn_a, constraint_a) # Create the second operator vertex_b = mock.Mock(name="vertex B") load_fn_b = mock.Mock(name="load function B") constraint_b = mock.Mock(name="Constraint B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec((vertex_b, ), load_fn_b, constraints=[constraint_b]) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection( operator_a, None, signal_ab_parameters, None, operator_b, None, None ) netlist = model.make_netlist() # Check that the make_vertices functions were called operator_a.make_vertices.assert_called_once_with(model) operator_b.make_vertices.assert_called_once_with(model) # Check that the netlist is as expected assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a] assert net.sinks == [vertex_b] assert net.weight == signal_ab_parameters.weight assert netlist.operator_vertices == { operator_a: (vertex_a, ), operator_b: (vertex_b, ), } assert netlist.keyspaces is model.keyspaces assert set(netlist.constraints) == set([constraint_a, constraint_b]) assert set(netlist.load_functions) == set([load_fn_a, load_fn_b]) assert netlist.before_simulation_functions == [pre_fn_a] assert netlist.after_simulation_functions == [post_fn_a]
def test_multiple_sink_vertices(self): """Test that each of the vertices associated with a sink is correctly included in the sinks of a net. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec((vertex_a, ), load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b0 = mock.Mock(name="vertex B0") vertex_b1 = mock.Mock(name="vertex B1") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec([vertex_b0, vertex_b1], load_fn_b) # Create a third operator, which won't accept the signal vertex_c = mock.Mock(name="vertex C") vertex_c.accepts_signal.side_effect = lambda _, __: False object_c = mock.Mock(name="object C") operator_c = mock.Mock(name="operator C", spec_set=["make_vertices"]) operator_c.make_vertices.return_value = netlistspec((vertex_c, )) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=3) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.object_operators[object_c] = operator_c model.connection_map.add_connection( operator_a, None, signal_ab_parameters, None, operator_b, None, None ) model.connection_map.add_connection( operator_a, None, signal_ab_parameters, None, operator_c, None, None ) netlist = model.make_netlist() # Check that the "accepts_signal" method of vertex_c was called with # reasonable arguments assert vertex_c.accepts_signal.called # Check that the netlist is as expected assert netlist.operator_vertices == { operator_a: (vertex_a, ), operator_b: (vertex_b0, vertex_b1), operator_c: (vertex_c, ), } assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a] assert net.sinks == [vertex_b0, vertex_b1] assert net.weight == signal_ab_parameters.weight assert len(netlist.constraints) == 0
def test_multiple_sink_vertices(self): """Test that each of the vertices associated with a sink is correctly included in the sinks of a net. """ # Create the first operator vertex_a = mock.Mock(name="vertex A") load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec((vertex_a, ), load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b0 = mock.Mock(name="vertex B0") vertex_b1 = mock.Mock(name="vertex B1") load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec([vertex_b0, vertex_b1], load_fn_b) # Create a third operator, which won't accept the signal vertex_c = mock.Mock(name="vertex C") vertex_c.accepts_signal.side_effect = lambda _, __: False object_c = mock.Mock(name="object C") operator_c = mock.Mock(name="operator C", spec_set=["make_vertices"]) operator_c.make_vertices.return_value = netlistspec((vertex_c, )) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=3) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.object_operators[object_c] = operator_c model.connection_map.add_connection(operator_a, None, signal_ab_parameters, None, operator_b, None, None) model.connection_map.add_connection(operator_a, None, signal_ab_parameters, None, operator_c, None, None) netlist = model.make_netlist() # Check that the "accepts_signal" method of vertex_c was called with # reasonable arguments assert vertex_c.accepts_signal.called # Check that the netlist is as expected assert netlist.operator_vertices == { operator_a: (vertex_a, ), operator_b: (vertex_b0, vertex_b1), operator_c: (vertex_c, ), } assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a] assert net.sinks == [vertex_b0, vertex_b1] assert net.weight == signal_ab_parameters.weight assert len(netlist.constraints) == 0
def test_make_connections(self, use_registered_dicts, seed): """Test that building connections adds a new signal to the model.""" # TODO Test that the connection is fully built model = Model() class A(object): pass class B(object): pass a = A() b = B() # Create a connection from a to b connection = mock.Mock() connection.seed = seed connection.pre_obj = a connection.post_obj = b # Create getter methods source = ObjectPort(mock.Mock(), None) sink = ObjectPort(mock.Mock(), None) def source_getter_fn(m, c): assert m is model assert c is connection return spec(source) source_getter = mock.Mock(wraps=source_getter_fn) def sink_getter_fn(m, c): assert m is model assert c is connection return spec(sink) sink_getter = mock.Mock(wraps=sink_getter_fn) # Create a method to build the connection built_connection = mock.Mock(name="built connection") def connection_builder_fn(m, c): assert m is model assert c is connection return built_connection connection_builder_a = mock.Mock(wraps=connection_builder_fn) connection_builder_b = mock.Mock(wraps=connection_builder_fn) # Create a mock network network = mock.Mock() network.seed = None network.connections = [connection] network.ensembles = [] network.nodes = [] network.networks = [] network.probes = [] if use_registered_dicts: # Patch the getters, add a null builder with patch.object(model, "source_getters", {A: source_getter}), \ patch.object(model, "sink_getters", {B: sink_getter}), \ patch.object(model, "connection_parameter_builders", {A: connection_builder_a, B: connection_builder_b}): # Build the network model.build(network) else: model.build(network, extra_source_getters={A: source_getter}, extra_sink_getters={B: sink_getter}, extra_connection_parameter_builders={ A: connection_builder_a, B: connection_builder_b, }) # Check that seeds were provided if seed is not None: assert model.seeds[connection] == seed else: assert model.seeds[connection] is not None # Assert the getters were called assert source_getter.call_count == 1 assert sink_getter.call_count == 1 # Assert that the connection parameter builder was called assert connection_builder_a.call_count == 1 assert connection_builder_b.call_count == 0 # Assert that the parameters were saved assert model.params[connection] is built_connection # Assert that the signal exists signal = model.connections_signals[connection] assert signal.source is source assert signal.sinks == [sink]
def test_model_init_with_keyspaces(): """Test initialising a model, should be completely empty.""" keyspaces = mock.Mock() model = Model(keyspaces=keyspaces) assert model.keyspaces is keyspaces
def test_multiple_source_vertices(self): """Test that each of the vertices associated with a source is correctly included in the sources of a net. """ class MyVertexSlice(VertexSlice): def __init__(self, *args, **kwargs): super(MyVertexSlice, self).__init__(*args, **kwargs) self.args = None def transmits_signal(self, signal_parameters, transmission_parameters): self.args = (signal_parameters, transmission_parameters) return False # Create the first operator vertex_a0 = VertexSlice(slice(0, 1)) vertex_a1 = VertexSlice(slice(1, 2)) vertex_a2 = MyVertexSlice(slice(2, 3)) load_fn_a = mock.Mock(name="load function A") pre_fn_a = mock.Mock(name="pre function A") post_fn_a = mock.Mock(name="post function A") object_a = mock.Mock(name="object A") operator_a = mock.Mock(name="operator A", spec_set=["make_vertices"]) operator_a.make_vertices.return_value = \ netlistspec([vertex_a0, vertex_a1, vertex_a2], load_fn_a, pre_fn_a, post_fn_a) # Create the second operator vertex_b = Vertex() load_fn_b = mock.Mock(name="load function B") object_b = mock.Mock(name="object B") operator_b = mock.Mock(name="operator B", spec_set=["make_vertices"]) operator_b.make_vertices.return_value = \ netlistspec((vertex_b, ), load_fn_b) # Create a signal between the operators keyspace = mock.Mock(name="keyspace") keyspace.length = 32 signal_ab_parameters = SignalParameters(keyspace=keyspace, weight=43) # Create the model, add the items and then generate the netlist model = Model() model.object_operators[object_a] = operator_a model.object_operators[object_b] = operator_b model.connection_map.add_connection( operator_a, None, signal_ab_parameters, None, operator_b, None, None ) netlist = model.make_netlist() # Check that the netlist is as expected assert netlist.operator_vertices == { operator_a: (vertex_a0, vertex_a1, vertex_a2), operator_b: (vertex_b, ), } assert len(netlist.nets) == 1 for net in itervalues(netlist.nets): assert net.sources == [vertex_a0, vertex_a1] assert net.sinks == [vertex_b] assert len(netlist.constraints) == 0 # Check that `transmit_signal` was called correctly sig, tp = vertex_a2.args assert sig.keyspace is keyspace assert tp is None