Example #1
0
class TestChannels(TestCase):
    def setUp(self):
        # print("setup")
        self.instrument = DummyChannelInstrument(name='testchanneldummy')

    def tearDown(self):

        self.instrument.close()
        del self.instrument
        # del self.instrument is not sufficient in general because the __del__ method is
        # first invoked when there are 0 (non weak) references to the instrument. If a test
        # fails the unittest framework will keep a reference to the instrument is removed from
        # the testcase and __del__ is not invoked until all the tests have run.

    def test_channels_get(self):

        temperatures = self.instrument.channels.temperature.get()
        self.assertEqual(len(temperatures), 6)

    @given(value=hst.floats(0, 300), channel=hst.integers(0, 3))
    def test_channel_access_is_identical(self, value, channel):
        channel_to_label = {0: 'A', 1: 'B', 2: 'C', 3: "D"}
        label = channel_to_label[channel]
        channel_via_label = getattr(self.instrument, label)
        # set via labeled channel
        channel_via_label.temperature(value)
        self.assertEqual(channel_via_label.temperature(), value)
        self.assertEqual(self.instrument.channels[channel].temperature(),
                         value)
        self.assertEqual(self.instrument.channels.temperature()[channel],
                         value)
        # reset
        channel_via_label.temperature(0)
        self.assertEqual(channel_via_label.temperature(), 0)
        self.assertEqual(self.instrument.channels[channel].temperature(), 0)
        self.assertEqual(self.instrument.channels.temperature()[channel], 0)
        # set via index into list
        self.instrument.channels[channel].temperature(value)
        self.assertEqual(channel_via_label.temperature(), value)
        self.assertEqual(self.instrument.channels[channel].temperature(),
                         value)
        self.assertEqual(self.instrument.channels.temperature()[channel],
                         value)
        # it's not possible to set via self.instrument.channels.temperature as this is a multi parameter
        # that currently does not support set.

    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_add_channels_from_tuple(self):
        n_channels = len(self.instrument.channels)
        names = ('foo', 'bar', 'foobar')
        channels = tuple(
            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_insert_channel(self):
        n_channels = len(self.instrument.channels)
        name = 'foo'
        channel = DummyChannel(self.instrument, 'Chan' + name, name)
        self.instrument.channels.insert(1, channel)
        self.instrument.add_submodule(name, channel)

        self.assertEqual(len(self.instrument.channels), n_channels + 1)
        self.assertIs(self.instrument.channels[1], channel)
        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.insert(2, channel)
        self.assertEqual(len(self.instrument.channels), n_channels + 1)

    def test_remove_channel(self):
        channels = self.instrument.channels
        chanA = self.instrument.A
        original_length = len(channels.temperature())
        channels.remove(chanA)
        with self.assertRaises(AttributeError):
            getattr(channels, chanA.short_name)
        self.assertEqual(len(channels), original_length - 1)
        self.assertEqual(len(channels.temperature()), original_length - 1)

    def test_remove_locked_channel(self):
        channels = self.instrument.channels
        chanA = self.instrument.A
        channels.lock()
        with self.assertRaises(AttributeError):
            channels.remove(chanA)

    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)

    @given(setpoints=hst.lists(hst.floats(0, 300), min_size=4, max_size=4))
    def test_combine_channels(self, setpoints):
        self.assertEqual(len(self.instrument.channels), 6)

        mychannels = self.instrument.channels[0:2] + self.instrument.channels[
            4:]

        self.assertEqual(len(mychannels), 4)
        self.assertIs(mychannels[0], self.instrument.A)
        self.assertIs(mychannels[1], self.instrument.B)
        self.assertIs(mychannels[2], self.instrument.E)
        self.assertIs(mychannels[3], self.instrument.F)

        for i, chan in enumerate(mychannels):
            chan.temperature(setpoints[i])

        expected = tuple(setpoints[0:2] + [0, 0] + setpoints[2:])
        self.assertEquals(self.instrument.channels.temperature(), expected)

    @given(start=hst.integers(-8, 7),
           stop=hst.integers(-8, 7),
           step=hst.integers(1, 7))
    def test_access_channels_by_slice(self, start, stop, step):
        names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
        channels = tuple(
            DummyChannel(self.instrument, 'Chan' + name, name)
            for name in names)
        chlist = ChannelList(self.instrument, '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'testchanneldummy_Chan{exp_chan}'

    @given(myindexs=hst.lists(elements=hst.integers(-8, 7), min_size=1))
    def test_access_channels_by_tuple(self, myindexs):
        names = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H')
        mytuple = tuple(myindexs)
        channels = tuple(
            DummyChannel(self.instrument, 'Chan' + name, name)
            for name in names)
        chlist = ChannelList(self.instrument, 'channels', DummyChannel,
                             channels)

        mychans = chlist[mytuple]
        for chan, chanindex in zip(mychans, mytuple):
            assert chan.name == f'testchanneldummy_Chan{names[chanindex]}'

    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
            ]
