def setUp(self) -> None: self.body = DummyPulseTemplate() self.repetitions = 'foo' self.template = RepetitionPulseTemplate( self.body, self.repetitions, parameter_constraints=['foo<9']) self.sequencer = DummySequencer() self.block = DummyInstructionBlock()
def test_build_sequence_constant(self) -> None: repetitions = 3 t = RepetitionPulseTemplate(self.body, repetitions) parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) t.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertEqual([(self.body, parameters, conditions), (self.body, parameters, conditions), (self.body, parameters, conditions)], self.sequencer.sequencing_stacks[self.block])
def test_get_serialization_data_minimal(self) -> None: repetition_count = 3 template = RepetitionPulseTemplate(self.body, repetition_count) expected_data = dict( body=str(id(self.body)), repetition_count=repetition_count, ) data = template.get_serialization_data(self.serializer) self.assertEqual(expected_data, data)
def test_measurement_names(self): measurement_names = {'M'} body = DummyPulseTemplate(measurement_names=measurement_names) t = RepetitionPulseTemplate(body, 9) self.assertEqual(measurement_names, t.measurement_names) t = RepetitionPulseTemplate(body, 9, measurements=[('N', 1, 2)]) self.assertEqual({'M', 'N'}, t.measurement_names)
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_get_serialization_data_constant(self) -> None: repetition_count = 3 template = RepetitionPulseTemplate(self.body, repetition_count) expected_data = dict( type=self.serializer.get_type_identifier(template), body=str(id(self.body)), repetition_count=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_build_sequence_constant(self) -> None: repetitions = 3 t = RepetitionPulseTemplate(self.body, repetitions) parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) t.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertTrue(self.block.embedded_blocks) body_block = self.block.embedded_blocks[0] self.assertEqual({body_block}, set(self.sequencer.sequencing_stacks.keys())) self.assertEqual([(self.body, parameters, conditions)], self.sequencer.sequencing_stacks[body_block]) self.assertEqual([REPJInstruction(repetitions, InstructionPointer(body_block, 0))], self.block.instructions)
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 = 'foo' t = RepetitionPulseTemplate(body, repetition_count) self.assertEqual(repetition_count, t.repetition_count) self.assertEqual(body, t.body) with self.assertRaises(ValueError): RepetitionPulseTemplate(body, Expression(-1))
def test_parameter_not_provided(self): parameters = dict(foo=ConstantParameter(4)) conditions = dict(foo=DummyCondition(requires_stop=True)) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') template = RepetitionPulseTemplate(self.body, 'foo*bar', parameter_constraints=['foo<9']) with self.assertRaises(ParameterNotProvidedException): template.build_sequence(self.sequencer, parameters, conditions, measurement_mapping, channel_mapping, self.block)
def test_get_serialization_data_all_features(self) -> None: repetition_count = 'foo' measurements = [('a', 0, 1), ('b', 1, 1)] parameter_constraints = ['foo < 3'] template = RepetitionPulseTemplate( self.body, repetition_count, measurements=measurements, parameter_constraints=parameter_constraints) expected_data = dict(body=str(id(self.body)), repetition_count=repetition_count, measurements=measurements, parameter_constraints=parameter_constraints) data = template.get_serialization_data(self.serializer) self.assertEqual(expected_data, data)
def test_parameter_names_and_declarations(self) -> None: body = DummyPulseTemplate() t = RepetitionPulseTemplate(body, 5) self.assertEqual(body.parameter_names, t.parameter_names) body.parameter_names_ = {'foo', 't', 'bar'} self.assertEqual(body.parameter_names, t.parameter_names)
def test_requires_stop_declaration(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, ParameterDeclaration('foo')) parameter = DummyParameter() parameters = dict(foo=parameter) condition = DummyCondition() conditions = dict(foo=condition) for body_requires_stop in [True, False]: for condition_requires_stop in [True, False]: for parameter_requires_stop in [True, False]: body.requires_stop_ = body_requires_stop condition.requires_stop_ = condition_requires_stop parameter.requires_stop_ = parameter_requires_stop self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions))
def test_is_interruptable(self) -> None: body = DummyPulseTemplate(is_interruptable=False) t = RepetitionPulseTemplate(body, 6) self.assertFalse(t.is_interruptable) body.is_interruptable_ = True self.assertTrue(t.is_interruptable)
def test_deserialize_minimal(self) -> None: repetition_count = 3 data = dict(repetition_count=repetition_count, body=dict(name=str(id(self.body))), identifier='foo') # prepare dependencies for deserialization self.serializer.subelements[str(id(self.body))] = self.body # deserialize template = RepetitionPulseTemplate.deserialize(self.serializer, **data) # compare! self.assertIs(self.body, template.body) self.assertEqual(repetition_count, template.repetition_count)
def test_deserialize_constant(self) -> None: repetition_count = 3 data = dict( repetition_count=repetition_count, body=dict(name=str(id(self.body))), identifier='foo' ) # prepare dependencies for deserialization self.serializer.subelements[str(id(self.body))] = self.body # deserialize template = RepetitionPulseTemplate.deserialize(self.serializer, **data) # compare! self.assertEqual(self.body, template.body) self.assertEqual(repetition_count, template.repetition_count)
def test_deserialize_all_features(self) -> None: data = dict(repetition_count='foo', body=dict(name=str(id(self.body))), identifier='foo', parameter_constraints=['foo < 3'], measurements=[('a', 0, 1), ('b', 1, 1)]) # prepare dependencies for deserialization self.serializer.subelements[str(id(self.body))] = self.body # deserialize template = RepetitionPulseTemplate.deserialize(self.serializer, **data) # compare! self.assertIs(self.body, template.body) self.assertEqual('foo', template.repetition_count) self.assertEqual(template.parameter_constraints, [ParameterConstraint('foo < 3')]) self.assertEqual(template.measurement_declarations, data['measurements'])
def test_requires_stop_constant(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, 2) self.assertFalse(t.requires_stop({}, {})) body.requires_stop_ = True self.assertFalse(t.requires_stop({}, {}))
class RepetitionPulseTemplateSequencingTests(unittest.TestCase): def test_requires_stop_constant(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, 2) self.assertFalse(t.requires_stop({}, {})) body.requires_stop_ = True self.assertFalse(t.requires_stop({}, {})) def test_requires_stop_declaration(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, ParameterDeclaration('foo')) parameter = DummyParameter() parameters = dict(foo=parameter) condition = DummyCondition() conditions = dict(foo=condition) for body_requires_stop in [True, False]: for condition_requires_stop in [True, False]: for parameter_requires_stop in [True, False]: body.requires_stop_ = body_requires_stop condition.requires_stop_ = condition_requires_stop parameter.requires_stop_ = parameter_requires_stop self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions)) def setUp(self) -> None: self.body = DummyPulseTemplate() self.repetitions = ParameterDeclaration('foo', max=5) self.template = RepetitionPulseTemplate(self.body, self.repetitions) self.sequencer = DummySequencer() self.block = DummyInstructionBlock() def test_build_sequence_constant(self) -> None: repetitions = 3 t = RepetitionPulseTemplate(self.body, repetitions) parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) t.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertTrue(self.block.embedded_blocks) body_block = self.block.embedded_blocks[0] self.assertEqual({body_block}, set(self.sequencer.sequencing_stacks.keys())) self.assertEqual([(self.body, parameters, conditions)], self.sequencer.sequencing_stacks[body_block]) self.assertEqual([REPJInstruction(repetitions, InstructionPointer(body_block, 0))], self.block.instructions) def test_build_sequence_declaration_success(self) -> None: parameters = dict(foo=3) conditions = dict(foo=DummyCondition(requires_stop=True)) self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertTrue(self.block.embedded_blocks) body_block = self.block.embedded_blocks[0] self.assertEqual({body_block}, set(self.sequencer.sequencing_stacks.keys())) self.assertEqual([(self.body, parameters, conditions)], self.sequencer.sequencing_stacks[body_block]) self.assertEqual([REPJInstruction(parameters['foo'], InstructionPointer(body_block, 0))], self.block.instructions) def test_build_sequence_declaration_exceeds_bounds(self) -> None: parameters = dict(foo=9) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterValueIllegalException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_missing(self) -> None: parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotProvidedException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_value_not_whole(self) -> None: parameters = dict(foo=3.3) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotIntegerException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks)
def test_str(self) -> None: body = DummyPulseTemplate() t = RepetitionPulseTemplate(body, 9) self.assertIsInstance(str(t), str) t = RepetitionPulseTemplate(body, ParameterDeclaration('foo')) self.assertIsInstance(str(t), str)
def test_duration(self): body = DummyPulseTemplate(duration='foo') t = RepetitionPulseTemplate(body, 'bar') self.assertEqual(t.duration, Expression('foo*bar'))
class RepetitionPulseTemplateSequencingTests(unittest.TestCase): def test_requires_stop_constant(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, 2) self.assertFalse(t.requires_stop({}, {})) body.requires_stop_ = True self.assertFalse(t.requires_stop({}, {})) def test_requires_stop_declaration(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, 'foo') parameter = DummyParameter() parameters = dict(foo=parameter) condition = DummyCondition() conditions = dict(foo=condition) for body_requires_stop in [True, False]: for condition_requires_stop in [True, False]: for parameter_requires_stop in [True, False]: body.requires_stop_ = body_requires_stop condition.requires_stop_ = condition_requires_stop parameter.requires_stop_ = parameter_requires_stop self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions)) def setUp(self) -> None: self.body = DummyPulseTemplate() self.repetitions = 'foo' self.template = RepetitionPulseTemplate( self.body, self.repetitions, parameter_constraints=['foo<9']) self.sequencer = DummySequencer() self.block = DummyInstructionBlock() def test_build_sequence_constant(self) -> None: repetitions = 3 t = RepetitionPulseTemplate(self.body, repetitions) parameters = {} measurement_mapping = {'my': 'thy'} conditions = dict(foo=DummyCondition(requires_stop=True)) channel_mapping = {} t.build_sequence(self.sequencer, parameters, conditions, measurement_mapping, channel_mapping, self.block) self.assertTrue(self.block.embedded_blocks) body_block = self.block.embedded_blocks[0] self.assertEqual({body_block}, set(self.sequencer.sequencing_stacks.keys())) self.assertEqual([(self.body, parameters, conditions, measurement_mapping, channel_mapping)], self.sequencer.sequencing_stacks[body_block]) self.assertEqual( [REPJInstruction(repetitions, InstructionPointer(body_block, 0))], self.block.instructions) def test_build_sequence_declaration_success(self) -> None: parameters = dict(foo=ConstantParameter(3)) conditions = dict(foo=DummyCondition(requires_stop=True)) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') self.template.build_sequence(self.sequencer, parameters, conditions, measurement_mapping, channel_mapping, self.block) self.assertTrue(self.block.embedded_blocks) body_block = self.block.embedded_blocks[0] self.assertEqual({body_block}, set(self.sequencer.sequencing_stacks.keys())) self.assertEqual([(self.body, parameters, conditions, measurement_mapping, channel_mapping)], self.sequencer.sequencing_stacks[body_block]) self.assertEqual( [REPJInstruction(3, InstructionPointer(body_block, 0))], self.block.instructions) def test_parameter_not_provided(self): parameters = dict(foo=ConstantParameter(4)) conditions = dict(foo=DummyCondition(requires_stop=True)) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') template = RepetitionPulseTemplate(self.body, 'foo*bar', parameter_constraints=['foo<9']) with self.assertRaises(ParameterNotProvidedException): template.build_sequence(self.sequencer, parameters, conditions, measurement_mapping, channel_mapping, self.block) def test_build_sequence_declaration_exceeds_bounds(self) -> None: parameters = dict(foo=ConstantParameter(9)) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterConstraintViolation): self.template.build_sequence(self.sequencer, parameters, conditions, {}, {}, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_missing(self) -> None: parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotProvidedException): self.template.build_sequence(self.sequencer, parameters, conditions, {}, {}, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_value_not_whole( self) -> None: parameters = dict(foo=ConstantParameter(3.3)) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotIntegerException): self.template.build_sequence(self.sequencer, parameters, conditions, {}, {}, self.block) self.assertFalse(self.sequencer.sequencing_stacks)
def setUp(self) -> None: self.body = DummyPulseTemplate() self.repetitions = ParameterDeclaration('foo', max=5) self.template = RepetitionPulseTemplate(self.body, self.repetitions) self.sequencer = DummySequencer() self.block = DummyInstructionBlock()
class RepetitionPulseTemplateSequencingTests(unittest.TestCase): def test_requires_stop_constant(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, 2) self.assertFalse(t.requires_stop({}, {})) body.requires_stop_ = True self.assertFalse(t.requires_stop({}, {})) def test_requires_stop_declaration(self) -> None: body = DummyPulseTemplate(requires_stop=False) t = RepetitionPulseTemplate(body, ParameterDeclaration('foo')) parameter = DummyParameter() parameters = dict(foo=parameter) condition = DummyCondition() conditions = dict(foo=condition) for body_requires_stop in [True, False]: for condition_requires_stop in [True, False]: for parameter_requires_stop in [True, False]: body.requires_stop_ = body_requires_stop condition.requires_stop_ = condition_requires_stop parameter.requires_stop_ = parameter_requires_stop self.assertEqual(parameter_requires_stop, t.requires_stop(parameters, conditions)) def setUp(self) -> None: self.body = DummyPulseTemplate() self.repetitions = ParameterDeclaration('foo', max=5) self.template = RepetitionPulseTemplate(self.body, self.repetitions) self.sequencer = DummySequencer() self.block = DummyInstructionBlock() def test_build_sequence_constant(self) -> None: repetitions = 3 t = RepetitionPulseTemplate(self.body, repetitions) parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) t.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertEqual([(self.body, parameters, conditions), (self.body, parameters, conditions), (self.body, parameters, conditions)], self.sequencer.sequencing_stacks[self.block]) def test_build_sequence_declaration_success(self) -> None: parameters = dict(foo=3) conditions = dict(foo=DummyCondition(requires_stop=True)) self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertEqual([(self.body, parameters, conditions), (self.body, parameters, conditions), (self.body, parameters, conditions)], self.sequencer.sequencing_stacks[self.block]) def test_build_sequence_declaration_exceeds_bounds(self) -> None: parameters = dict(foo=9) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterValueIllegalException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_missing(self) -> None: parameters = {} conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotProvidedException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks) def test_build_sequence_declaration_parameter_value_not_whole(self) -> None: parameters = dict(foo=3.3) conditions = dict(foo=DummyCondition(requires_stop=True)) with self.assertRaises(ParameterNotIntegerException): self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(self.sequencer.sequencing_stacks)
def test_str(self) -> None: body = DummyPulseTemplate() t = RepetitionPulseTemplate(body, 9) self.assertIsInstance(str(t), str) t = RepetitionPulseTemplate(body, 'foo') self.assertIsInstance(str(t), str)