def setup(self):
root = RootTask()
root.should_pause = Event()
root.should_stop = Event()
root.paused = Event()
root.default_path = "toto"
self.root = root
def test_child_deletion_handling1():
# Test that adding a task to the root task is correctly handled.
root = RootTask()
task1 = ComplexTask(task_name='task1', task_database_entries={'val1': 2.0})
root.children_task.append(task1)
root.children_task = []
def test_override_saved_measure(self):
""" Test that overriding a measure does override evrything.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
# Adding a monitor.
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.monitors[u'monitor1'].save_test = True
path = os.path.join(self.test_dir, 'saved_measure.ini')
# Save measure.
measure.save_measure(path)
# Create a new measure without headers and checks and test that the old
# values are not in the config file.
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
measure.save_measure(path)
conf = ConfigObj(path)
assert_equal(conf['checks'], '[]')
assert_equal(conf['headers'], '[]')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = ArrayExtremaTask(task_name='Test')
self.root.children_task.append(self.task)
array = np.zeros((5, ), dtype=[('var1', 'f8'), ('var2', 'f8')])
array['var1'][1] = -1
array['var1'][3] = 1
self.root.write_in_database('array', array)
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.write_in_database('int', 1)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveFileTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.write_in_database('int', 1)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('array', np.array(range(10)))
def test_child_deletion_handling1():
# Test that adding a task to the root task is correctly handled.
root = RootTask()
task1 = ComplexTask(task_name='task1',
task_database_entries={'val1': 2.0})
root.children_task.append(task1)
root.children_task = []
def test_build_from_config1(self):
# Test building a interfaceable task from a config.
aux = RootTask()
aux.children_task = [IMixin()]
bis = RootTask.build_from_config(aux.task_preferences,
{'tasks': {'IMixin': IMixin,
'RootTask': RootTask}})
assert_equal(type(bis.children_task[0]).__name__, 'IMixin')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = MeasDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveArrayTask(task_name='Test')
self.root.children_task.append(self.task)
array = np.empty(2, dtype=np.dtype([('a', 'f8'), ('b', 'f8')]))
array[0] = (0, 1)
array[1] = (2, 3)
self.root.write_in_database('array', array)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def test_build_from_config1(self):
# Test building a interfaceable task from a config.
aux = RootTask()
aux.children_task = [IMixin()]
bis = RootTask.build_from_config(
aux.task_preferences,
{'tasks': {
'IMixin': IMixin,
'RootTask': RootTask
}})
assert_equal(type(bis.children_task[0]).__name__, 'IMixin')
def test_ex_access_handling1():
# Test adding an ex_access for an entry.
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2', task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
def test_ex_access_handling1():
# Test adding an ex_access for an entry.
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2',
task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
def test_child_addition_handling1():
# Test that adding a task to the root task is correctly handled.
root = RootTask()
task1 = ComplexTask(task_name='task1', task_database_entries={'val1': 2.0})
root.children_task.append(task1)
assert_equal(task1.task_depth, 1)
assert_equal(task1.task_path, 'root')
assert_is(task1.task_database, root.task_database)
assert_is(task1.root_task, root)
assert_is(task1.parent_task, root)
assert_equal(task1.get_from_database('task1_val1'), 2.0)
assert_equal(root.get_from_database('task1_val1'), 2.0)
def test_child_addition_handling1():
# Test that adding a task to the root task is correctly handled.
root = RootTask()
task1 = ComplexTask(task_name='task1',
task_database_entries={'val1': 2.0})
root.children_task.append(task1)
assert_equal(task1.task_depth, 1)
assert_equal(task1.task_path, 'root')
assert_is(task1.task_database, root.task_database)
assert_is(task1.root_task, root)
assert_is(task1.parent_task, root)
assert_equal(task1.get_from_database('task1_val1'), 2.0)
assert_equal(root.get_from_database('task1_val1'), 2.0)
class TestLogTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LogTask(task_name='Test')
self.root.children_task.append(self.task)
def test_check1(self):
# Simply test that everything is ok message is evaluable.
self.task.message = 'True'
test, traceback = self.task.check()
assert_true(test)
assert_false(traceback)
def test_check2(self):
# Test handling a wrong message.
self.task.message = 'True{'
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test', traceback)
def test_perform(self):
# Test performing when condition is True.
self.task.message = 'toro'
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_message'), 'toro')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoadArrayTask(task_name='Test')
self.task.interface = CSVLoadInterface()
self.task.folder = FOLDER_PATH
self.task.filename = 'fake.dat'
self.root.children_task.append(self.task)
def test_add_monitor1(self):
""" Test adding a new monitor.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
# Be sure that there is no observers for the database
assert_false(measure.root_task.task_database.has_observers('notifier'))
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
# Check the monitor is now in the list of the measure monitors
assert_in(u'monitor1', measure.monitors)
# Check that all values have been correctly updated.
monitor = measure.monitors[u'monitor1']
assert_equal(monitor.measure_name, measure.name)
assert_equal(monitor.measure_status, measure.status)
assert_equal(monitor.updated, {'root/default_path': 1})
assert_equal(measure.collect_entries_to_observe(),
['root/default_path'])
# Check that the notifier is correctly observed.
assert_true(measure.root_task.task_database.has_observers('notifier'))
class TestLogTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LogTask(task_name='Test')
self.root.children_task.append(self.task)
def test_check1(self):
# Simply test that everything is ok message is evaluable.
self.task.message = 'True'
test, traceback = self.task.check()
assert_true(test)
assert_false(traceback)
def test_check2(self):
# Test handling a wrong message.
self.task.message = 'True{'
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test', traceback)
def test_perform(self):
# Test performing when condition is True.
self.task.message = 'toro'
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_message'), 'toro')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = TransferPulseSequenceTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'AWG5014B': InstrHelper}
self.root.write_in_database('int', 2)
self.sequence = RootSequence()
self.context = AWGContext()
self.sequence.context = self.context
self.sequence.external_vars = {'a': None}
pulse1 = Pulse(def_1='1.0', def_2='{a}', channel='Ch1_M1')
pulse2 = Pulse(def_1='{a} + 1.0', def_2='4.0', channel='Ch1_M1')
pulse3 = Pulse(def_1='{2_stop} + 0.5', def_2='10', channel='Ch1_M1')
self.sequence.items.extend([pulse1, pulse2, pulse3])
self.task.sequence = self.sequence
self.task.sequence_vars = {'a': '{Root_int}'}
interface = AWGTransferInterface(task=self.task)
self.task.interface = interface
self.task.selected_driver = 'AWG5014B'
self.task.selected_profile = 'Test1'
def get_ch(s, ch):
return InstrHelper(({'output_state': 'OFF'},
{'select_sequence': lambda s, se: None}))
prof = ({'owner': [None], 'defined_channels': ('Ch1',)},
{'get_channel': get_ch, 'to_send': lambda s, se: None})
self.root.run_time['profiles'] = {'Test1': prof}
def build_task_from_config(config, dep_source, root=False):
""" Rebuild a task hierarchy from a Section.
Parameters
----------
config : Section
Section representing the task hierarchy.
dep_source :
Source of the build dependencies of the hierarchy. This can either
be the instance of the TaskManager of a dict of dependencies.
Returns
-------
task :
Newly built task.
"""
if not isinstance(dep_source, dict):
core = dep_source.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_build_dep_from_config'
dep_source = core.invoke_command(cmd, {'config': config})
if isinstance(dep_source, Exception):
return None
if root:
return RootTask.build_from_config(config, dep_source)
else:
task_class = dep_source['tasks'][config.pop('task_class')]
return task_class.build_from_config(config, dep_source)
def test_ex_access_handling5():
# Test removing a task with whose one entry has an ex_access, and then
# adding a different task (same name, same class, etc)
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2', task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
task1.children_task = []
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task3 = SimpleTask(task_name='task2', task_database_entries={'val2': 'r'})
task1.children_task.append(task3)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
def build_task_from_config(config, dep_source, root=False):
""" Rebuild a task hierarchy from a Section.
Parameters
----------
config : Section
Section representing the task hierarchy.
dep_source :
Source of the build dependencies of the hierarchy. This can either
be the instance of the TaskManager of a dict of dependencies.
Returns
-------
task :
Newly built task.
"""
if not isinstance(dep_source, dict):
core = dep_source.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_build_dep_from_config'
dep_source = core.invoke_command(cmd, {'config': config})
if dep_source is None:
return None
if root:
return RootTask.build_from_config(config, dep_source)
else:
task_class = dep_source['tasks'][config.pop('task_class')]
return task_class.build_from_config(config, dep_source)
def test_ex_access_handling4():
# Test removing a task with whose one entry has an ex_access, adding a new
# one and re-adding the first.
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2', task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
task1.children_task = []
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task3 = SimpleTask(task_name='task3', task_database_entries={'val3': 'r'})
task1.children_task.append(task3)
task1.children_task.append(task2)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.write_in_database('int', 1)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveFileTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.write_in_database('int', 1)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('array', np.array(range(10)))
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = ArrayExtremaTask(task_name='Test')
self.root.children_task.append(self.task)
array = np.zeros((5,), dtype=[('var1', 'f8'), ('var2', 'f8')])
array['var1'][1] = -1
array['var1'][3] = 1
self.root.write_in_database('array', array)
def test_run_checks4(self):
""" Test running checks for a measure. Passing without added.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask()
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = False
res, errors = measure.run_checks(self.workbench, internal_only=True)
assert_true(res)
assert_equal(errors, {})
def test_ex_access_handling5():
# Test removing a task with whose one entry has an ex_access, and then
# adding a different task (same name, same class, etc)
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2',
task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
task1.children_task = []
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task3 = SimpleTask(task_name='task2',
task_database_entries={'val2': 'r'})
task1.children_task.append(task3)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = ApplyMagFieldTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
class TestPNASetRFFrequencyTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetRFFrequencyTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
self.task.unit = 'GHz'
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_check_pna_interface1(self):
# Simply test that everything is ok if frequency can be evaluated.
self.task.interface = PNASetRFFrequencyInterface(task=self.task,
channel=1)
self.task.frequency = '1.0'
profile = {'Test1': ({'defined_channels': [[1]]}, {})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
def test_check_pna_interface2(self):
# Check handling a wrong channel.
self.task.interface = PNASetRFFrequencyInterface(task=self.task,
channel=1)
self.task.frequency = '1.0'
profile = {'Test1': ({'defined_channels': [[2]]}, {})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_perform_pna_interface(self):
self.task.interface = PNASetRFFrequencyInterface(task=self.task)
self.task.frequency = '1.0'
profile = {
'Test1': ({
'frequency': [0.0],
'owner': [None]
}, {
'get_channel': lambda x, i: x
})
}
self.root.run_time['profiles'] = profile
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_frequency'), 1.0e9)
def test_collect_dependencies(self):
# Test collecting build dependencies.
self.workbench.register(TaskManagerManifest())
from hqc_meas.tasks.api import RootTask, ComplexTask
from hqc_meas.tasks.tasks_util.log_task import LogTask
aux = [LogTask(task_name="r")]
root = RootTask(task_name="root")
root.children_task = [ComplexTask(task_name="complex", children_task=aux), LogTask(task_name="t")]
core = self.workbench.get_plugin(u"enaml.workbench.core")
com = u"hqc_meas.dependencies.collect_dependencies"
res, build, run = core.invoke_command(com, {"obj": root}, core)
assert_true(res)
assert_in("tasks", build)
assert_equal(sorted(["LogTask", "ComplexTask"]), sorted(build["tasks"].keys()))
assert_not_in("interfaces", build)
assert_false(run)
def test_remove_monitor2(self):
""" Test removing a non-existent monitor (should be a no-op).
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
measure.remove_monitor(u'monitor1')
class TestPNASetRFFrequencyTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetRFFrequencyTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
self.task.unit = 'GHz'
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_check_pna_interface1(self):
# Simply test that everything is ok if frequency can be evaluated.
self.task.interface = PNASetRFFrequencyInterface(task=self.task,
channel=1)
self.task.frequency = '1.0'
profile = {'Test1': ({'defined_channels': [[1]]},
{})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
def test_check_pna_interface2(self):
# Check handling a wrong channel.
self.task.interface = PNASetRFFrequencyInterface(task=self.task,
channel=1)
self.task.frequency = '1.0'
profile = {'Test1': ({'defined_channels': [[2]]},
{})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_perform_pna_interface(self):
self.task.interface = PNASetRFFrequencyInterface(task=self.task)
self.task.frequency = '1.0'
profile = {'Test1': ({'frequency': [0.0],
'owner': [None]},
{'get_channel': lambda x, i: x}
)}
self.root.run_time['profiles'] = profile
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_frequency'), 1.0e9)
def test_ex_access_handling4():
# Test removing a task with whose one entry has an ex_access, adding a new
# one and re-adding the first.
root = RootTask()
task1 = ComplexTask(task_name='task1')
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2',
task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
task1.add_access_exception('task2_val2')
assert_equal(root.get_from_database('task2_val2'), 'r')
task1.children_task = []
assert_raises(KeyError, root.get_from_database, 'task2_val2')
task3 = SimpleTask(task_name='task3',
task_database_entries={'val3': 'r'})
task1.children_task.append(task3)
task1.children_task.append(task2)
assert_raises(KeyError, root.get_from_database, 'task2_val2')
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = self.excep_class(task_name='Test', condition='rr')
self.root.children_task.append(self.task)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveArrayTask(task_name='Test')
self.root.children_task.append(self.task)
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveArrayTask(task_name='Test')
self.root.children_task.append(self.task)
array = np.empty(2, dtype=np.dtype([('a', 'f8'), ('b', 'f8')]))
array[0] = (0, 1)
array[1] = (2, 3)
self.root.write_in_database('array', array)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def test_collect_dependencies(self):
# Test collecting build dependencies.
self.workbench.register(TaskManagerManifest())
from hqc_meas.tasks.api import RootTask, ComplexTask
from hqc_meas.tasks.tasks_util.log_task import LogTask
aux = [LogTask(task_name='r')]
root = RootTask(task_name='root')
root.children_task = [
ComplexTask(task_name='complex', children_task=aux),
LogTask(task_name='t')
]
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.dependencies.collect_dependencies'
res, build, run = core.invoke_command(com, {'obj': root}, core)
assert_true(res)
assert_in('tasks', build)
assert_equal(sorted(['LogTask', 'ComplexTask']),
sorted(build['tasks'].keys()))
assert_not_in('interfaces', build)
assert_false(run)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = MeasDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
self.task.back_step = 0.1
self.task.delay = 0.1
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def setup(self):
root = RootTask()
root.should_pause = Event()
root.should_stop = Event()
root.paused = Event()
root.default_path = 'toto'
self.root = root
def build_root(manager, mode, config=None, parent_ui=None, build_dep=None):
""" Create a new RootTask.
Parameters
----------
manager : TaskManagerPlugin
Instance of the current task manager plugin.
mode : {'from config', 'from template', 'from file'}
Whether to use the given config, or look for one in templates or a
file.
config : configobj.Section
Object holding the informations necessary to build the root task.
parent_ui : optional
Optional parent widget for the dialog.
build_dep : optional
Optionnal dict containing the build dependencies.
Returns:
-------
task : RootTask
"""
if mode == 'from config':
pass
elif mode == 'from file':
path = FileDialogEx.get_open_file_name(parent=parent_ui,
name_filters=['*.ini'])
config, _ = load_template(path)
elif mode == 'from template':
view = TemplateSelectorView(parent=parent_ui, manager=manager)
result = view.exec_()
if result:
path = view.path
config, _ = load_template(path)
if config:
if build_dep is None:
core = manager.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_build_dep_from_config'
build_dep = core.invoke_command(cmd, {'config': config})
if build_dep is None:
return None
config.pop('task_class')
return RootTask.build_from_config(config, build_dep)
def build_root(manager, mode, config=None, parent_ui=None, build_dep=None):
""" Create a new RootTask.
Parameters
----------
manager : TaskManagerPlugin
Instance of the current task manager plugin.
mode : {'from config', 'from template', 'from file'}
Whether to use the given config, or look for one in templates or a
file.
config : configobj.Section
Object holding the informations necessary to build the root task.
parent_ui : optional
Optional parent widget for the dialog.
build_dep : optional
Optionnal dict containing the build dependencies.
Returns:
-------
task : RootTask
"""
if mode == 'from config':
pass
elif mode == 'from file':
path = FileDialogEx.get_open_file_name(parent=parent_ui,
name_filters=['*.ini'])
config, _ = load_template(path)
elif mode == 'from template':
view = TemplateSelectorView(parent=parent_ui, manager=manager)
result = view.exec_()
if result:
path = view.path
config, _ = load_template(path)
if config:
if build_dep is None:
core = manager.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_build_dep_from_config'
build_dep = core.invoke_command(cmd, {'config': config})
if isinstance(build_dep, Exception):
return None
config.pop('task_class')
return RootTask.build_from_config(config, build_dep)
def test_observer_root_task(self):
""" Test the behavior of the root_task observer.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
root_task1 = RootTask()
root_task2 = RootTask()
measure.root_task = root_task1
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.root_task = root_task2
assert_equal(measure.monitors[u'monitor1'].updated,
{'root/default_path': 1})
assert_equal(measure.collect_entries_to_observe(),
['root/default_path'])
assert_false(root_task1.task_database.has_observers('notifier'))
assert_true(root_task2.task_database.has_observers('notifier'))
def test_collect_headers(self):
""" Test header collection.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask()
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
measure.collect_headers(self.workbench)
assert_equal(measure.root_task.default_header,
'Test header\nTest header')
def test_observer_status(self):
""" Test observer for measure status.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.status = 'Test over'
assert_equal(measure.monitors[u'monitor1'].measure_status, 'Test over')
def test_run_checks2(self):
""" Test running checks for a measure. Failing because added check.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = False
res, errors = measure.run_checks(self.workbench)
assert_false(res)
assert_equal(errors, {u'check1': {'test': 'Failed'}})
def test_child_addition_handling2():
# Test that adding a task to a complex task below the root task is
# correctly handled.
root = RootTask()
task1 = ComplexTask(task_name='task1', task_database_entries={'val1': 2.0})
root.children_task.append(task1)
task2 = SimpleTask(task_name='task2', task_database_entries={'val2': 'r'})
task1.children_task.append(task2)
assert_equal(task2.task_depth, 2)
assert_equal(task2.task_path, 'root/task1')
assert_is(task2.task_database, root.task_database)
assert_is(task2.root_task, root)
assert_is(task2.parent_task, task1)
assert_equal(task2.get_from_database('task2_val2'), 'r')
class TestSetRFOnOffTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetRFOnOffTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_check_base_interface1(self):
# Simply test that everything is ok if voltage can be evaluated.
self.task.switch = '1.0'
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
def test_check_base_interface2(self):
# Check handling a wrong voltage.
self.task.switch = '*1.0*'
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_perform_base_interface(self):
self.task.switch = '1.0'
self.root.run_time['profiles'] = {'Test1': ({'output': [0.0],
'owner': [None]}, {})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_output'), 1.0)
class TestSetDCVoltageTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = MeasDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_perform(self):
self.task.wait_time = 1.0
self.root.run_time['profiles'] = {'Test1': ({},
{'read_voltage_dc': [2.0]})
}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_voltage'), 2.0)
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = TransferPulseSequenceTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'AWG5014B': InstrHelper}
self.root.write_in_database('int', 2)
self.sequence = RootSequence()
self.context = AWGContext()
self.sequence.context = self.context
self.sequence.external_vars = {'a': None}
pulse1 = Pulse(def_1='1.0', def_2='{a}', channel='Ch1_M1')
pulse2 = Pulse(def_1='{a} + 1.0', def_2='4.0', channel='Ch1_M1')
pulse3 = Pulse(def_1='{2_stop} + 0.5', def_2='10', channel='Ch1_M1')
self.sequence.items.extend([pulse1, pulse2, pulse3])
self.task.sequence = self.sequence
self.task.sequence_vars = {'a': '{Root_int}'}
interface = AWGTransferInterface(task=self.task)
self.task.interface = interface
self.task.selected_driver = 'AWG5014B'
self.task.selected_profile = 'Test1'
class TestSaveArrayTask(object):
test_dir = TEST_PATH
@classmethod
def setup_class(cls):
print complete_line(__name__ +
':{}.setup_class()'.format(cls.__name__), '-', 77)
os.mkdir(cls.test_dir)
@classmethod
def teardown_class(cls):
print complete_line(__name__ +
':{}.teardown_class()'.format(cls.__name__), '-',
77)
# Removing pref files creating during tests.
try:
shutil.rmtree(cls.test_dir)
# Hack for win32.
except OSError:
print 'OSError'
dirs = os.listdir(cls.test_dir)
for directory in dirs:
shutil.rmtree(os.path.join(cls.test_dir), directory)
shutil.rmtree(cls.test_dir)
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveArrayTask(task_name='Test')
self.root.children_task.append(self.task)
array = np.empty(2, dtype=np.dtype([('a', 'f8'), ('b', 'f8')]))
array[0] = (0, 1)
array[1] = (2, 3)
self.root.write_in_database('array', array)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def teardown(self):
folder = self.test_dir
for the_file in os.listdir(folder):
file_path = os.path.join(folder, the_file)
if os.path.isfile(file_path):
os.remove(file_path)
def test_check1(self):
# Check everything ok in Text mode.
task = self.task
task.folder = self.test_dir
task.filename = 'test_perform{Root_str}.txt'
task.mode = 'Text file'
task.header = 'teststs'
task.target_array = '{Root_array}'
test, traceback = task.check()
assert_true(test)
assert_false(traceback)
assert_false(os.path.isfile(os.path.join(self.test_dir,
'test_performa.txt')))
def test_check2(self):
# Check everything ok in Binary mode (wrong file extension, and header)
task = self.task
task.folder = self.test_dir
task.filename = 'test_perform{Root_str}.txt'
task.mode = 'Binary file'
task.header = 'teststs'
task.target_array = '{Root_array}'
test, traceback = task.check()
assert_true(test)
assert_equal(len(traceback), 2)
assert_in('root/Test-header', traceback)
assert_in('root/Test-file_ext', traceback)
assert_false(os.path.isfile(os.path.join(self.test_dir,
'test_performa.npy')))
def test_check3(self):
# Check handling a wrong folder.
task = self.task
task.folder = self.test_dir + '{eee}'
test, traceback = task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check4(self):
# Check handling a wrong filename.
task = self.task
task.folder = self.test_dir
task.filename = '{rr}'
test, traceback = task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check5(self):
# Check handling a wrong database address.
task = self.task
task.folder = self.test_dir
task.filename = 'test_perform{Root_str}.txt'
task.mode = 'Text file'
task.header = 'teststs'
task.target_array = '**{Root_array}'
test, traceback = task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_perform1(self):
# Test performing in text mode.
task = self.task
task.folder = self.test_dir
task.filename = 'test_perform{Root_str}.txt'
task.mode = 'Text file'
task.header = 'tests'
task.target_array = '{Root_array}'
task.perform()
path = os.path.join(self.test_dir, 'test_performa.txt')
assert_true(os.path.isfile(path))
with open(path) as f:
lines = f.readlines()
assert_equal(lines[0:2], ['# tests\n', 'a\tb\n'])
assert_equal([float(x) for x in lines[2][:-1].split('\t')],
[0.0, 1.0])
assert_equal([float(x) for x in lines[3][:-1].split('\t')],
[2.0, 3.0])
def test_perform2(self):
# Test performing in binary mode.
task = self.task
task.folder = self.test_dir
task.filename = 'test_perform{Root_str}.npy'
task.mode = 'Binary file'
task.target_array = '{Root_array}'
task.perform()
path = os.path.join(self.test_dir, 'test_performa.npy')
assert_true(os.path.isfile(path))
a = np.load(path)
np.testing.assert_array_equal(a, task.get_from_database('Root_array'))
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoopTask(task_name='Test')
self.root.children_task.append(self.task)
class TestLoopTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoopTask(task_name='Test')
self.root.children_task.append(self.task)
def test_task_handling(self):
# Test adding removing a task.
aux = CheckTask()
self.task.task = aux
# Check value is not written in database if a task is present.
assert_not_in('value', self.task.task_database_entries)
# Confirm the child was added (_child_added called)
assert_is(aux.root_task, self.root)
del self.task.task
# Check value is written in database if no task is present.
assert_in('value', self.task.task_database_entries)
# Confirm the child was added (_child_removed called)
assert_is(aux.root_task, None)
def test_timing_handling(self):
# Test enabling/disabling the timing.
assert_not_in('elapsed_time', self.task.task_database_entries)
self.task.timing = True
assert_in('elapsed_time', self.task.task_database_entries)
self.task.timing = False
assert_not_in('elapsed_time', self.task.task_database_entries)
def test_check_linspace_interface1(self):
# Simply test that everything is ok when all formulas are true.
interface = LinspaceLoopInterface()
interface.start = '1.0'
interface.stop = '2.0'
interface.step = '0.1'
self.task.interface = interface
test, traceback = self.task.check()
assert_true(test)
assert_false(traceback)
assert_equal(self.task.get_from_database('Test_point_number'), 11)
def test_check_linspace_interface2(self):
# Test handling a wrong start.
interface = LinspaceLoopInterface()
interface.start = '1.0*'
interface.stop = '2.0'
interface.step = '0.1'
self.task.interface = interface
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test-start', traceback)
def test_check_linspace_interface3(self):
# Test handling a wrong stop.
interface = LinspaceLoopInterface()
interface.start = '1.0'
interface.stop = '2.0*'
interface.step = '0.1'
self.task.interface = interface
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test-stop', traceback)
def test_check_linspace_interface4(self):
# Test handling a wrong step.
interface = LinspaceLoopInterface()
interface.start = '1.0'
interface.stop = '2.0'
interface.step = '0.1*'
self.task.interface = interface
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test-step', traceback)
def test_check_linspace_interface5(self):
# Test handling a wrong number of point.
interface = LinspaceLoopInterface()
interface.start = '1.0'
interface.stop = '2.0'
interface.step = '0.0'
self.task.interface = interface
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 2)
assert_in('root/Test-points', traceback)
assert_in('root/Test-linspace', traceback)
def test_check_iterable_interface1(self):
# Simply test that everything is ok when all formulas are true.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
test, traceback = self.task.check()
assert_true(test)
assert_false(traceback)
assert_equal(self.task.get_from_database('Test_point_number'), 11)
def test_check_iterable_interface2(self):
# Test handling a wrong iterable formula.
interface = IterableLoopInterface()
interface.iterable = '*range(11)'
self.task.interface = interface
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test', traceback)
def test_check_iterable_interface3(self):
# Test handling a wrong iterable type.
interface = IterableLoopInterface()
interface.iterable = '1.0'
self.task.interface = interface
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test', traceback)
def test_perform1(self):
# Test performing a simple loop no timing. Iterable interface.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_value'), 10)
def test_perform2(self):
# Test performing a simple loop no timing. Linspace interface.
interface = LinspaceLoopInterface()
interface.start = '1.0'
interface.stop = '2.0'
interface.step = '0.1'
self.task.interface = interface
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_value'), 2.0)
def test_perform3(self):
# Test performing a simple loop no timing. Break.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.children_task.append(BreakTask(task_name='break',
condition='{Test_value} == 5')
)
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_value'), 5)
def test_perform4(self):
# Test performing a simple loop no timing. Continue
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.children_task.append(ContinueTask(task_name='break',
condition='True')
)
self.task.children_task.append(CheckTask(task_name='check'))
self.root.task_database.prepare_for_running()
self.task.perform()
assert_false(self.task.children_task[1].perform_called)
def test_perform_task1(self):
# Test performing a loop with an embedded task no timing.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.task = CheckTask(task_name='check')
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 11)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 10)
def test_perform_task2(self):
# Test performing a loop with an embedded task no timing. Break.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.task = CheckTask(task_name='check')
self.task.children_task.append(BreakTask(task_name='break',
condition='{Test_index} == 6')
)
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 6)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 5)
def test_perform_task3(self):
# Test performing a loop with an embedded task no timing. Continue.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.task = CheckTask(task_name='check')
self.task.children_task.append(ContinueTask(task_name='break',
condition='True')
)
self.task.children_task.append(CheckTask(task_name='check'))
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 11)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 10)
assert_false(self.task.children_task[1].perform_called)
def test_perform_timing1(self):
# Test performing a simple loop timing.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_value'), 10)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
def test_perform_timing2(self):
# Test performing a simple loop timing. Break
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.task.children_task.append(BreakTask(task_name='break',
condition='{Test_value} == 0')
)
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_value'), 0)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
def test_perform_timing3(self):
# Test performing a simple loop timing. Continue
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.task.children_task.append(ContinueTask(task_name='break',
condition='True')
)
self.task.children_task.append(CheckTask(task_name='check'))
self.root.task_database.prepare_for_running()
self.task.perform()
assert_false(self.task.children_task[1].perform_called)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
def test_perform_timing_task1(self):
# Test performing a loop with an embedded task no timing.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.task.task = CheckTask(task_name='check')
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 11)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 10)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
def test_perform_timing_task2(self):
# Test performing a loop with an embedded task no timing. Break.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.task.task = CheckTask(task_name='check')
self.task.children_task.append(BreakTask(task_name='break',
condition='{Test_index} == 1')
)
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 1)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 0)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
def test_perform_timing_task3(self):
# Test performing a loop with an embedded task no timing. Continue.
interface = IterableLoopInterface()
interface.iterable = 'range(11)'
self.task.interface = interface
self.task.timing = True
self.task.task = CheckTask(task_name='check')
self.task.children_task.append(ContinueTask(task_name='break',
condition='True')
)
self.task.children_task.append(CheckTask(task_name='check'))
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_index'), 11)
assert_true(self.task.task.perform_called)
assert_equal(self.task.task.perform_value, 10)
assert_false(self.task.children_task[1].perform_called)
assert_not_equal(self.root.get_from_database('Test_elapsed_time'), 1.0)
class TestSaveTask(object):
test_dir = TEST_PATH
@classmethod
def setup_class(cls):
print complete_line(__name__ +
':{}.setup_class()'.format(cls.__name__), '-', 77)
os.mkdir(cls.test_dir)
@classmethod
def teardown_class(cls):
print complete_line(__name__ +
':{}.teardown_class()'.format(cls.__name__), '-',
77)
# Removing pref files creating during tests.
try:
shutil.rmtree(cls.test_dir)
# Hack for win32.
except OSError:
print 'OSError'
dirs = os.listdir(cls.test_dir)
for directory in dirs:
shutil.rmtree(os.path.join(cls.test_dir), directory)
shutil.rmtree(cls.test_dir)
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.write_in_database('int', 1)
self.root.write_in_database('float', 2.0)
self.root.write_in_database('str', 'a')
def teardown(self):
folder = self.test_dir
for the_file in os.listdir(folder):
file_path = os.path.join(folder, the_file)
if os.path.isfile(file_path):
os.remove(file_path)
def test_saving_target_observer(self):
self.task.saving_target = 'Array'
assert_equal(self.task.get_from_database('Test_array'),
np.array([1.0]))
self.task.saving_target = 'File'
aux = self.task.accessible_database_entries()
assert_not_in('Test_array', aux)
self.task.saving_target = 'File and array'
assert_equal(self.task.get_from_database('Test_array'),
np.array([1.0]))
def test_check1(self):
# Test everything ok in file mode (no array size).
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir
task.filename = 'test{Root_int}.txt'
task.file_mode = 'New'
task.header = 'test'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
file_path = os.path.join(self.test_dir, 'test1.txt')
test, traceback = task.check()
assert_true(test)
assert_false(traceback)
assert_false(os.path.isfile(file_path))
assert_false(task.initialized)
task.file_mode = 'Add'
test, traceback = task.check()
assert_true(test)
assert_false(traceback)
assert_true(os.path.isfile(file_path))
os.remove(file_path)
def test_check2(self):
# Test everything of in array mode (assert database state).
task = self.task
task.saving_target = 'Array'
task.array_size = '1000*{Root_float}'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
test, traceback = task.check()
assert_true(test)
assert_false(traceback)
array = task.get_from_database('Test_array')
assert_equal(array.dtype.names, ('toto', 'tata'))
def test_check3(self):
# Test everything is ok in file & array mode.
task = self.task
task.saving_target = 'File and array'
task.folder = self.test_dir
task.filename = 'test_rr.txt'
task.file_mode = 'New'
task.header = 'test'
task.array_size = '1000*{Root_float}'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
file_path = os.path.join(self.test_dir, 'test_rr.txt')
test, traceback = task.check()
assert_true(test)
assert_false(traceback)
assert_false(os.path.isfile(file_path))
array = task.get_from_database('Test_array')
assert_equal(array.dtype.names, ('toto', 'tata'))
def test_check4(self):
# Test check issues in file mode : folder.
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir + '{tt}'
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 1)
def test_check5(self):
# Test check issues in file mode : file.
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir
task.filename = 'test{tt}.txt'
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 1)
def test_check6(self):
# Test check issues in file mode : array_size.
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir + '{tt}'
task.filename = 'test.txt'
task.file_mode = 'New'
task.header = 'test'
task.array_size = '1000*'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
file_path = os.path.join(self.test_dir, 'test.txt')
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 1)
assert_false(os.path.isfile(file_path))
def test_check7(self):
# Test check issues in array mode : wrong array_size.
task = self.task
task.saving_target = 'Array'
task.array_size = '1000*{Root_float}*'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 1)
assert_equal(self.task.get_from_database('Test_array'),
np.array([1.0]))
def test_check8(self):
# Test check issues in array mode : absent array_size.
task = self.task
task.saving_target = 'Array'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 1)
assert_equal(self.task.get_from_database('Test_array'),
np.array([1.0]))
def test_check9(self):
# Test check issues in entrie.
task = self.task
task.saving_target = 'Array'
task.array_size = '1000*{Root_float}'
task.saved_values = [('toto', '{Root_str*}'),
('tata', '{Root_float*}')]
test, traceback = task.check()
assert_false(test)
assert_true(traceback)
assert_equal(len(traceback), 2)
array = task.get_from_database('Test_array')
assert_equal(array.dtype.names, ('toto', 'tata'))
def test_check10(self):
# Test warning in case the file already exists in new mode.
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir
task.filename = 'test_e.txt'
task.file_mode = 'New'
task.header = 'test'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
file_path = os.path.join(self.test_dir, 'test_e.txt')
with open(file_path, 'w'):
pass
assert_true(os.path.isfile(file_path))
test, traceback = task.check()
assert_true(test)
assert_true(traceback)
assert_true(os.path.isfile(file_path))
def test_perform1(self):
# Test performing in mode file. (Call three times perform)
task = self.task
task.saving_target = 'File'
task.folder = self.test_dir
task.filename = 'test_perform{Root_int}.txt'
task.file_mode = 'Add'
task.header = 'test'
task.array_size = '3'
task.saved_values = [('toto', '{Root_str}'), ('tata', '{Root_float}')]
file_path = os.path.join(self.test_dir, 'test_perform1.txt')
with open(file_path, 'w') as f:
f.write('test\n')
task.perform()
assert_true(task.initialized)
assert_true(task.file_object)
assert_equal(task.line_index, 1)
with open(file_path) as f:
a = f.readlines()
assert_equal(a, ['test\n', '# test\n', 'toto\ttata\n', 'a\t2.0\n'])
task.perform()
assert_true(task.initialized)
assert_equal(task.line_index, 2)
with open(file_path) as f:
a = f.readlines()
assert_equal(a, ['test\n', '# test\n', 'toto\ttata\n', 'a\t2.0\n',
'a\t2.0\n'])
task.perform()
assert_false(task.initialized)
assert_equal(task.line_index, 3)
with open(file_path) as f:
a = f.readlines()
assert_equal(a, ['test\n', '# test\n', 'toto\ttata\n', 'a\t2.0\n',
'a\t2.0\n', 'a\t2.0\n'])
def test_perform2(self):
# Test performing in array mode. (Call three times perform)
task = self.task
task.saving_target = 'Array'
task.array_size = '3'
task.saved_values = [('toto', '{Root_int}'), ('tata', '{Root_float}')]
task.perform()
assert_true(task.initialized)
assert_equal(task.line_index, 1)
task.perform()
assert_true(task.initialized)
assert_equal(task.line_index, 2)
task.perform()
assert_false(task.initialized)
assert_equal(task.line_index, 3)
array_type = np.dtype([(str(s[0]), 'f8')
for s in task.saved_values])
array = np.empty((3), dtype=array_type)
array[0] = (1, 2.0)
array[1] = (1, 2.0)
array[2] = (1, 2.0)
np.testing.assert_array_equal(task.array, array)
class TestTransferPulseSequenceTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = TransferPulseSequenceTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'AWG5014B': InstrHelper}
self.root.write_in_database('int', 2)
self.sequence = RootSequence()
self.context = AWGContext()
self.sequence.context = self.context
self.sequence.external_vars = {'a': None}
pulse1 = Pulse(def_1='1.0', def_2='{a}', channel='Ch1_M1')
pulse2 = Pulse(def_1='{a} + 1.0', def_2='4.0', channel='Ch1_M1')
pulse3 = Pulse(def_1='{2_stop} + 0.5', def_2='10', channel='Ch1_M1')
self.sequence.items.extend([pulse1, pulse2, pulse3])
self.task.sequence = self.sequence
self.task.sequence_vars = {'a': '{Root_int}'}
interface = AWGTransferInterface(task=self.task)
self.task.interface = interface
self.task.selected_driver = 'AWG5014B'
self.task.selected_profile = 'Test1'
def test_check_no_sequence(self):
self.task.sequence = None
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_no_interface(self):
self.task.interface = None
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 2)
def test_check_errors_in_vars(self):
self.task.sequence_vars = {'a': '**'}
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_compilation_errors(self):
self.task.sequence.items[0].def_1 = 'b'
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_wrong_context(self):
self.task.sequence.context = None
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_ok(self):
test, traceback = self.task.check()
assert_true(test)
def test_register_preferences_seq_path(self):
self.task.sequence_path = 'toto'
self.task.register_preferences()
assert_in('sequence_path', self.task.task_preferences)
assert_not_in('sequence', self.task.task_preferences)
def test_register_preferences_seq(self):
self.task.register_preferences()
assert_not_in('sequence_path', self.task.task_preferences)
assert_in('sequence', self.task.task_preferences)
class TestApplyMagFieldTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = ApplyMagFieldTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_check1(self):
# Simply test that everything is ok if field can be evaluated.
self.task.target_field = '3.0'
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
assert_equal(self.task.get_from_database('Test_Bfield'), 3.0)
def test_check2(self):
# Check handling a wrong field.
self.task.target_field = '*1.0*'
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
assert_in('root/Test-field', traceback)
assert_equal(self.task.get_from_database('Test_Bfield'), 0.01)
def test_perform1(self):
# Simple test when everything is right.
self.task.target_field = '2.0'
self.root.run_time['profiles'] = {'Test1': ({'owner': []},
{'make_ready': [None],
'go_to_field': [None]}
)}
self.root.task_database.prepare_for_running()
self.task.perform()
join_threads(self.root)
assert_equal(self.root.get_from_database('Test_Bfield'), 2.0)
def test_perform2(self):
# Test multiple run when connection is maintained.
self.task.target_field = '2.0'
self.root.run_time['profiles'] = {'Test1': ({'owner': []},
{'make_ready': [None],
'go_to_field': [None],
'check_connection': [True]
}
)}
self.root.task_database.prepare_for_running()
self.task.perform()
join_threads(self.root)
self.task.perform()
join_threads(self.root)
# In case of fail make_ready would be called twice.
assert_equal(self.root.get_from_database('Test_Bfield'), 2.0)
class TestSetDCVoltageTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LockInMeasureTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_mode_observation(self):
# Check database is correctly updated when the mode change.
self.task.mode = 'X'
assert_equal(self.task.get_from_database('Test_x'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_y', aux)
assert_not_in('Test_amplitude', aux)
assert_not_in('Test_phase', aux)
self.task.mode = 'Y'
assert_equal(self.task.get_from_database('Test_y'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_x', aux)
assert_not_in('Test_amplitude', aux)
assert_not_in('Test_phase', aux)
self.task.mode = 'X&Y'
assert_equal(self.task.get_from_database('Test_x'), 1.0)
assert_equal(self.task.get_from_database('Test_y'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_amplitude', aux)
assert_not_in('Test_phase', aux)
self.task.mode = 'Amp'
assert_equal(self.task.get_from_database('Test_amplitude'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_x', aux)
assert_not_in('Test_y', aux)
assert_not_in('Test_phase', aux)
self.task.mode = 'Phase'
assert_equal(self.task.get_from_database('Test_phase'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_x', aux)
assert_not_in('Test_y', aux)
assert_not_in('Test_amplitude', aux)
self.task.mode = 'Amp&Phase'
assert_equal(self.task.get_from_database('Test_amplitude'), 1.0)
assert_equal(self.task.get_from_database('Test_phase'), 1.0)
aux = self.task.accessible_database_entries()
assert_not_in('Test_x', aux)
assert_not_in('Test_y', aux)
def test_perform1(self):
self.task.mode = 'X'
self.root.run_time['profiles'] = {'Test1': ({}, {'read_x': [2.0]})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_x'), 2.0)
def test_perform2(self):
self.task.mode = 'Y'
self.root.run_time['profiles'] = {'Test1': ({}, {'read_y': [2.0]})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_y'), 2.0)
def test_perform3(self):
self.task.mode = 'X&Y'
self.root.run_time['profiles'] = {'Test1': ({},
{'read_xy': [(2.0, 3.0)]})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_x'), 2.0)
assert_equal(self.root.get_from_database('Test_y'), 3.0)
def test_perform4(self):
self.task.mode = 'Amp'
self.root.run_time['profiles'] = {'Test1': ({},
{'read_amplitude': [2.0]})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_amplitude'), 2.0)
def test_perform5(self):
self.task.mode = 'Phase'
self.root.run_time['profiles'] = {'Test1': ({}, {'read_phase': [2.0]})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_phase'), 2.0)
def test_perform6(self):
self.task.mode = 'Amp&Phase'
self.root.run_time['profiles'] = {'Test1': ({},
{'read_amp_and_phase': [(2.0, 3.0)]})
}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_amplitude'), 2.0)
assert_equal(self.root.get_from_database('Test_phase'), 3.0)
class TestSetDCVoltageTask(object):
def setup(self):
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
self.task.back_step = 0.1
self.task.delay = 0.1
# This is set simply to make sure the test of InstrTask pass.
self.task.selected_driver = 'Test'
self.task.selected_profile = 'Test1'
def test_check_base_interface1(self):
# Simply test that everything is ok if voltage can be evaluated.
self.task.target_value = '1.0'
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
def test_check_base_interface2(self):
# Check handling a wrong voltage.
self.task.target_value = '*1.0*'
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_multichannel_interface1(self):
# Check the multichannel specific tests, passing.
interface = MultiChannelVoltageSourceInterface(task=self.task)
interface.channel = 1
self.task.interface = interface
self.task.target_value = '1.0'
profile = {'Test1': ({'defined_channels': [[1]]},
{})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_true(test)
assert_false(traceback)
def test_check_multichannel_interface2(self):
# Check the multichannel specific tests, failing = driver.
interface = MultiChannelVoltageSourceInterface(task=self.task)
interface.channel = 1
self.task.interface = interface
self.task.target_value = '1.0'
self.root.run_time['drivers'] = {}
profile = {'Test1': ({'defined_channels': [[1]]},
{})}
self.root.run_time['profiles'] = profile
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_multichannel_interface3(self):
# Check the multichannel specific tests, failing =profile.
interface = MultiChannelVoltageSourceInterface(task=self.task)
interface.channel = 1
self.task.interface = interface
self.task.target_value = '1.0'
self.task.selected_profile = ''
self.root.run_time['drivers'] = {'Test': InstrHelper}
test, traceback = self.task.check()
assert_false(test)
assert_equal(len(traceback), 1)
def test_check_multichannel_interface4(self):
# Check the multichannel specific tests, failing = channel.
interface = MultiChannelVoltageSourceInterface(task=self.task)
interface.channel = 2
self.task.interface = interface
self.task.target_value = '1.0'
profile = {'Test1': ({'defined_channels': [[1]]},
{})}
self.root.run_time['profiles'] = profile
self.root.run_time['drivers'] = {'Test': InstrHelper}
test, traceback = self.task.check(test_instr=True)
assert_false(test)
assert_equal(len(traceback), 1)
def test_smooth_set_stopping(self):
self.root.run_time['profiles'] = {'Test1': ({'voltage': [0.0],
'funtion': ['VOLT'],
'owner': [None]}, {})}
self.root.task_database.prepare_for_running()
self.root.should_stop.set()
setter = lambda value: setattr(self.driver, 'voltage', value)
self.task.smooth_set(1.0, setter, 0.0)
assert_equal(self.root.get_from_database('Test_voltage'), 0.0)
def test_perform_base_interface(self):
# Test also that a target which is not a multiple of the back step
# is correctly handled.
self.task.target_value = '0.05'
self.root.run_time['profiles'] = {'Test1': ({'voltage': [0.0],
'funtion': ['VOLT'],
'owner': [None]}, {})}
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_voltage'), 0.05)
self.task.target_value = '1.06'
self.task.perform()
assert_equal(self.root.get_from_database('Test_voltage'), 1.06)
def test_perform_multichannel_interface(self):
interface = MultiChannelVoltageSourceInterface(task=self.task)
interface.channel = 1
self.task.interface = interface
self.task.target_value = '1.0'
profile = {'Test1': ({'voltage': [0.0],
'funtion': ['VOLT'],
'owner': [None]},
{'get_channel': lambda x, i: x}
)}
self.root.run_time['profiles'] = profile
self.root.task_database.prepare_for_running()
self.task.perform()
assert_equal(self.root.get_from_database('Test_voltage'), 1.0)
