def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
pmac_block = make_block_creator(__file__,
"test_pmac_manager_block.yaml")
self.child = self.create_child_block(pmac_block,
self.process,
mri_prefix="PMAC",
config_dir="/tmp")
# These are the child blocks we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
# self.child_y = self.process.get_controller(
# "BL45P-ML-STAGE-01:Y")
self.child_cs1 = self.process.get_controller("PMAC:CS1")
self.child_traj = self.process.get_controller("PMAC:TRAJ")
self.child_status = self.process.get_controller("PMAC:STATUS")
# CS1 needs to have the right port otherwise we will error
self.set_attributes(self.child_cs1, port="CS1")
self.o = BeamSelectorPart(
name="beamSelector",
mri="PMAC",
selectorAxis="x",
tomoAngle=0,
diffAngle=0.5,
moveTime=0.5,
)
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
pass
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a fast child
c1 = call_with_params(RunnableController, self.p,
[WaitingPart("p", 0.01)],
mri="fast", configDir="/tmp")
self.p.add_controller("fast", c1)
# And a slow one
c2 = call_with_params(RunnableController, self.p,
[WaitingPart("p", 1.0)],
mri="slow", configDir="/tmp")
self.p.add_controller("slow", c2)
# And a top level one
p1 = call_with_params(RunnableChildPart, name="FAST", mri="fast")
p2 = call_with_params(RunnableChildPart, name="SLOW", mri="slow")
c3 = call_with_params(RunnableController, self.p, [p1, p2],
mri="top", configDir="/tmp")
self.p.add_controller("top", c3)
self.b = self.context.block_view("top")
self.bf = self.context.block_view("fast")
self.bs = self.context.block_view("slow")
# start the process off
self.p.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(odin_writer_block,
self.process,
mri="mri",
prefix="prefix")
self.mock_when_value_matches(self.child)
# set up some values for OdinData PVs that Excalibur would have
settings = {
"imageHeight": 1536,
"imageWidth": 1048,
"blockSize": 1,
"numProcesses": 4,
"dataType": "uint16",
}
self.set_attributes(self.child, **settings)
self.o = OdinWriterPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
self.completed_steps = 0
# goal for these is 3000, 2000, True
cols, rows, alternate = 3000, 2000, False
self.steps_to_do = cols * rows
xs = LineGenerator("x", "mm", 0.0, 0.5, cols, alternate=alternate)
ys = LineGenerator("y", "mm", 0.0, 0.1, rows)
self.generator = CompoundGenerator([ys, xs], [], [], 0.1)
self.generator.prepare()
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a ticker_block block to act as our child
for c in ticker_block(mri="childBlock", config_dir="/tmp"):
self.p.add_controller(c)
self.b_child = self.context.block_view("childBlock")
# Make an empty part for our parent
part1 = Part("part1")
# Make a RunnableChildPart to control the ticker_block
part2 = RunnableChildPart(mri='childBlock',
name='part2',
initial_visibility=True)
# create a root block for the RunnableController block to reside in
self.c = RunnableController(mri='mainBlock', config_dir="/tmp")
self.c.add_part(part1)
self.c.add_part(part2)
self.p.add_controller(self.c)
self.b = self.context.block_view("mainBlock")
self.ss = self.c.state_set
# start the process off
self.checkState(self.ss.DISABLED)
self.p.start()
self.checkState(self.ss.READY)
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(stats_plugin_block,
self.process,
mri="BLOCK:STAT",
prefix="prefix")
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
# Make a ticker_block block to act as our child
self.c_child = call_with_params(ticker_block,
self.p,
mri="childBlock",
configDir="/tmp")
self.b_child = self.context.block_view("childBlock")
# Make an empty part for our parent
part1 = Part("part1")
# Make a RunnableChildPart to control the ticker_block
part2 = call_with_params(RunnableChildPart,
mri='childBlock',
name='part2')
# create a root block for the RunnableController block to reside in
self.c = call_with_params(RunnableController,
self.p, [part1, part2],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
self.ss = self.c.stateSet
# start the process off
self.checkState(self.ss.DISABLED)
self.p.start()
self.checkState(self.ss.READY)
def _get_blocks(context: Context, panda_mri: str) -> List[Block]:
"""Get panda, seqA and seqB Blocks using the given context"""
# {part_name: export_name}
panda = context.block_view(panda_mri)
seq_part_names = {}
for source, export in panda.exports.value.rows():
if export in SEQ_TABLES:
assert source.endswith(
".table"
), "Expected export %s to come from SEQx.table, got %s" % (export,
source)
seq_part_names[source[:-len(".table")]] = export
assert (tuple(sorted(seq_part_names.values())) == SEQ_TABLES
), "Expected exported attributes %s, got %s" % (
SEQ_TABLES,
panda.exports.value.export,
)
# {export_name: mri}
seq_mris = {}
for name, mri, _, _, _ in panda.layout.value.rows():
if name in seq_part_names:
export = seq_part_names[name]
seq_mris[export] = mri
assert sorted(seq_mris) == sorted(seq_part_names.values(
)), "Couldn't find MRI for some of %s" % (seq_part_names.values(), )
blocks = [panda]
blocks += [context.block_view(seq_mris[x]) for x in SEQ_TABLES]
return blocks
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(hdf_writer_block,
self.process,
mri="BLOCK:HDF5",
prefix="prefix")
self.process.start()
def abort_after_1s(self):
# Need a new context as in a different cothread
c = Context(self.p)
b = c.block_view("mainBlock")
c.sleep(1.0)
self.checkState(self.ss.RUNNING)
b.abort()
self.checkState(self.ss.ABORTED)
class TestRunnableControllerCollectsAllParams(unittest.TestCase):
def setUp(self):
self.p = Process('process1')
self.context = Context(self.p)
def tearDown(self):
self.p.stop(timeout=1)
def test_no_hook_passes(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester2("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
def test_hook_fails(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester3("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
def test_hook_plus_method_takes_nothing_passes(self):
# create a root block for the RunnableController block to reside in
self.c = call_with_params(
RunnableController,
self.p, [PartTester1("1"), PartTester4("2")],
mri='mainBlock',
configDir="/tmp",
axesToMove=["x"])
self.p.add_controller('mainBlock', self.c)
self.b = self.context.block_view("mainBlock")
# start the process off
self.p.start()
takes = list(self.b.configure.takes.elements)
self.assertEqual(takes, ["size", "generator", "axesToMove"])
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
position_labeller_block, self.process, mri="BLOCK-POS", prefix="prefix"
)
self.o = PositionLabellerPart(name="m", mri="BLOCK-POS")
self.context.set_notify_dispatch_request(self.o.notify_dispatch_request)
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
xmap_driver_block, self.process, mri="mri", prefix="prefix"
)
self.mock_when_value_matches(self.child)
self.o = XmapDriverPart(name="m", mri="mri", runs_on_windows=True)
self.context.set_notify_dispatch_request(self.o.notify_dispatch_request)
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(reframe_plugin_block,
self.process,
mri="mri",
prefix="prefix")
self.mock_when_value_matches(self.child)
self.o = ReframePluginPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
class TestIocIconPart(unittest.TestCase):
def add_part_and_start(self):
self.icon = IocIconPart(
"ICON",
os.path.split(__file__)[0] +
"/../../../malcolm/modules/system/icons/epics-logo.svg",
)
self.c1.add_part(self.icon)
self.p.add_controller(self.c1)
self.p.start()
def setUp(self):
self.p = Process("process1")
self.context = Context(self.p)
self.c1 = RunnableController(mri="SYS",
config_dir="/tmp",
use_git=False)
def tearDown(self):
self.p.stop(timeout=1)
@patch("malcolm.modules.ca.util.CAAttribute")
def test_has_pv(self, CAAttribute):
self.add_part_and_start()
CAAttribute.assert_called_once_with(
ANY,
catools.DBR_STRING,
"",
"ICON:KERNEL_VERS",
throw=False,
callback=self.icon.update_icon,
)
assert isinstance(CAAttribute.call_args[0][0], StringMeta)
meta = CAAttribute.call_args[0][0]
assert meta.description == "Host Architecture"
assert not meta.writeable
assert len(meta.tags) == 0
def test_adds_correct_icons(self):
self.add_part_and_start()
assert self.context.block_view("SYS").icon.value == defaultIcon
arch = MockPv("windows")
self.icon.update_icon(arch)
assert self.context.block_view("SYS").icon.value == winIcon
arch = MockPv("WIND")
self.icon.update_icon(arch)
assert self.context.block_view("SYS").icon.value == vxIcon
arch = MockPv("linux")
self.icon.update_icon(arch)
assert self.context.block_view("SYS").icon.value == linuxIcon
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.cs = self.create_child_block(cs_block,
self.process,
mri="PMAC:CS1",
prefix="PV:CSPRE")
self.child = self.create_child_block(pmac_trajectory_block,
self.process,
mri="PMAC:TRAJ",
prefix="PV:PRE")
self.o = PmacTrajectoryPart(name="pmac", mri="PMAC:TRAJ")
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(andor_driver_block,
self.process,
mri="mri",
prefix="prefix")
self.mock_when_value_matches(self.child)
# readoutTime used to be 0.002, not any more...
self.andor_driver_part = AndorDriverPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(
self.andor_driver_part.notify_dispatch_request)
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
eiger_driver_block,
self.process,
mri="mri",
prefix="prefix",
fan_prefix="FAN",
)
self.o = EigerDriverPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(self.o.notify_dispatch_request)
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.mri = "mri"
self.child = self.create_child_block(ethercat_driver_block,
self.process,
mri=self.mri,
prefix="prefix")
self.mock_when_value_matches(self.child)
self.ethercat_driver_part = EthercatDriverPart(name="m", mri="mri")
self.context.set_notify_dispatch_request(
self.ethercat_driver_part.notify_dispatch_request)
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(pmac_trajectory_block,
self.process,
mri="PMAC:TRAJ",
prefix="PV:PRE",
statPrefix="PV:STAT")
self.child.parts["i10"].attr.set_value(1705244)
self.o = call_with_params(PmacTrajectoryPart,
name="pmac",
mri="PMAC:TRAJ")
list(self.o.create_attribute_models())
self.process.start()
def s_server_hello_with_malcolm_client(self):
from malcolm.core import call_with_params, Context, ResponseError
from malcolm.blocks.builtin import proxy_block
call_with_params(proxy_block,
self.process2,
mri="hello",
comms="client")
context = Context(self.process2)
context.when_matches(["hello", "health", "value"], "OK", timeout=2)
block2 = self.process2.block_view("hello")
ret = block2.greet(name="me2")
assert ret == dict(greeting="Hello me2")
with self.assertRaises(ResponseError):
block2.error()
def test_set_export_parts(self):
context = Context(self.p)
b = context.block_view("mainBlock")
assert list(b) == [
'meta', 'health', 'state', 'layout', 'design', 'exports',
'modified', 'disable', 'reset', 'save', 'attr'
]
new_exports = Table(self.c.exports.meta)
new_exports.append(('part2.attr', 'childAttr'))
new_exports.append(('part2.reset', 'childReset'))
self.c.set_exports(new_exports)
assert self.c.modified.value == True
assert self.c.modified.alarm.message == "exports changed"
call_with_params(self.c.save, design='testSaveLayout')
assert self.c.modified.value == False
# block has changed, get a new view
b = context.block_view("mainBlock")
assert list(b) == [
'meta', 'health', 'state', 'layout', 'design', 'exports',
'modified', 'disable', 'reset', 'save', 'attr', 'childAttr',
'childReset'
]
assert self.c.state.value == "Ready"
assert b.childAttr.value == "defaultv"
assert self.c.modified.value == False
m = MagicMock()
f = b.childAttr.subscribe_value(m)
# allow a subscription to come through
context.sleep(0.1)
m.assert_called_once_with("defaultv")
m.reset_mock()
self.c_part.attr.set_value("newv")
assert b.childAttr.value == "newv"
assert self.c_part.attr.value == "newv"
assert self.c.modified.value == True
assert self.c.modified.alarm.message == \
"part2.attr.value = 'newv' not 'defaultv'"
# allow a subscription to come through
context.sleep(0.1)
m.assert_called_once_with("newv")
b.childAttr.put_value("again")
assert b.childAttr.value == "again"
assert self.c_part.attr.value == "again"
assert self.c.modified.value == True
assert self.c.modified.alarm.message == \
"part2.attr.value = 'again' not 'defaultv'"
# remove the field
new_exports = Table(self.c.exports.meta)
self.c.set_exports(new_exports)
assert self.c.modified.value == True
call_with_params(self.c.save)
assert self.c.modified.value == False
# block has changed, get a new view
b = context.block_view("mainBlock")
assert "childAttr" not in b
def cs_axis_numbers(
context: Context,
layout_table: builtin.util.LayoutTable,
cs_port: str,
) -> Dict[str, int]:
"""Given the layout table of a PMAC, get the axis number for each name
in the table which is in the specified CS"""
axis_numbers = {}
for name, mri in zip(layout_table.name, layout_table.mri):
child = context.block_view(mri)
try:
axis_number = child.axisNumber.value
except (AttributeError, KeyError):
axis_number = None
try:
cs = child.cs.value
except (AttributeError, KeyError):
cs = None
if cs and axis_number:
child_cs_port = child.cs.value.split(",", 1)[0]
if cs_port == child_cs_port:
if name in axis_numbers:
axis_numbers[name] = axis_number
else:
axis_numbers[name] = axis_number
return axis_numbers
class TestMotorPreMovePart(ChildTestCase):
def setUp(self):
self.process = Process("test_process")
self.context = Context(self.process)
# Create a raw motor mock to handle axis request
self.child = self.create_child_block(raw_motor_block,
self.process,
mri="BS",
pv_prefix="PV:PRE")
# Add Beam Selector object
self.o = MotorPreMovePart(name="MotorPreMovePart", mri="BS", demand=50)
controller = RunnableController("SCAN", "/tmp")
controller.add_part(self.o)
self.process.add_controller(controller)
self.process.start()
def tearDown(self):
del self.context
self.process.stop(timeout=1)
def test_bs(self):
b = self.context.block_view("SCAN")
generator = CompoundGenerator([LineGenerator("x", "mm", 0, 1, 10)], [],
[], 0.1)
b.configure(generator)
self.o.on_configure(self.context)
assert self.child.handled_requests.mock_calls == [
call.put("demand", 50)
]
def setUp(self):
self.process = Process("test_process")
self.context = Context(self.process)
# Create a raw motor mock to handle axis request
self.child = self.create_child_block(
raw_motor_block, self.process, mri="BS", pv_prefix="PV:PRE"
)
# Add Beam Selector object
self.o = MotorPreMovePart(name="MotorPreMovePart", mri="BS", demand=50)
controller = RunnableController("SCAN", "/tmp", use_git=False)
controller.add_part(self.o)
self.process.add_controller(controller)
self.process.start()
def setUp(self):
self.p = Process("process1")
self.context = Context(self.p)
self.c1 = RunnableController(mri="SYS", config_dir="/tmp")
self.tmp_dir = f"/tmp/{now}-{os.getpid()}"
os.mkdir(self.tmp_dir)
os.mkdir(self.tmp_dir + "/configure")
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
stats_plugin_block, self.process,
mri="BLOCK-STAT", prefix="prefix")
self.o = StatsPluginPart(name="m", mri="BLOCK-STAT")
self.process.start()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
reframe_plugin_block, self.process,
mri="mri", prefix="prefix")
self.o = ReframePluginPart(name="m", mri="mri")
self.process.start()
def abort_detector(self, context: Context) -> None:
child = context.block_view(self.mri)
child.stop()
# Stop is a put to a busy record which returns immediately
# The detector might take a while to actually stop so use the
# acquiring pv (which is the same asyn parameter as the busy record
# that stop() pokes) to check that it has finished
child.when_value_matches("acquiring", False, timeout=DEFAULT_TIMEOUT)
def test_save(self):
assert self.c.design.value == ""
assert self.c.design.meta.choices == [""]
c = Context(self.p)
li = []
c.subscribe(["mainBlock", "design", "meta"], li.append)
# Wait for long enough for the other process to get a look in
c.sleep(0.1)
assert len(li) == 1
assert li.pop()["choices"] == [""]
b = c.block_view("mainBlock")
design_name = "testSaveLayout"
b.save(designName=design_name)
assert len(li) == 3
assert li[0]["writeable"] is False
assert li[1]["choices"] == ["", design_name]
assert li[2]["writeable"] is True
assert self.c.design.meta.choices == ["", design_name]
self.check_expected_save(design_name)
assert self.c.state.value == "Ready"
assert self.c.design.value == design_name
assert self.c.modified.value is False
os.remove(self._get_design_filename(self.main_block_name, design_name))
self.c_part.attr.set_value("newv")
assert self.c.modified.value is True
assert (self.c.modified.alarm.message ==
"part2.attr.value = 'newv' not 'defaultv'")
self.c.save(designName="")
self.check_expected_save(design_name, attr="newv")
assert self.c.design.value == "testSaveLayout"
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(
xmap_detector_driver_block, self.process,
mri="mri", prefix="prefix")
self.o = call_with_params(XmapDriverPart, name="m", mri="mri")
list(self.o.create_attribute_models())
self.process.start()