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_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_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_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_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_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
