def test_deserialize(self) -> None: data = dict(is_measurement_pulse=True, time_parameter_declarations=[dict(name='hugo'), dict(name='foo')], voltage_parameter_declarations=[dict(name='ilse')], entries=[[(0, 0, 'hold'), ('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')]], identifier='foo') # prepare dependencies for deserialization self.serializer.subelements['foo'] = ParameterDeclaration('foo') self.serializer.subelements['hugo'] = ParameterDeclaration('hugo') self.serializer.subelements['ilse'] = ParameterDeclaration('ilse') # deserialize template = TablePulseTemplate.deserialize(self.serializer, **data) # prepare expected parameter declarations self.serializer.subelements['foo'].min_value = 0 self.serializer.subelements['foo'].max_value = self.serializer.subelements['hugo'] all_declarations = set(self.serializer.subelements.values()) # prepare expected entries entries = [[(0, 0, HoldInterpolationStrategy()), (self.serializer.subelements['foo'], 2, HoldInterpolationStrategy()), (self.serializer.subelements['hugo'], self.serializer.subelements['ilse'], LinearInterpolationStrategy())]] # compare! self.assertEqual(all_declarations, template.parameter_declarations) self.assertEqual({'foo', 'hugo', 'ilse'}, template.parameter_names) self.assertEqual(entries, template.entries) self.assertEqual('foo', template.identifier)
def test_get_entries_instantiated_two_entries_parameter_missing(self) -> None: table = TablePulseTemplate() t_decl = ParameterDeclaration('t', min=1, max=2) v2_decl = ParameterDeclaration('v2', min=10, max=30) table.add_entry(t_decl, v2_decl) with self.assertRaises(ParameterNotProvidedException): table.get_entries_instantiated(dict())
def __test_valid_values(self, **kwargs): expected_values = {'min': float('-inf'), 'max': float('+inf'), 'default': None} for k in kwargs: expected_values[k] = kwargs[k] expected_values['absolute_min'] = expected_values['min'] expected_values['absolute_max'] = expected_values['max'] if isinstance(expected_values['absolute_min'], ParameterDeclaration): expected_values['absolute_min'] = expected_values['absolute_min'].absolute_min_value if isinstance(expected_values['absolute_max'], ParameterDeclaration): expected_values['absolute_max'] = expected_values['absolute_max'].absolute_max_value decl = ParameterDeclaration('test', **kwargs) self.assertEqual('test', decl.name) self.assertEqual(expected_values['min'], decl.min_value) self.assertEqual(expected_values['max'], decl.max_value) self.assertEqual(expected_values['default'], decl.default_value) self.assertEqual(expected_values['absolute_min'], decl.absolute_min_value) self.assertEqual(expected_values['absolute_max'], decl.absolute_max_value) decl = ParameterDeclaration('test', default=expected_values['default']) if 'min' in kwargs: decl.min_value = kwargs['min'] if 'max' in kwargs: decl.max_value = kwargs['max'] self.assertEqual(expected_values['min'], decl.min_value) self.assertEqual(expected_values['max'], decl.max_value) self.assertEqual(expected_values['default'], decl.default_value) self.assertEqual(expected_values['absolute_min'], decl.absolute_min_value) self.assertEqual(expected_values['absolute_max'], decl.absolute_max_value)
def test_add_entry_empty_time_is_declaration(self) -> None: table = TablePulseTemplate() decl = ParameterDeclaration('foo') table.add_entry(decl, 0) decl.min_value = 0 self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_empty_time_is_declaration(self) -> None: table = TablePulseTemplate() decl = ParameterDeclaration('foo') table.add_entry(decl, 0) decl.min_value = 0 self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 0, HoldInterpolationStrategy())], table.entries) self.assertEqual({'foo'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_float_after_declaration_greater_bound(self) -> None: table = TablePulseTemplate() decl = ParameterDeclaration('t', max=3.4) table.add_entry(decl, 7.1) table.add_entry(2.1, 5.5) expected_decl = ParameterDeclaration('t', min=0, max=2.1) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (expected_decl, 7.1, HoldInterpolationStrategy()), (2.1, 5.5, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'t'}, table.parameter_names) self.assertEqual({expected_decl}, table.parameter_declarations)
def test_add_entry_time_float_after_declaration_greater_bound(self) -> None: table = TablePulseTemplate() decl = ParameterDeclaration('t', max=3.4) table.add_entry(decl, 7.1) decl.min_value = 0 self.assertRaises(ValueError, table.add_entry, 2.1, 5.5) self.assertEqual([(0, 0, HoldInterpolationStrategy()), (decl, 7.1, HoldInterpolationStrategy())], table.entries) self.assertEqual({'t'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_bound_after_declaration_upper_bound(self) -> None: table = TablePulseTemplate() bar_decl = ParameterDeclaration('bar', min=1, max=2) foo_decl = ParameterDeclaration('foo', min=1) table.add_entry(bar_decl, -3) table.add_entry(foo_decl, 0.1) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo', 'bar'}, table.parameter_names) self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
class ParameterDeclarationSerializationTests(unittest.TestCase): def setUp(self) -> None: self.serializer = DummySerializer() self.declaration = ParameterDeclaration('foo') self.expected_data = dict(name='foo', type=self.serializer.get_type_identifier(self.declaration)) def test_get_serialization_data_all_default(self) -> None: self.expected_data['min_value'] = float('-inf') self.expected_data['max_value'] = float('+inf') self.expected_data['default_value'] = None self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer)) def test_get_serialization_data_all_floats(self) -> None: self.declaration = ParameterDeclaration('foo', min=-3.1, max=4.3, default=0.2) self.expected_data['min_value'] = -3.1 self.expected_data['max_value'] = 4.3 self.expected_data['default_value'] = 0.2 self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer)) def test_get_serialization_data_min_max_references(self) -> None: bar_min = ParameterDeclaration('bar_min') bar_max = ParameterDeclaration('bar_max') self.declaration.min_value = bar_min self.declaration.max_value = bar_max self.expected_data['min_value'] = 'bar_min' self.expected_data['max_value'] = 'bar_max' self.expected_data['default_value'] = None self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer)) def test_deserialize_all_default(self) -> None: data = dict(min_value=float('-inf'), max_value=float('+inf'), default_value=None, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(data['min_value'], declaration.min_value) self.assertEqual(data['max_value'], declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier) def test_deserialize_all_floats(self) -> None: data = dict(min_value=33.3, max_value=44, default_value=41.1, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(data['min_value'], declaration.min_value) self.assertEqual(data['max_value'], declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier) def test_deserialize_min_max_references(self) -> None: data = dict(min_value='bar_min', max_value='bar_max', default_value=-23.5, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(float('-inf'), declaration.min_value) self.assertEqual(float('+inf'), declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier)
def test_add_entry_time_parmeter_name_in_use_as_time(self) -> None: table = TablePulseTemplate() table.add_entry('foo', 'bar') foo_decl = ParameterDeclaration('foo', min=0) bar_decl = ParameterDeclaration('bar') with self.assertRaises(ValueError): table.add_entry(ParameterDeclaration('foo'), 3.4) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, bar_decl, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo', 'bar'}, table.parameter_names) self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None: table = TablePulseTemplate() table.add_entry('bar', 72.14) table.add_entry('foo', 0) bar_decl = ParameterDeclaration('bar', min=0) foo_decl = ParameterDeclaration('foo') foo_decl.min_value = bar_decl self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'bar', 'foo'}, table.parameter_names) self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)
def test_internal_set_value_exception_branches(self) -> None: foo = ParameterDeclaration('foo', min=2.1, max=2.6) bar = ParameterDeclaration('bar', min=foo, max=foo) with self.assertRaises(ValueError): ParameterDeclaration('foobar', min=3.1, max=bar) bar = ParameterDeclaration('bar', min=foo, max=foo) foobar = ParameterDeclaration('foobar', max=1.1) with self.assertRaises(ValueError): self.__assign_min_value(foobar, bar)
def test_add_entry_time_declaration_after_declaration_no_upper_bound(self) -> None: table = TablePulseTemplate() table.add_entry('bar', 72.14) table.add_entry('foo', 0) bar_decl = ParameterDeclaration('bar', min=0) foo_decl = ParameterDeclaration('foo') foo_decl.min_value = bar_decl self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, 72.14, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())], table.entries) self.assertEqual({'bar', 'foo'}, table.parameter_names) self.assertEqual({bar_decl, foo_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_after_declaration_upper_bound(self) -> None: table = TablePulseTemplate() bar_decl = ParameterDeclaration('bar', min=1, max=2) foo_decl = ParameterDeclaration('foo') table.add_entry(bar_decl, -3) table.add_entry(foo_decl, 0.1) foo_decl.min_value = bar_decl self.assertEqual([(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy()), (foo_decl, 0.1, HoldInterpolationStrategy())], table.entries) self.assertEqual({'foo', 'bar'}, table.parameter_names) self.assertEqual({foo_decl, bar_decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_bound_upper_bound_too_small_after_declaration(self) -> None: table = TablePulseTemplate() bar_decl = ParameterDeclaration('bar', min=1, max=2) foo_decl = ParameterDeclaration('foo', min=1, max=1.5) table.add_entry(bar_decl, -3) with self.assertRaises(ValueError): table.add_entry(foo_decl, 0.1) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (bar_decl, -3, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'bar'}, table.parameter_names) self.assertEqual({bar_decl}, table.parameter_declarations)
def test_get_entries_instantiated_unlinked_time_declarations(self) -> None: table = TablePulseTemplate() foo_decl = ParameterDeclaration('foo', min=1, max=2) bar_decl = ParameterDeclaration('bar', min=1.5, max=4) table.add_entry(foo_decl, 'v', 'linear') table.add_entry(bar_decl, 0, 'jump') instantiated_entries = table.get_entries_instantiated({'v': 2.3, 'foo': 1, 'bar': 4}) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy())]], instantiated_entries) with self.assertRaises(Exception): table.get_entries_instantiated({'v': 2.3, 'foo': 2, 'bar': 1.5})
def test_get_entries_instantiated_two_entries_invalid_parameters(self) -> None: table = TablePulseTemplate() table.add_entry(0, 'v1') t_decl = ParameterDeclaration('t', min=1, max=2) v2_decl = ParameterDeclaration('v2', min=10, max=30) table.add_entry(t_decl, v2_decl) with self.assertRaises(ParameterValueIllegalException): table.get_entries_instantiated({'v1': -5, 't': 0, 'v2': 20}) with self.assertRaises(ParameterValueIllegalException): table.get_entries_instantiated({'v1': -5, 't': 1, 'v2': -20})
def test_add_entry_time_declaration_invalid_bounds(self) -> None: table = TablePulseTemplate() bar_decl = ParameterDeclaration('bar') foo_decl = ParameterDeclaration('foo') foo_decl.min_value = bar_decl self.assertRaises(ValueError, table.add_entry, foo_decl, 23857.23) self.assertRaises(ValueError, table.add_entry, bar_decl, -4967.1) self.assertFalse(table.entries) self.assertFalse(table.parameter_names) self.assertFalse(table.parameter_declarations)
def test_get_serialization_data_min_max_references(self) -> None: bar_min = ParameterDeclaration('bar_min') bar_max = ParameterDeclaration('bar_max') self.declaration.min_value = bar_min self.declaration.max_value = bar_max self.expected_data['min_value'] = 'bar_min' self.expected_data['max_value'] = 'bar_max' self.expected_data['default_value'] = None self.assertEqual( self.expected_data, self.declaration.get_serialization_data(self.serializer))
def test_get_serialization_data_all_floats(self) -> None: self.declaration = ParameterDeclaration('foo', min=-3.1, max=4.3, default=0.2) self.expected_data['min_value'] = -3.1 self.expected_data['max_value'] = 4.3 self.expected_data['default_value'] = 0.2 self.assertEqual( self.expected_data, self.declaration.get_serialization_data(self.serializer))
def test_requires_stop_true_mapped_parameters(self) -> None: dummy = DummyPulseTemplate(parameter_names={'foo'}, requires_stop=True) pulse = MultiChannelPulseTemplate([(dummy, dict(foo='2*bar'), [0]), (dummy, dict(foo='rab-5'), [1])], {'bar', 'rab'}) self.assertEqual({'bar', 'rab'}, pulse.parameter_names) self.assertEqual( {ParameterDeclaration('bar'), ParameterDeclaration('rab')}, pulse.parameter_declarations) parameters = dict(bar=ConstantParameter(-3.6), rab=ConstantParameter(35.26)) self.assertTrue(pulse.requires_stop(parameters, dict()))
def test_add_entry_time_declaration_invalid_bounds(self) -> None: table = TablePulseTemplate() bar_decl = ParameterDeclaration('bar') foo_decl = ParameterDeclaration('foo') foo_decl.min_value = bar_decl with self.assertRaises(ValueError): table.add_entry(foo_decl, 23857.23) with self.assertRaises(ValueError): table.add_entry(bar_decl, -4967.1) self.assertEquals([[TableEntry(0, 0, HoldInterpolationStrategy())]], table.entries) self.assertFalse(table.parameter_names) self.assertFalse(table.parameter_declarations)
def test_add_entry_voltage_declaration_reuse(self) -> None: table = TablePulseTemplate() foo_decl = ParameterDeclaration('foo', min=0, max=3.3) bar_decl = ParameterDeclaration('bar', min=-3.3, max=1.15) table.add_entry(0, foo_decl) table.add_entry(1.51, bar_decl) table.add_entry(3, 'foo') table.add_entry('t', foo_decl) t_decl = ParameterDeclaration('t', min=3) self.assertEqual([[(0, foo_decl, HoldInterpolationStrategy()), (1.51, bar_decl, HoldInterpolationStrategy()), (3, foo_decl, HoldInterpolationStrategy()), (t_decl, foo_decl, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo', 'bar', 't'}, table.parameter_names) self.assertEqual({foo_decl, bar_decl, t_decl}, table.parameter_declarations)
def test_deserialize(self) -> None: dummy1 = DummyPulseTemplate(parameter_names={'foo'}, num_channels=2) dummy2 = DummyPulseTemplate(parameter_names={}, num_channels=1) exp = Expression("bar - 35") data = dict(external_parameters=['bar'], subtemplates=[ dict(template=str(id(dummy1)), parameter_mappings=dict(foo=str(exp)), channel_mappings=[0, 2]), dict(template=str(id(dummy2)), parameter_mappings=dict(), channel_mappings=[1]) ]) serializer = DummySerializer(serialize_callback=lambda x: str(x) if isinstance(x, Expression) else str(id(x))) serializer.subelements[str(id(dummy1))] = dummy1 serializer.subelements[str(id(dummy2))] = dummy2 serializer.subelements[str(exp)] = exp template = MultiChannelPulseTemplate.deserialize(serializer, **data) self.assertEqual(set(data['external_parameters']), template.parameter_names) self.assertEqual({ParameterDeclaration('bar')}, template.parameter_declarations) recovered_data = template.get_serialization_data(serializer) self.assertEqual(data, recovered_data)
def test_requires_stop(self) -> None: table = TablePulseTemplate() foo_decl = ParameterDeclaration('foo', min=1) bar_decl = ParameterDeclaration('bar') table.add_entry(foo_decl, 'v', 'linear') table.add_entry(bar_decl, 0, 'jump') test_sets = [(False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}), (False, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, False)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, False), 'bar': DummyParameter(0, False), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(False)}), (True, {'foo': DummyParameter(0, True), 'bar': DummyParameter(0, True), 'v': DummyParameter(0, True)}, {'foo': DummyCondition(True)})] for expected_result, parameter_set, condition_set in test_sets: self.assertEqual(expected_result, table.requires_stop(parameter_set, condition_set))
def test_add_entry_empty_time_is_0_voltage_is_parameter(self) -> None: table = TablePulseTemplate() table.add_entry(0, 'foo') decl = ParameterDeclaration('foo') self.assertEqual([[(0, decl, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_higher_min_after_float(self) -> None: table = TablePulseTemplate() table.add_entry(3.2, 92.1) decl = ParameterDeclaration('t', min=4.5) table.add_entry(decl, 1.2) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy()), (decl, 1.2, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'t'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_deserialize_all_default(self) -> None: data = dict(min_value=float('-inf'), max_value=float('+inf'), default_value=None, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(data['min_value'], declaration.min_value) self.assertEqual(data['max_value'], declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier)
def test_parameter_names_and_declarations_string_input(self) -> None: template = FunctionPulseTemplate("3 * foo + bar * t", "5 * hugo") expected_parameter_names = {'foo', 'bar', 'hugo'} self.assertEqual(expected_parameter_names, template.parameter_names) self.assertEqual( {ParameterDeclaration(name) for name in expected_parameter_names}, template.parameter_declarations)
def test_deserialize_all_floats(self) -> None: data = dict(min_value=33.3, max_value=44, default_value=41.1, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(data['min_value'], declaration.min_value) self.assertEqual(data['max_value'], declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier)
def test_deserialize_min_max_references(self) -> None: data = dict(min_value='bar_min', max_value='bar_max', default_value=-23.5, name='foo') declaration = ParameterDeclaration.deserialize(self.serializer, **data) self.assertEqual(float('-inf'), declaration.min_value) self.assertEqual(float('+inf'), declaration.max_value) self.assertEqual(data['default_value'], declaration.default_value) self.assertEqual(data['name'], declaration.name) self.assertIsNone(declaration.identifier)
def test_build_sequence(self) -> None: table = TablePulseTemplate() foo_decl = ParameterDeclaration('foo', min=1) bar_decl = ParameterDeclaration('bar') table.add_entry(foo_decl, 'v', 'linear') table.add_entry(bar_decl, 0, 'jump') parameters = {'v': 2.3, 'foo': 1, 'bar': 4} instantiated_entries = tuple(table.get_entries_instantiated(parameters)) waveform = table.build_waveform(parameters) sequencer = DummySequencer() instruction_block = DummyInstructionBlock() table.build_sequence(sequencer, parameters, {}, instruction_block) expected_waveform = TableWaveform(instantiated_entries) self.assertEqual(1, len(instruction_block.instructions)) instruction = instruction_block.instructions[0] self.assertIsInstance(instruction, EXECInstruction) self.assertEqual(expected_waveform, instruction.waveform) self.assertEqual(expected_waveform, waveform)
def test_add_entry_time_float_after_declaration_smaller_than_min_bound(self) -> None: table = TablePulseTemplate() decl = ParameterDeclaration('t', min=1.2, max=83456.2) table.add_entry(decl, 2.2) with self.assertRaises(ValueError): table.add_entry(1.1, -6.3) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (decl, 2.2, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'t'}, table.parameter_names) self.assertEqual({decl}, table.parameter_declarations)
def test_add_entry_time_declaration_lower_min_after_float(self) -> None: table = TablePulseTemplate() table.add_entry(3.2, 92.1) decl = ParameterDeclaration('t', min=0.1) with self.assertRaises(ValueError): table.add_entry(decl, 1.2) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (3.2, 92.1, HoldInterpolationStrategy())]], table.entries) self.assertFalse(table.parameter_names) self.assertFalse(table.parameter_declarations)
def test_add_entry_voltage_declaration_in_use_as_time(self) -> None: table = TablePulseTemplate() foo_decl = ParameterDeclaration('foo', min=0, max=2) table.add_entry(foo_decl, 0) with self.assertRaises(ValueError): table.add_entry(4, foo_decl) self.assertEqual([[(0, 0, HoldInterpolationStrategy()), (foo_decl, 0, HoldInterpolationStrategy())]], table.entries) self.assertEqual({'foo'}, table.parameter_names) self.assertEqual({foo_decl}, table.parameter_declarations)
def test_get_serialization_data_declaration(self) -> None: repetition_count = ParameterDeclaration('foo') template = RepetitionPulseTemplate(self.body, repetition_count) expected_data = dict( type=self.serializer.get_type_identifier(template), body=str(id(self.body)), repetition_count=str(id(repetition_count)) ) data = template.get_serialization_data(self.serializer) self.assertEqual(expected_data, data)
def test_init(self) -> None: body = DummyPulseTemplate() repetition_count = 3 t = RepetitionPulseTemplate(body, repetition_count) self.assertEqual(repetition_count, t.repetition_count) self.assertEqual(body, t.body) repetition_count = ParameterDeclaration('foo') t = RepetitionPulseTemplate(body, repetition_count) self.assertEqual(repetition_count, t.repetition_count) self.assertEqual(body, t.body)
def test_get_value(self) -> None: decl = ParameterDeclaration('foo') foo_param = ConstantParameter(2.1) self.assertEqual(foo_param.get_value(), decl.get_value({'foo': foo_param})) self.assertRaises(ParameterNotProvidedException, decl.get_value, {}) decl = ParameterDeclaration('foo', default=2.7) self.assertEqual(decl.default_value, decl.get_value({})) decl = ParameterDeclaration('foo', min=1.3) self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)})) self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)})) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(1.1)}) decl = ParameterDeclaration('foo', max=2.3) self.assertTrue(1.4, decl.get_value({'foo': ConstantParameter(1.4)})) self.assertTrue(2.3, decl.get_value({'foo': ConstantParameter(2.3)})) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)}) decl = ParameterDeclaration('foo', min=1.3, max=2.3) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(0.9)}) self.assertEqual(1.3, decl.get_value({'foo': ConstantParameter(1.3)})) self.assertEqual(1.4, decl.get_value({'foo': ConstantParameter(1.4)})) self.assertEqual(2.3, decl.get_value({'foo': ConstantParameter(2.3)})) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'foo': ConstantParameter(3.1)}) min_decl = ParameterDeclaration('min', min=1.2, max=2.3) max_decl = ParameterDeclaration('max', min=1.2, max=5.1) min_param = ConstantParameter(1.3) max_param = ConstantParameter(2.3) decl = ParameterDeclaration('foo', min=min_decl, max=max_decl) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(0.9)}) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.2)}) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.25)}) self.assertEqual(1.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.3)})) self.assertEqual(1.7, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(1.7)})) self.assertEqual(2.3, decl.get_value({'min': min_param, 'max': max_param, 'foo': ConstantParameter(2.3)})) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(3.5)}) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(5.1)}) self.assertRaises(ParameterValueIllegalException, decl.get_value, {'min': min_param, 'max': max_param, 'foo': ConstantParameter(17.2)})
def test_is_parameter_valid_no_bounds(self) -> None: decl = ParameterDeclaration('foo') param = ConstantParameter(2.4) self.assertTrue(decl.is_parameter_valid(param))
def test_is_parameter_valid_min_max_bound(self) -> None: decl = ParameterDeclaration('foobar', min=-0.1, max=13.2) params = [(False, -0.5), (True, -0.1), (True, 0), (True, 7.9), (True, 13.2), (False, 17.3)] for expected, param in params: self.assertEqual(expected, decl.is_parameter_valid(param))
def setUp(self) -> None: self.serializer = DummySerializer() self.declaration = ParameterDeclaration('foo') self.expected_data = dict(name='foo', type=self.serializer.get_type_identifier(self.declaration))
def test_get_serialization_data_all_floats(self) -> None: self.declaration = ParameterDeclaration('foo', min=-3.1, max=4.3, default=0.2) self.expected_data['min_value'] = -3.1 self.expected_data['max_value'] = 4.3 self.expected_data['default_value'] = 0.2 self.assertEqual(self.expected_data, self.declaration.get_serialization_data(self.serializer))
def __min_assignment(self, decl: ParameterDeclaration, value: Union[ParameterDeclaration, float]) -> None: decl.min_value = value
def __assign_min_value(self, left_value: ParameterDeclaration, right_value: ParameterDeclaration) -> None: left_value.min_value = right_value