def test_measure_average(RE, one_bounce_system): logger.debug("test_measure_average") #Load motor and yag _, mot, det = one_bounce_system #Fake event storage centroids = [] readbacks = [] col_c = collector(det.name + '_detector_stats2_centroid_x', centroids) col_r = collector(mot.name + '_pitch', readbacks) #Run plan RE(run_wrapper(measure_average([det, mot], delay=0.1, num=5)), subs={'event':[col_c, col_r]}) #Check events assert centroids == [250.,250.,250.,250.,250.] assert readbacks == [0.,0.,0.,0.,0.] #Clear from last test centroids.clear() readbacks.clear() #Run with array of delays RE(run_wrapper(measure_average([det, mot], delay=[0.1], num=2)), subs={'event':[col_c, col_r]}) #Check events assert centroids == [250., 250.] assert readbacks == [0., 0.] #Invalid delay settings with pytest.raises(ValueError): RE(run_wrapper(measure_average([det, mot], delay=[0.1], num=3)))
def test_fiducialize(RE, fiducialized_yag): fake_slits, fake_yag = fiducialized_yag #collector callbacks aggregate data from 'yield from' returns in lists center = [] measuredcenter = collector("centroid", center) #Run plan with sufficiently large max_width RE(run_wrapper( fiducialize(fake_slits, fake_yag, start=0.1, step_size=1.0, centroid='centroid', samples=1)), subs={'event': [measuredcenter]}) #First shot is blocked second is not assert center == [0.0, 0.3] #Run plan with insufficiently large max_width with pytest.raises(BeamNotFoundError): RE( run_wrapper( fiducialize(fake_slits, fake_yag, start=0.1, step_size=1.0, max_width=0.25, centroid='centroid', samples=1)), )
def test_slit_scan_area_compare(RE): fake_slits = Mover( "slits", OrderedDict([ ('xwidth', (lambda x, y: x)), ('ywidth', (lambda x, y: y)), ]), { 'x': 0, 'y': 0 }) fake_yag = Reader( 'fake_yag', { 'xwidth': (lambda: fake_slits.read()['xwidth']['value']), 'ywidth': (lambda: fake_slits.read()['ywidth']['value']), }) # collector callbacks aggregate data from 'yield from' in the given lists xwidths = [] ywidths = [] measuredxwidths = collector("xwidth", xwidths) measuredywidths = collector("ywidth", ywidths) #test two basic positions RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.0, 1.0, 2)), subs={'event': [measuredxwidths, measuredywidths]}) RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.1, 1.5, 2)), subs={'event': [measuredxwidths, measuredywidths]}) # excpect error if both measurements <= 0 with pytest.raises(ValueError): RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 0.0, 0.0, 2)), subs={'event': [measuredxwidths, measuredywidths]}) # expect error if one measurement <= 0 with pytest.raises(ValueError): RE(run_wrapper(slit_scan_area_comp(fake_slits, fake_yag, 1.1, 0.0, 2)), subs={'event': [measuredxwidths, measuredywidths]}) logger.debug(xwidths) logger.debug(ywidths) assert xwidths == [ 1.0, 1.0, 1.1, 1.1, 0.0, 0.0, 1.1, 1.1, ] assert ywidths == [ 1.0, 1.0, 1.5, 1.5, 0.0, 0.0, 0.0, 0.0, ]
def test_slit_scan_fiducialize(RE, fiducialized_yag): fake_slits, fake_yag = fiducialized_yag #collector callbacks aggregate data from 'yield from' returns in lists center = [] measuredcenter = collector("centroid", center) #Run plan with wide slits RE(run_wrapper( slit_scan_fiducialize(fake_slits, fake_yag, x_width=1.0, y_width=1.0, centroid='centroid', samples=1)), subs={'event': [measuredcenter]}) assert center == [0.3] #collector callbacks aggregate data from 'yield from' returns in lists center = [] measuredcenter = collector("centroid", center) #Run plan with narrow slits RE(run_wrapper( slit_scan_fiducialize(fake_slits, fake_yag, centroid='centroid', samples=1)), subs={'event': [measuredcenter]}) assert center == [0.0]
def test_match_condition_success_no_stop(RE, mot_and_sig): logger.debug("test_match_condition_success_no_stop") mot, sig = mot_and_sig mot.delay = 0 # Delay has no purpose if we aren't going to stop def condition(x): if 5 < x < 7: return True elif 10 < x < 16: return True return False RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False))) assert 12 < mot.position < 14 # Motor should end in the middle of the largest True region mot.move(0, wait=True) def condition(x): return 10 < x < 16 RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False))) assert 12 < mot.position < 14 mot.move(0, wait=True) def condition(x): return x > 10 RE(run_wrapper(match_condition(sig, condition, mot, 20, has_stop=False))) assert 14 < mot.position < 16
def test_iterwalk_raises_RuntimeError_on_motion_timeout( RE, lcls_two_bounce_system): logger.debug("test_iterwalk_raises_RuntimeError_on_motion_timeout") s, m1, m2, y1, y2 = lcls_two_bounce_system # Center pixels of yag center_pix = [y1.size[0] / 2] * 2 goal = [p + 300 for p in center_pix] # Define a bad set command def bad_set(yag, cmd=None, **kwargs): logger.info("{0}Setting Attributes. (BAD)".format(yag.log_pref)) logger.debug("{0}Setting: CMD:{1}, {2} (BAD)".format( yag.log_pref, cmd, kwargs)) return Status(done=True, success=False) # Patch yag set command y1.set = lambda cmd, **kwargs: bad_set(y1, cmd, **kwargs) plan = run_wrapper( iterwalk([y1, y2], [m1, m2], goal, starts=None, first_steps=1, gradients=None, detector_fields='detector_stats2_centroid_x', motor_fields='pitch', tolerances=TOL, system=None, averages=1, overshoot=0, max_walks=5, timeout=None)) # Check a RunTimError is raised with pytest.raises(RuntimeError): RE(plan) # Reload system s, m1, m2, y1, y2 = lcls_two_bounce_system # Patch yag set command y2.set = lambda cmd, **kwargs: bad_set(y2, cmd, **kwargs) plan = run_wrapper( iterwalk([y1, y2], [m1, m2], goal, starts=None, first_steps=1e-6, gradients=None, detector_fields='detector_stats2_centroid_x', motor_fields='pitch', tolerances=TOL, system=None, averages=1, overshoot=0, max_walks=5, timeout=None)) # Check a RunTimError is raised with pytest.raises(RuntimeError): RE(plan)
def test_walk_to_pixel(RE, one_bounce_system): logger.debug("test_walk_to_pixel") _, mot, det = one_bounce_system ########################## # Test on simple devices # ########################## simple_motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0}) simple_det = Reader('det', {'det' : lambda : 5*simple_motor.read()['motor']['value'] + 2}) #Naive step plan = run_wrapper(walk_to_pixel(simple_det, simple_motor, 200, 0, first_step=1e-6, tolerance=10, average=None, target_fields=['det', 'motor'], max_steps=3)) RE(plan) assert np.isclose(simple_det.read()['det']['value'], 200, atol=1) simple_motor.set(0.) #Gradient simple_motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0}) simple_det = Reader('det', {'det' : lambda : 5*simple_motor.read()['motor']['value'] + 2}) plan = run_wrapper(walk_to_pixel(simple_det, simple_motor, 200, 0, gradient=1.6842e+06, tolerance=10, average=None, target_fields=['det', 'motor'], max_steps=3)) RE(plan) assert np.isclose(simple_det.read()['det']['value'], 200, atol=1) ########################## # Test on full model # ########################## #Naive step plan = run_wrapper(walk_to_pixel(det, mot, 200, 0, first_step=1e-6, tolerance=10, average=None, target_fields=['detector_stats2_centroid_x', 'pitch'], max_steps=3)) RE(plan) assert np.isclose(det.read()[det.name + '_detector_stats2_centroid_x']['value'], 200, atol=1) mot.set(0.) #Gradient plan = run_wrapper(walk_to_pixel(det, mot, 200, 0, gradient=1.6842e+06, tolerance=10, average=None, target_fields=['detector_stats2_centroid_x', 'pitch'], max_steps=3)) RE(plan) assert np.isclose(det.read()[det.name + '_detector_stats2_centroid_x']['value'], 200, atol=10)
def test_process_det_data_returns_correct_detector_dict(sim_det_01, RE): resize = 1.0 kernel = (9, 9) uint_mode = "clip" thresh_mode = "otsu" thresh_factor = 3 det_01 = sim_det_01 # Fake event storage array_data = [] array_count = [] col_images = collector(det_01.image.array_data.name, array_data) col_count = collector(det_01.image.array_counter.name, array_count) # A test plan that reads the data 10 times and process the data def test_plan(det): read_data = yield from measure([det], num=10) array_signal = det.image.array_data size_signal = det.image.array_size proc_dict = process_det_data(read_data, array_signal, size_signal, kernel=kernel, resize=resize, uint_mode=uint_mode, thresh_mode=thresh_mode) assert (len(proc_dict) == 20) # Run the plan RE(run_wrapper(test_plan(det_01)), subs={'event': [col_count, col_images]})
def test_characterize_returns_correct_detector_dict(sim_det_01, RE): resize = 1.0 kernel = (9, 9) uint_mode = "scale" thresh_mode = "otsu" thresh_factor = 3 min_area = 100 det_01 = sim_det_01 array_str = "image.array_data" size_str = "image.array_size" # Fake event storage array_data = [] array_count = [] col_images = collector(det_01.image.array_data.name, array_data) col_count = collector(det_01.image.array_counter.name, array_count) # A test plan that reads the data 10 times and process the data def test_plan(det, sig, size): proc_dict = yield from characterize(det, array_str, size_str, num=10, kernel=kernel, resize=resize, uint_mode=uint_mode, min_area=min_area, thresh_factor=thresh_factor) assert (len(proc_dict) == 20) # Run the plan RE(run_wrapper(test_plan(det_01, "image.array_data", "image.array_size")), subs={'event': [col_count, col_images]})
def test_homs_fiducialize(RE, fiducialized_yag_set): #set of independant (slit,yag) tuples fset = fiducialized_yag_set slit_set, yag_set = list(zip(*fset)) yag_set = [ PIM("TEST"), PIM("TEST"), PIM("TEST"), ] center = [] measuredcenter = collector("TST:TEST_detector_stats2_centroid_y", center) state = [] measuredstate = collector("TST:TEST_states", state) RE(run_wrapper( homs_fiducialize(slit_set, yag_set, x_width=.6, y_width=.6, samples=2, centroid='detector_stats2_centroid_y')), subs={'event': [measuredcenter, measuredstate]}) #print(fset[0][0].read()['xwidth']['value']) #print(fset[1][0].read()['xwidth']['value']) #print(center) #print(state) for x in yag_set: assert x.read()['TST:TEST_states']['value'] == 'OUT', "yag not removed" for index, _ in enumerate(center): assert center[index] == 0.0, 'measurment incorrect'
def test_beam_statistics(RE, resize, kernel, uint_mode, thresh_mode, min_area, thresh_factor, filter_kernel, image_num, cent_num, image_delay, ad_data, image_data, lcls_two_bounce_system): _, _, _, y1, y2 = lcls_two_bounce_system array_str = "image1.array_data" size_str = "image1.array_size" def test_plan(): stats = yield from beam_statistics([y1, y2], array_field=array_str, size_field=size_str, cent_num=cent_num, image_num=image_num, kernel=kernel, resize=resize, uint_mode=uint_mode, thresh_factor=thresh_factor, filter_kernel=filter_kernel, thresh_mode=thresh_mode, md="all", image_delay=image_delay, ad_data=ad_data, image_data=image_data) for _, det in stats.items(): for key, val in det.items(): if key == "md": continue assert (not np.isnan(val) or not np.isinf(val) or not None) RE(run_wrapper(test_plan()))
def test_beam_statistics_raises_runtimeerror_on_timeout( RE, resize, kernel, uint_mode, thresh_mode, min_area, thresh_factor, filter_kernel, num, delay, ad_data, image_data, lcls_two_bounce_system): _, _, _, y1, y2 = lcls_two_bounce_system array_str = "image1.array_data" size_str = "image1.array_size" def test_plan(): stats = yield from beam_statistics([y1, y2], array_field=array_str, size_field=size_str, num=num, kernel=kernel, resize=resize, uint_mode=uint_mode, thresh_factor=thresh_factor, filter_kernel=filter_kernel, thresh_mode=thresh_mode, md="all", image_delay=delay, ad_data=ad_data, image_data=image_data, timeout=-1) with pytest.raises(RuntimeError): RE(run_wrapper(test_plan()))
def test_beam_statistics_raises_runtimeerror_on_stuck_motor( RE, resize, kernel, uint_mode, thresh_mode, min_area, thresh_factor, filter_kernel, num, delay, ad_data, image_data, lcls_two_bounce_system): _, _, _, y1, y2 = lcls_two_bounce_system array_str = "image1.array_data" size_str = "image1.array_size" # Set the motor set_and_wait timeout to be 1s y1.timeout = 1 # Make the motor 'stuck' by it always reading back 'OUT' y1.states._get_readback = lambda: "OUT" def test_plan(): stats = yield from beam_statistics([y1, y2], array_field=array_str, size_field=size_str, num=num, kernel=kernel, resize=resize, uint_mode=uint_mode, thresh_factor=thresh_factor, filter_kernel=filter_kernel, thresh_mode=thresh_mode, md="all", image_delay=delay, ad_data=ad_data, image_data=image_data, pim_timeout=1) with pytest.raises(RuntimeError): RE(run_wrapper(test_plan()))
def test_match_condition_fail_no_stop(RE, mot_and_sig): logger.debug("test_match_condition_fail_no_stop") mot, sig = mot_and_sig mot.delay = 0 RE( run_wrapper( match_condition(sig, lambda x: x > 50, mot, 40, has_stop=False))) assert mot.position == 40
def test_iterwalk(RE, lcls_two_bounce_system, goal1, goal2, first_steps, gradients, tolerances, overshoot, max_walks): logger.debug( "test_iterwalk with goal1=%s, goal2=%s, first_steps=%s, " + "gradients=%s, tolerances=%s, overshoot=%.2f, max_walks=%s", goal1, goal2, first_steps, gradients, tolerances, overshoot, max_walks) s, m1, m2, y1, y2 = lcls_two_bounce_system goal1 += y1.size[0] / 2 goal2 += y2.size[0] / 2 goal = [goal1, goal2] plan = run_wrapper( iterwalk([y1, y2], [m1, m2], goal, starts=None, first_steps=first_steps, gradients=gradients, detector_fields='detector_stats2_centroid_x', motor_fields='pitch', tolerances=tolerances, system=[m1, m2, y1, y2], averages=1, overshoot=overshoot, max_walks=max_walks, timeout=None)) RE(plan) assert np.isclose(y1.read()[y1.name + '_detector_stats2_centroid_x']['value'], goal[0], atol=tolerances) assert np.isclose(y2.read()[y2.name + '_detector_stats2_centroid_x']['value'], goal[1], atol=tolerances) # Make sure we actually read all the groups as we went m1_reads = 0 m2_reads = 0 y1_reads = 0 y2_reads = 0 saves = 0 for msg in RE.msg_hook.msgs: if msg.command == 'read': if msg.obj == m1: m1_reads += 1 if msg.obj == m2: m2_reads += 1 if msg.obj == y1: y1_reads += 1 if msg.obj == y2: y2_reads += 1 if msg.command == 'save': saves += 1 assert saves > 0 assert all( map(lambda x: x == saves, [m1_reads, m2_reads, y1_reads, y2_reads]))
def test_recover_threshold_timeout_failure(RE, mot_and_sig): logger.debug("test_recover_threshold_timeout_failure") mot, sig = mot_and_sig # Make the motor slower to guarantee a timeout mot.n_steps = 5000 RE(run_wrapper(recover_threshold(sig, 50, mot, +1, timeout=0.1))) pos = mot.position assert not 49 < pos < 51 assert mot.position not in (100, -100)
def test_measure(RE): #Simplest implementation plan = run_wrapper(measure([det,motor], num=5, delay=0.01)) #Fake callback storage shots = list() cb = collector('det', shots) #Run simple RE(plan, subs={'event' : cb}) assert shots == [1.0, 1.0, 1.0, 1.0, 1.0] #Create counting detector index = 0 def count(): nonlocal index index += 1 return index counter = Reader('det', {'intensity' : count}) #Filtered implementation plan = run_wrapper(measure([counter], filters = {'intensity' : lambda x : x > 2}, #num=5, delay=[0.01, 0.02, 0.03, 0.04])) num=5)) #Fake callback storage shots = list() cb = collector('intensity', shots) #Run filtered RE(plan, subs={'event' : cb}) assert shots == [1, 3, 4, 5, 6, 7] #2 is skipped, because read is called #by `describe`, which is called by RE #after first read # Make sure an exception is raised when we fail too many filter checks counter = Reader('det', {'intensity' : count}) plan = run_wrapper(measure([counter], filters = {'intensity' : lambda x : False}, num=500)) with pytest.raises(FilterCountError): RE(plan)
def test_verify_all_answers(RE, fake_yags): yags, ans = fake_yags ok_queue = Queue() # Check that all correct returns True, near correct returns True, and # completely wrong returns False. RE( run_wrapper( verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x', ans, 1))) RE( run_wrapper( verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x', [a + 5 for a in ans], 6))) RE( run_wrapper( verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x', [a + 5 for a in ans], 1))) assert ok_queue.get() is True, "Exactly correct rejected!" assert ok_queue.get() is True, "Within tolerance rejected!" assert ok_queue.get() is False, "Outside of tolerance accepted!"
def test_iterwalk_raises_RuntimeError_on_failed_walk_to_pixel( RE, lcls_two_bounce_system): logger.debug("test_iterwalk_raises_RuntimeError_on_failed_walk_to_pixel") s, m1, m2, y1, y2 = lcls_two_bounce_system # Center pixels of yag center_pix = [y1.size[0] / 2] * 2 goal = [p + 300 for p in center_pix] # Define a bad set command def bad_set(mirror, cmd=None, **kwargs): logger.info("{0}Setting Attributes. (BAD)".format(mirror.log_pref)) logger.debug("{0}Setting: CMD:{1}, {2} (BAD)".format( mirror.log_pref, cmd, kwargs)) err = 0.1 if cmd in ("IN", "OUT"): pass # If these were removable we'd implement it here elif cmd is not None: # Here is where we move the pitch motor if a value is set cmd += err mirror.sim_pitch = cmd return mirror.pitch.set(cmd) mirror.sim_x = kwargs.get('x', mirror.sim_x) mirror.sim_z = kwargs.get('z', mirror.sim_z) mirror.sim_pitch = kwargs.get('pitch', mirror.sim_pitch) for motor in mirror.motors: motor_params = motor.read() for key in kwargs.keys(): if key in motor_params: # Add error term to sets motor.set(kwargs[key] + err) return Status(done=True, success=True) # Patch yag set command m1.set = lambda cmd, **kwargs: bad_set(m1, cmd, **kwargs) plan = run_wrapper( iterwalk([y1, y2], [m1, m2], goal, starts=None, first_steps=1e-6, gradients=None, detector_fields='sim_x', motor_fields='pitch', tolerances=TOL, system=None, averages=1, overshoot=0, max_walks=5, timeout=None)) # Check a RunTimError is raised with pytest.raises(RuntimeError): RE(plan)
def test_measure_centroid(RE, one_bounce_system): logger.debug("test_measure_centroid") #Load motor and yag _, mot, det = one_bounce_system #Fake event storage centroids = [] col_c = collector(det.name + '_detector_stats2_centroid_x', centroids) #Run plan # assert 0 RE(run_wrapper(measure_centroid(det, average=5, target_field='detector_stats2_centroid_x')), subs={'event':[col_c]}) #Check events assert centroids == [250.,250.,250.,250.,250.]
def test_nonrewindable_detector(fresh_RE, motor_det, start_state, msg_seq): class FakeSig: def get(self): return False motor, det = motor_det det.rewindable = FakeSig() RE = fresh_RE RE.rewindable = start_state m_col = MsgCollector() RE.msg_hook = m_col RE(bp.run_wrapper(bp.trigger_and_read([motor, det]))) assert [m.command for m in m_col.msgs] == msg_seq
def test_verify_all_readers(RE, fake_yags): yags, ans = fake_yags ok = False RE( run_wrapper( verify_all(yags[1:], 'detector_stats2_centroid_x', ans, 5, other_readers=yags[0], other_fields='detector_stats2_centroid_y'))) for msg in RE.msg_hook.msgs: if msg.command == 'read' and yags[0] is msg.obj: ok = True break assert ok, ("We didn't find our extra reader in the collected messages")
def test_intreupted_with_callbacks(fresh_RE, int_meth, stop_num, msg_num): RE = fresh_RE docs = defaultdict(list) def collector_cb(name, doc): nonlocal docs docs[name].append(doc) RE.msg_hook = MsgCollector() RE(subs_wrapper(run_wrapper(pause()), {'all': collector_cb})) getattr(RE, int_meth)() assert len(docs['start']) == 1 assert len(docs['event']) == 0 assert len(docs['descriptor']) == 0 assert len(docs['stop']) == stop_num assert len(RE.msg_hook.msgs) == msg_num
def test_verify_all_array(RE, fake_yags): yags, ans = fake_yags ok_queue = Queue() # Last let's make sure we can get a list of bools that correspond correctly # to the yag that was wrong ans[0] = ans[0] + 25 RE( run_wrapper( verify_and_stash(ok_queue, yags, 'detector_stats2_centroid_x', ans, 5, summary=False))) ok_list = ok_queue.get() assert not ok_list[0], "Wrong element bool i=0" for i in range(1, len(ans)): assert ok_list[i], "Wrong element bool i={}".format(i)
def test_fitwalk(RE): #Create simulated devices motor = Mover('motor', {'motor' : lambda x : x}, {'x' :0}) det = Reader('det', {'centroid' : lambda : 5*motor.read()['motor']['value'] + 2}) #Assemble linear fitting callback linear = LinearFit('centroid', 'motor', average=1) #Assemble parabolic fitting callback parabola = ParabolicFit('centroid', 'motor', average=1) #Create plan walk = fitwalk([det], motor, [parabola, linear], 89.4, average=1, tolerance = 0.5) #Call with RunEngine RE(run_wrapper(walk)) #Check we hit our target assert np.isclose(det.read()['centroid']['value'], 89.4, 0.5)
def test_sim_det_interfaces_with_bluesky_correctly(sim_det_01, sim_det_02, RE): global_data = None det_01 = sim_det_01 det_02 = sim_det_02 im_filter = lambda image: contour_area_filter(image, uint_mode="clip") # Fake event storage array_data = [] array_count = [] col_images = collector(det_01.image.array_data.name, array_data) col_count = collector(det_01.image.array_counter.name, array_count) # A test plan that just reads the data 10 times def test_plan(det): read_data = yield from measure([det], num=10) # Include the counter in the read det_01.image.read_attrs = ["array_data", "array_counter"] # Run the plan RE(run_wrapper(test_plan(det_01)), subs={'event': [col_count, col_images]}) # Check the each image against the count im_filter = lambda image: contour_area_filter(image, uint_mode="clip") for count, array in zip(array_count, array_data): try: array_size = [int(val) for val in det_01.image.array_size.get()] if array_size == [0, 0, 0]: raise RuntimeError('Invalid image') if array_size[-1] == 0: array_size = array_size[:-1] image = np.array(array).reshape(array_size) idx = count - 1 cent, bbox = detect(image, uint_mode="clip", filters=im_filter) assert (idx % 4 != 3 or idx == 0) except NoBeamDetected: assert (idx % 4 == 3)
def test_measure_average_system(RE, lcls_two_bounce_system): logger.debug("test_measure_average_system") _, m1, m2, y1, y2 = lcls_two_bounce_system centroids = [] readbacks = [] col_c = collector(y1.name + '_detector_stats2_centroid_x', centroids) col_r = collector(m1.name + '_pitch', readbacks) RE(run_wrapper(measure_average([y1, m1, y2, m2], delay=0.1, num=5)), subs={'event':[col_c, col_r]}) assert centroids == [y1.detector._get_readback_centroid_x()] * 5 assert readbacks == [m1.position] * 5 # RE.msg_hook is a message collector m1_reads = 0 m2_reads = 0 y1_reads = 0 y2_reads = 0 saves = 0 for msg in RE.msg_hook.msgs: if msg.command == 'read': if msg.obj == m1: m1_reads += 1 if msg.obj == m2: m2_reads += 1 if msg.obj == y1: y1_reads += 1 if msg.obj == y2: y2_reads += 1 if msg.command == 'save': saves += 1 assert saves > 0 assert all(map(lambda x: x == saves, [m1_reads, m2_reads, y1_reads, y2_reads]))
def test_match_condition_success(RE, mot_and_sig): logger.debug("test_match_condition_success") mot, sig = mot_and_sig RE(run_wrapper(match_condition(sig, lambda x: x > 10, mot, 20))) assert mot.position < 11
def test_match_condition_fail(RE, mot_and_sig): logger.debug("test_match_condition_fail") mot, sig = mot_and_sig RE(run_wrapper(match_condition(sig, lambda x: x > 50, mot, 40))) assert mot.position == 40
def test_match_condition_timeout(RE, mot_and_sig): logger.debug("test_match_condition_timeout") mot, sig = mot_and_sig RE(run_wrapper(match_condition(sig, lambda x: x > 9, mot, 5, timeout=0.3))) assert mot.position < 5