def test_set_element_by_slice(dci_with_list): foo = DummyChannel(dci_with_list, name="foo", channel="foo") bar = DummyChannel(dci_with_list, name="bar", channel="bar") dci_with_list.channels[0:2] = [foo, bar] assert dci_with_list.channels[0] is foo assert dci_with_list.channels[1] is bar assert (dci_with_list.channels.get_channel_by_name("foo") == dci_with_list.channels[0]) assert (dci_with_list.channels.get_channel_by_name("bar") == dci_with_list.channels[1])
def test_channels_is_sequence(dci): names = ("A", "B", "C", "D", "E", "F", "G", "H") channels = tuple(DummyChannel(dci, name, name) for name in names) chlist = ChannelList(dci, "channels", DummyChannel, channels) assert isinstance(chlist, Sequence) assert issubclass(ChannelList, Sequence)
def test_add_channel(self): n_channels = len(self.instrument.channels) name = 'foo' channel = DummyChannel(self.instrument, 'Chan' + name, name) self.instrument.channels.append(channel) self.instrument.add_submodule(name, channel) self.assertEqual(len(self.instrument.channels), n_channels + 1) self.instrument.channels.lock() # after locking the channels it's not possible to add any more channels with self.assertRaises(AttributeError): name = 'bar' channel = DummyChannel(self.instrument, 'Chan' + name, name) self.instrument.channels.append(channel) self.assertEqual(len(self.instrument.channels), n_channels + 1)
def test_add_channels_from_generator(self): n_channels = len(self.instrument.channels) names = ('foo', 'bar', 'foobar') channels = (DummyChannel(self.instrument, 'Chan'+name, name) for name in names) self.instrument.channels.extend(channels) self.assertEqual(len(self.instrument.channels), n_channels + len(names))
def test_channels_count(dci): names = ("A", "B", "C", "D", "E", "F", "G", "H") channels = tuple(DummyChannel(dci, name, name) for name in names) chlist = ChannelList(dci, "channels", DummyChannel, channels) for channel in channels: assert chlist.count(channel) == 1
def test_add_channel(dci): n_channels = len(dci.channels) name = 'foo' channel = DummyChannel(dci, 'Chan' + name, name) dci.channels.append(channel) dci.add_submodule(name, channel) assert len(dci.channels) == n_channels + 1 dci.channels.lock() # after locking the channels it's not possible to add any more channels with pytest.raises(AttributeError): name = 'bar' channel = DummyChannel(dci, 'Chan' + name, name) dci.channels.append(channel) assert len(dci.channels) == n_channels + 1
def test_channels_reverse(dci): names = ("A", "B", "C", "D", "E", "F", "G", "H") channels = tuple(DummyChannel(dci, name, name) for name in names) chlist = ChannelList(dci, "channels", DummyChannel, channels) reverse_names = reversed(names) for name, chan in zip(reverse_names, reversed(chlist)): assert chan.short_name == name
def test_add_channels_from_tuple(dci): n_channels = len(dci.channels) names = ('foo', 'bar', 'foobar') channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names) dci.channels.extend(channels) assert len(dci.channels) == n_channels + len(names)
def test_extend_channels_from_tuple(dci_with_list): n_channels = len(dci_with_list.channels) names = ("foo", "bar", "foobar") channels = tuple( DummyChannel(dci_with_list, "Chan" + name, name) for name in names) dci_with_list.channels.extend(channels) assert len(dci_with_list.channels) == n_channels + len(names)
def test_access_channels_by_tuple(dci, myindexs): names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H') mytuple = tuple(myindexs) channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names) chlist = ChannelList(dci, 'channels', DummyChannel, channels) mychans = chlist[mytuple] for chan, chanindex in zip(mychans, mytuple): assert chan.name == f'dci_Chan{names[chanindex]}'
def test_access_channels_by_name(dci, myindexs): names = ("A", "B", "C", "D", "E", "F", "G", "H") channels = tuple(DummyChannel(dci, "Chan" + name, name) for name in names) chlist = ChannelList(dci, "channels", DummyChannel, channels) channel_names = (f"Chan{names[i]}" for i in myindexs) mychans = chlist.get_channel_by_name(*channel_names) for chan, chanindex in zip(mychans, myindexs): assert chan.name == f'dci_Chan{names[chanindex]}'
def test_append_channel(dci_with_list): n_channels_pre = len(dci_with_list.channels) n_channels_post = n_channels_pre + 1 chan_num = 11 name = f"Chan{chan_num}" channel = DummyChannel(dci_with_list, name, chan_num) dci_with_list.channels.append(channel) dci_with_list.add_submodule(name, channel) assert len(dci_with_list.channels) == n_channels_post dci_with_list.channels.lock() # after locking the channels it's not possible to add any more channels with pytest.raises(AttributeError): name = "bar" channel = DummyChannel(dci_with_list, "Chan" + name, name) dci_with_list.channels.append(channel) assert len(dci_with_list.channels) == n_channels_post
def test_access_channels_by_slice(dci, start, stop, step): names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H') channels = tuple(DummyChannel(dci, 'Chan' + name, name) for name in names) chlist = ChannelList(dci, 'channels', DummyChannel, channels) if stop < start: step = -step myslice = slice(start, stop, step) mychans = chlist[myslice] expected_channels = names[myslice] for chan, exp_chan in zip(mychans, expected_channels): assert chan.name == f'dci_Chan{exp_chan}'
def test_extend_then_remove(dci): n_channels = len(dci.channels) names = ('foo', 'bar', 'foobar') channels = [DummyChannel(dci, 'Chan' + name, name) for name in names] dci.channels.extend(channels) assert len(dci.channels) == n_channels + len(names) last_channel = dci.channels[-1] dci.channels.remove(last_channel) assert last_channel not in dci.channels assert len(dci.channels) == n_channels + len(names) - 1
def test_insert_channel(dci_with_list): n_channels_pre = len(dci_with_list.channels) name = "foo" channel = DummyChannel(dci_with_list, "Chan" + name, name) dci_with_list.channels.insert(1, channel) dci_with_list.add_submodule(name, channel) n_channels_post = n_channels_pre + 1 assert dci_with_list.channels.get_channel_by_name(f"Chan{name}") is channel assert len(dci_with_list.channels) == n_channels_post assert dci_with_list.channels[1] is channel dci_with_list.channels.lock() # after locking the channels it's not possible to add any more channels with pytest.raises(AttributeError): name = "bar" channel = DummyChannel(dci_with_list, "Chan" + name, name) dci_with_list.channels.insert(2, channel) assert len(dci_with_list.channels) == n_channels_post assert len(dci_with_list.channels._channel_mapping) == n_channels_post
def test_extend_then_remove(self): n_channels = len(self.instrument.channels) names = ('foo', 'bar', 'foobar') channels = [DummyChannel(self.instrument, 'Chan' + name, name) for name in names] self.instrument.channels.extend(channels) self.assertEqual(len(self.instrument.channels), n_channels + len(names)) last_channel = self.instrument.channels[-1] self.instrument.channels.remove(last_channel) assert last_channel not in self.instrument.channels self.assertEqual(len(self.instrument.channels), n_channels + len(names) - 1)
def test_remove_tupled_channel(dci): channel_tuple = tuple( DummyChannel(dci, f'Chan{C}', C) for C in ('A', 'B', 'C', 'D', 'E', 'F')) channels = ChannelList(dci, "TempSensorsTuple", DummyChannel, channel_tuple, snapshotable=False) chan_a = channels.ChanA with pytest.raises(AttributeError): channels.remove(chan_a)
def test_remove_tupled_channel(self): channel_tuple = tuple( DummyChannel(self.instrument, f'Chan{C}', C) for C in ('A', 'B', 'C', 'D', 'E', 'F')) channels = ChannelList(self.instrument, "TempSensorsTuple", DummyChannel, channel_tuple, snapshotable=False) chanA = channels.ChanA with self.assertRaises(AttributeError): channels.remove(chanA)
def test_extend_then_remove(dci_with_list): n_channels = len(dci_with_list.channels) names = ("foo", "bar", "foobar") channels = [ DummyChannel(dci_with_list, "Chan" + name, name) for name in names ] dci_with_list.channels.extend(channels) assert len(dci_with_list.channels) == n_channels + len(names) last_channel = dci_with_list.channels[-1] dci_with_list.channels.remove(last_channel) assert last_channel not in dci_with_list.channels assert len(dci_with_list.channels) == n_channels + len(names) - 1
def test_remove_tupled_channel(dci_with_list): channel_tuple = tuple( DummyChannel(dci_with_list, f"Chan{C}", C) for C in ("A", "B", "C", "D", "E", "F")) channels = ChannelList( dci_with_list, "TempSensorsTuple", DummyChannel, channel_tuple, snapshotable=False, ) chan_a = channels.ChanA with pytest.raises(AttributeError): channels.remove(chan_a)
def test_channel_tuple_snapshot_enabled(empty_instrument): channels = ChannelList(empty_instrument, "ListElem", DummyChannel, snapshotable=True) for chan_name in ("A", "B", "C", "D", "E", "F"): channel = DummyChannel(empty_instrument, f"Chan{chan_name}", chan_name) channels.append(channel) empty_instrument.add_submodule("channels", channels) snapshot = empty_instrument.channels.snapshot() assert snapshot["snapshotable"] is True assert len(snapshot.keys()) == 3 assert "channels" in snapshot.keys()
def test_names(self): ex_inst_name = 'testchanneldummy' for channel in self.instrument.channels: sub_channel = DummyChannel(channel, 'subchannel', 'subchannel') channel.add_submodule('somesubchannel', sub_channel) assert self.instrument.name == ex_inst_name assert self.instrument.full_name == ex_inst_name assert self.instrument.short_name == ex_inst_name assert self.instrument.name_parts == [ex_inst_name] # Parameters directly on instrument assert self.instrument.IDN.name == 'IDN' assert self.instrument.IDN.full_name == f"{ex_inst_name}_IDN" for chan, name in zip(self.instrument.channels, ['A', 'B', 'C', 'D', 'E', 'F']): ex_chan_name = f"Chan{name}" ex_chan_full_name = f"{ex_inst_name}_{ex_chan_name}" assert chan.short_name == ex_chan_name assert chan.name == ex_chan_full_name assert chan.full_name == ex_chan_full_name assert chan.name_parts == [ex_inst_name, ex_chan_name] ex_param_name = 'temperature' assert chan.temperature.name == ex_param_name assert chan.temperature.full_name ==\ f'{ex_chan_full_name}_{ex_param_name}' assert chan.temperature.short_name == ex_param_name assert chan.temperature.name_parts == [ ex_inst_name, ex_chan_name, ex_param_name ] ex_subchan_name = f"subchannel" ex_subchan_full_name = f"{ex_chan_full_name}_{ex_subchan_name}" assert chan.somesubchannel.short_name == ex_subchan_name assert chan.somesubchannel.name == ex_subchan_full_name assert chan.somesubchannel.full_name == ex_subchan_full_name assert chan.somesubchannel.name_parts == [ ex_inst_name, ex_chan_name, ex_subchan_name ] assert chan.somesubchannel.temperature.name == ex_param_name assert chan.somesubchannel.temperature.full_name ==\ f'{ex_subchan_full_name}_{ex_param_name}' assert chan.somesubchannel.temperature.short_name == ex_param_name assert chan.somesubchannel.temperature.name_parts == \ [ex_inst_name, ex_chan_name, ex_subchan_name, ex_param_name]
def _make_dci_with_list(): for i in range(10): pass dci = Instrument(name="dciwl") channels = ChannelList(dci, "ListElem", DummyChannel, snapshotable=False) for chan_name in ("A", "B", "C", "D", "E", "F"): channel = DummyChannel(dci, f"Chan{chan_name}", chan_name) channels.append(channel) dci.add_submodule(chan_name, channel) dci.add_submodule("channels", channels) try: yield dci finally: dci.close()