Example #2
0
class TestChannels(TestCase):
    def setUp(self):
        # print("setup")
        self.instrument = DummyChannelInstrument(name='testchanneldummy')

    def tearDown(self):

        self.instrument.close()
        del self.instrument
        # del self.instrument is not sufficient in general because the __del__ method is
        # first invoked when there are 0 (non weak) references to the instrument. If a test
        # fails the unittest framework will keep a reference to the instrument is removed from
        # the testcase and __del__ is not invoked until all the tests have run.

    def test_channels_get(self):

        temperatures = self.instrument.channels.temperature.get()
        self.assertEqual(len(temperatures), 6)

    @given(value=hst.floats(0, 300), channel=hst.integers(0, 3))
    def test_channel_access_is_identical(self, value, channel):
        channel_to_label = {0: 'A', 1: 'B', 2: 'C', 3: "D"}
        label = channel_to_label[channel]
        channel_via_label = getattr(self.instrument, label)
        # set via labeled channel
        channel_via_label.temperature(value)
        self.assertEqual(channel_via_label.temperature(), value)
        self.assertEqual(self.instrument.channels[channel].temperature(),
                         value)
        self.assertEqual(self.instrument.channels.temperature()[channel],
                         value)
        # reset
        channel_via_label.temperature(0)
        self.assertEqual(channel_via_label.temperature(), 0)
        self.assertEqual(self.instrument.channels[channel].temperature(), 0)
        self.assertEqual(self.instrument.channels.temperature()[channel], 0)
        # set via index into list
        self.instrument.channels[channel].temperature(value)
        self.assertEqual(channel_via_label.temperature(), value)
        self.assertEqual(self.instrument.channels[channel].temperature(),
                         value)
        self.assertEqual(self.instrument.channels.temperature()[channel],
                         value)
        # it's not possible to set via self.instrument.channels.temperature as this is a multi parameter
        # that currently does not support set.

    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_add_channels_from_tuple(self):
        n_channels = len(self.instrument.channels)
        names = ('foo', 'bar', 'foobar')
        channels = tuple(
            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_insert_channel(self):
        n_channels = len(self.instrument.channels)
        name = 'foo'
        channel = DummyChannel(self.instrument, 'Chan' + name, name)
        self.instrument.channels.insert(1, channel)
        self.instrument.add_submodule(name, channel)

        self.assertEqual(len(self.instrument.channels), n_channels + 1)
        self.assertIs(self.instrument.channels[1], channel)
        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.insert(2, channel)
        self.assertEqual(len(self.instrument.channels), n_channels + 1)

    @given(setpoints=hst.lists(hst.floats(0, 300), min_size=4, max_size=4))
    def test_combine_channels(self, setpoints):
        self.assertEqual(len(self.instrument.channels), 6)

        mychannels = self.instrument.channels[0:2] + self.instrument.channels[
            4:]

        self.assertEqual(len(mychannels), 4)
        self.assertIs(mychannels[0], self.instrument.A)
        self.assertIs(mychannels[1], self.instrument.B)
        self.assertIs(mychannels[2], self.instrument.E)
        self.assertIs(mychannels[3], self.instrument.F)

        for i, chan in enumerate(mychannels):
            chan.temperature(setpoints[i])

        expected = tuple(setpoints[0:2] + [0, 0] + setpoints[2:])
        self.assertEquals(self.instrument.channels.temperature(), expected)