def test_requires_stop(self) -> None: condition = DummyCondition(requires_stop=False) conditions = {'foo_cond': condition} body = DummyPulseTemplate(requires_stop=False) t = LoopPulseTemplate('foo_cond', body) self.assertFalse(t.requires_stop({}, conditions)) condition.requires_stop_ = True self.assertTrue(t.requires_stop({}, conditions)) body.requires_stop_ = True condition.requires_stop_ = False self.assertFalse(t.requires_stop({}, conditions))
def test_build_waveform_none(self): wfs = [ DummyWaveform(duration=1.1, defined_channels={'A'}), DummyWaveform(duration=1.1, defined_channels={'B'}) ] sts = [ DummyPulseTemplate(duration='t1', defined_channels={'A'}, waveform=wfs[0]), DummyPulseTemplate(duration='t1', defined_channels={'B'}, waveform=wfs[1]), DummyPulseTemplate(duration='t1', defined_channels={'C'}, waveform=None) ] pt = AtomicMultiChannelPulseTemplate(*sts, parameter_constraints=['a < b']) parameters = dict(a=2.2, b=1.1, c=3.3) channel_mapping = dict(A=6) with self.assertRaises(ParameterConstraintViolation): # parameter constraints are checked before channel mapping is applied pt.build_waveform(parameters, channel_mapping=dict()) parameters['a'] = 0.5 wf = pt.build_waveform(parameters, channel_mapping=channel_mapping) self.assertIs(wf['A'], wfs[0]) self.assertIs(wf['B'], wfs[1]) sts[1].waveform = None wf = pt.build_waveform(parameters, channel_mapping=channel_mapping) self.assertIs(wf, wfs[0]) sts[0].waveform = None wf = pt.build_waveform(parameters, channel_mapping=channel_mapping) self.assertIsNone(wf)
def test_get_serialization_data(self) -> None: body = DummyPulseTemplate() condition_name = 'foo_cond' identifier = 'foo_loop' t = LoopPulseTemplate(condition_name, body, identifier=identifier) serializer = DummySerializer() expected_data = dict(type=serializer.get_type_identifier(t), body=str(id(body)), condition=condition_name) data = t.get_serialization_data(serializer) self.assertEqual(expected_data, data)
def test_deserialize(self): sts = [DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}), DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'})] def deserialization_callback(ident: str): self.assertIn(ident, ('0', '1')) if ident == '0': return 0 else: return 1 serializer = DummySerializer(deserialize_callback=deserialization_callback) serializer.subelements = sts data = dict(subtemplates=['0', '1'], parameter_constraints=['a < d']) template = AtomicMultiChannelPulseTemplate.deserialize(serializer, **data) self.assertIs(template.subtemplates[0], sts[0]) self.assertIs(template.subtemplates[1], sts[1]) self.assertEqual(template.parameter_constraints, [ParameterConstraint('a < d')])
def test_internal_create_program(self): lhs = 'x + y' rhs = DummyPulseTemplate(defined_channels={'u', 'v', 'w'}) arith = ArithmeticPulseTemplate(lhs, '-', rhs) scope = DictScope.from_kwargs(x=3, y=5, z=8, volatile={'some_parameter'}) channel_mapping = dict(u='a', v='b', w=None) measurement_mapping = dict(m1='m2') global_transformation = OffsetTransformation({'unrelated': 1.}) to_single_waveform = {'something_else'} parent_loop = mock.Mock() expected_transformation = mock.Mock(spec=IdentityTransformation()) inner_trafo = mock.Mock(spec=IdentityTransformation()) inner_trafo.chain.return_value = expected_transformation with mock.patch.object(rhs, '_create_program') as inner_create_program: with mock.patch.object( arith, '_get_transformation', return_value=inner_trafo) as get_transformation: arith._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) get_transformation.assert_called_once_with( parameters=scope, channel_mapping=channel_mapping) inner_trafo.chain.assert_called_once_with(global_transformation) inner_create_program.assert_called_once_with( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=expected_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) with self.assertRaisesRegex(NotImplementedError, 'volatile'): arith._internal_create_program( scope=DictScope.from_kwargs(x=3, y=5, z=8, volatile={'x'}), measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop)
def test_create_program_subtemplate_none(self) -> None: measurement_mapping = {'meas1': 'meas2'} parameter_mapping = {'t': 'k'} channel_mapping = {'B': 'default'} template = DummyPulseTemplate(measurements=[('meas1', 0, 1)], measurement_names={'meas1'}, defined_channels={'B'}, waveform=None, duration=0, parameter_names={'t'}) st = MappingPulseTemplate(template, parameter_mapping=parameter_mapping, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping) pre_parameters = {'k': ConstantParameter(5)} pre_measurement_mapping = {'meas2': 'meas3'} pre_channel_mapping = {'default': 'A'} program = Loop() st._internal_create_program( parameters=pre_parameters, measurement_mapping=pre_measurement_mapping, channel_mapping=pre_channel_mapping, to_single_waveform=set(), global_transformation=None, parent_loop=program) self.assertEqual(1, len(template.create_program_calls)) self.assertEqual( (st.map_parameters(pre_parameters), st.get_updated_measurement_mapping(pre_measurement_mapping), st.get_updated_channel_mapping(pre_channel_mapping), program), template.create_program_calls[-1]) self.assertEqual(1, program.repetition_count) self.assertEqual(0, len(program.children)) self.assertIsNone(program._measurements) # ensure same result as from Sequencer sequencer = Sequencer() sequencer.push(st, parameters=pre_parameters, conditions={}, window_mapping=pre_measurement_mapping, channel_mapping=pre_channel_mapping) block = sequencer.build() program_old = MultiChannelProgram( block, channels={'A'}).programs[frozenset({'A'})] self.assertEqual(program_old, program)
def test_init(self): lhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'b'}, parameter_names={'x', 'y'}) rhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'c'}, parameter_names={'x', 'z'}) with self.assertRaisesRegex(TypeError, 'needs to be a pulse template'): ArithmeticPulseTemplate('a', '+', 'b') with self.assertRaisesRegex(TypeError, 'two PulseTemplates'): ArithmeticPulseTemplate(lhs, '+', rhs) with self.assertRaisesRegex(ValueError, r'Operands \(scalar, PulseTemplate\) require'): ArithmeticPulseTemplate(4, '/', rhs) with self.assertRaisesRegex(ValueError, r'Operands \(PulseTemplate, scalar\) require'): ArithmeticPulseTemplate(lhs, '%', 4) scalar = mock.Mock() non_pt = mock.Mock() with mock.patch.object(ArithmeticPulseTemplate, '_parse_operand', return_value=scalar) as parse_operand: arith = ArithmeticPulseTemplate(lhs, '/', non_pt) parse_operand.assert_called_once_with(non_pt, lhs.defined_channels) self.assertEqual(lhs, arith.lhs) self.assertEqual(scalar, arith.rhs) self.assertEqual(lhs, arith._pulse_template) self.assertEqual(scalar, arith._scalar) self.assertEqual('/', arith._arithmetic_operator) with mock.patch.object(ArithmeticPulseTemplate, '_parse_operand', return_value=scalar) as parse_operand: arith = ArithmeticPulseTemplate(non_pt, '-', rhs) parse_operand.assert_called_once_with(non_pt, rhs.defined_channels) self.assertEqual(scalar, arith.lhs) self.assertEqual(rhs, arith.rhs) self.assertEqual(rhs, arith._pulse_template) self.assertEqual(scalar, arith._scalar) self.assertEqual('-', arith._arithmetic_operator)
def test_get_updated_channel_mapping(self): template = DummyPulseTemplate(defined_channels={'foo', 'bar'}) st = MappingPulseTemplate(template, channel_mapping={'bar': 'kneipe'}) with self.assertRaises(KeyError): st.get_updated_channel_mapping(dict()) self.assertEqual( st.get_updated_channel_mapping({ 'kneipe': 'meas1', 'foo': 'meas2', 'troet': 'meas3' }), { 'foo': 'meas2', 'bar': 'meas1' })
def test_drop_channel(self): dummy = DummyPulseTemplate(defined_channels={'A', 'B', 'C', 'D'}, parameter_names={'k', 'f', 'b'}) pulse = MappingPulseTemplate(dummy, parameter_mapping={ 'k': 'f', 'b': 2.3 }, channel_mapping={ 'A': 'a', 'C': None, 'D': None }) self.assertEqual({'a', 'B'}, pulse.defined_channels)
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_build_sequence(self) -> None: dummy_wf1 = DummyWaveform(duration=2.3, num_channels=2) dummy_wf2 = DummyWaveform(duration=2.3, num_channels=1) dummy1 = DummyPulseTemplate(parameter_names={'foo'}, num_channels=2, waveform=dummy_wf1) dummy2 = DummyPulseTemplate(parameter_names={}, num_channels=1, waveform=dummy_wf2) pulse = MultiChannelPulseTemplate([(dummy1, { 'foo': '2*bar' }, [2, 1]), (dummy2, {}, [0])], {'bar'}) result = pulse.build_waveform({'bar': ConstantParameter(3)}) expected = MultiChannelWaveform([(dummy_wf1, [2, 1]), (dummy_wf2, [0])]) self.assertEqual(expected, result) self.assertEqual([{ 'foo': MappedParameter(Expression("2*bar"), {'bar': ConstantParameter(3)}) }], dummy1.build_waveform_calls) self.assertEqual([{}], dummy2.build_waveform_calls)
def test_concatenation_sequence_table_pulse(self): a = DummyPulseTemplate(parameter_names={'foo'}, defined_channels={'A'}) b = DummyPulseTemplate(parameter_names={'bar'}, defined_channels={'A'}) c = DummyPulseTemplate(parameter_names={'snu'}, defined_channels={'A'}) d = DummyPulseTemplate(parameter_names={'snu'}, defined_channels={'A'}) seq1 = SequencePulseTemplate(a, b, external_parameters=['foo', 'bar']) seq2 = SequencePulseTemplate(c, d, external_parameters=['snu']) seq = seq1 @ c self.assertTrue(len(seq.subtemplates) == 3) for st, expected in zip(seq.subtemplates, [a, b, c]): self.assertTrue(st, expected) seq = c @ seq1 self.assertTrue(len(seq.subtemplates) == 3) for st, expected in zip(seq.subtemplates, [c, a, b]): self.assertTrue(st, expected) seq = seq1 @ seq2 self.assertTrue(len(seq.subtemplates) == 4) for st, expected in zip(seq.subtemplates, [a, b, c, d]): self.assertTrue(st, expected)
def test_integral(self): integrals_lhs = dict(a=ExpressionScalar('a_lhs'), b=ExpressionScalar('b')) integrals_rhs = dict(a=ExpressionScalar('a_rhs'), c=ExpressionScalar('c')) lhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'b'}, parameter_names={'x', 'y'}, integrals=integrals_lhs) rhs = DummyPulseTemplate(duration=4, defined_channels={'a', 'c'}, parameter_names={'x', 'z'}, integrals=integrals_rhs) expected_plus = dict(a=ExpressionScalar('a_lhs + a_rhs'), b=ExpressionScalar('b'), c=ExpressionScalar('c')) expected_minus = dict(a=ExpressionScalar('a_lhs - a_rhs'), b=ExpressionScalar('b'), c=ExpressionScalar('-c')) self.assertEqual(expected_plus, (lhs + rhs).integral) self.assertEqual(expected_minus, (lhs - rhs).integral)
def test_build_waveform(self): wfs = [ DummyWaveform(duration=1.1, defined_channels={'A'}), DummyWaveform(duration=1.1, defined_channels={'B'}) ] sts = [ DummyPulseTemplate(duration='t1', defined_channels={'A'}, parameter_names={'a', 'b'}, measurement_names={'A', 'C'}, waveform=wfs[0]), DummyPulseTemplate(duration='t1', defined_channels={'B'}, parameter_names={'a', 'c'}, measurement_names={'A', 'B'}, waveform=wfs[1]) ] pt = AtomicMultiChannelPulseTemplate(*sts, parameter_constraints=['a < b']) parameters = dict(a=2.2, b=1.1, c=3.3) channel_mapping = dict() with self.assertRaises(ParameterConstraintViolation): pt.build_waveform(parameters, channel_mapping=dict()) parameters['a'] = 0.5 wf = pt.build_waveform(parameters, channel_mapping=channel_mapping) self.assertEqual(wf['A'], wfs[0]) self.assertEqual(wf['B'], wfs[1]) for st in sts: self.assertEqual(st.build_waveform_calls, [(parameters, channel_mapping)]) self.assertIs(parameters, st.build_waveform_calls[0][0]) self.assertIs(channel_mapping, st.build_waveform_calls[0][1])
def test_get_serialization_data_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "SequencePT does not issue warning for old serialization routines." ): dummy1 = DummyPulseTemplate() dummy2 = DummyPulseTemplate() sequence = SequencePulseTemplate(dummy1, dummy2, parameter_constraints=['a<b'], measurements=[('m', 0, 1)], registry=dict()) serializer = DummySerializer(serialize_callback=lambda x: str(x)) expected_data = dict(subtemplates=[str(dummy1), str(dummy2)], parameter_constraints=['a < b'], measurements=[('m', 0, 1)]) data = sequence.get_serialization_data(serializer) self.assertEqual(expected_data, data)
def test_unlink(self): apt = AbstractPulseTemplate(identifier='my_apt') dummy = DummyPulseTemplate() with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") apt.unlink() self.assertFalse(w) apt.link_to(dummy) with self.assertWarns(UnlinkWarning): apt.unlink() self.assertIsNone(apt._linked_target)
def test_as_expression(self): sts = [ DummyPulseTemplate(duration='t1', defined_channels={'A'}, integrals={'A': ExpressionScalar('2+k')}), DummyPulseTemplate(duration='t1', defined_channels={'B', 'C'}, integrals={ 'B': ExpressionScalar('t1-t0*3.1'), 'C': ExpressionScalar('l') }) ] pulse = AtomicMultiChannelPulseTemplate(*sts) self.assertEqual( { 'A': ExpressionScalar( sympify('(2+k) / t1') * pulse._AS_EXPRESSION_TIME), 'B': ExpressionScalar( sympify('(t1-t0*3.1)/t1') * pulse._AS_EXPRESSION_TIME), 'C': ExpressionScalar(sympify('l/t1') * pulse._AS_EXPRESSION_TIME) }, pulse._as_expression())
def test_integral(self) -> None: dummy = DummyPulseTemplate(integrals=['foo+2', 'k*3+x**2']) template = RepetitionPulseTemplate(dummy, 7) self.assertEqual([Expression('7*(foo+2)'), Expression('7*(k*3+x**2)')], template.integral) template = RepetitionPulseTemplate(dummy, '2+m') self.assertEqual( [Expression('(2+m)*(foo+2)'), Expression('(2+m)*(k*3+x**2)')], template.integral) template = RepetitionPulseTemplate(dummy, Expression('2+m')) self.assertEqual( [Expression('(2+m)*(foo+2)'), Expression('(2+m)*(k*3+x**2)')], template.integral)
def test_init_broken_mappings(self) -> None: st1 = DummyPulseTemplate(parameter_names={'foo'}, is_interruptable=True, num_channels=2, duration=1.3) st2 = DummyPulseTemplate(parameter_names={'bar'}, is_interruptable=True, num_channels=1, duration=6.34) with self.assertRaises(MissingMappingException): MultiChannelPulseTemplate([(st1, { 'foo': "bar" }, [0, 2]), (st2, {}, [1])], {'bar'}) with self.assertRaises(MissingMappingException): MultiChannelPulseTemplate([(st1, {}, [0, 2]), (st2, { 'bar': "bar" }, [1])], {'bar'}) with self.assertRaises(MissingParameterDeclarationException): MultiChannelPulseTemplate([(st1, { 'foo': "2.3 ** bar" }, [0, 2]), (st2, { 'bar': "bar" }, [1])], {})
def test_internal_create_program_no_measurement_mapping(self) -> None: sub1 = DummyPulseTemplate(duration=3, waveform=DummyWaveform(duration=3), measurements=[('b', 1, 2)]) sub2 = DummyPulseTemplate(duration=2, waveform=DummyWaveform(duration=2), parameter_names={'foo'}) scope = DictScope.from_kwargs() seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)]) children = [Loop(waveform=DummyWaveform())] loop = Loop(measurements=[], children=children) with self.assertRaises(KeyError): seq._internal_create_program(scope=scope, measurement_mapping=dict(), channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop) self.assertFalse(sub1.create_program_calls) self.assertFalse(sub2.create_program_calls) self.assertEqual(children, list(loop.children)) self.assertEqual(1, loop.repetition_count) self.assertIsNone(loop.waveform) self.assert_measurement_windows_equal({}, loop.get_measurement_windows()) # test for child level measurements (does not guarantee to leave parent_loop unchanged in this case) with self.assertRaises(KeyError): seq._internal_create_program(scope=scope, measurement_mapping=dict(a='a'), channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop)
def test_internal_create_program_parameter_constraint_violations( self) -> None: sub1 = DummyPulseTemplate(duration=3, waveform=DummyWaveform(duration=3), measurements=[('b', 1, 2)]) sub2 = DummyPulseTemplate(duration=2, waveform=DummyWaveform(duration=2), parameter_names={'foo'}) scope = DictScope.from_kwargs(foo=7) seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)], parameter_constraints={'foo < 2'}) loop = Loop() with self.assertRaises(ParameterConstraintViolation): seq._internal_create_program(scope=scope, measurement_mapping={ 'a': 'a', 'b': 'b' }, channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop)
def test_init(self): template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'}, measurement_names={'M'}) overwritten_channels = {'Y': 'c', 'Z': 'a'} expected_overwritten_channels = {'Y': ExpressionScalar('c'), 'Z': ExpressionScalar('a')} pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels) self.assertIs(template, pccpt.template) self.assertEqual(expected_overwritten_channels, pccpt.overwritten_channels) self.assertEqual({'X', 'Y', 'Z'}, pccpt.defined_channels) self.assertEqual({'a', 'b', 'c'}, pccpt.parameter_names) self.assertEqual({'M'}, pccpt.measurement_names) self.assertEqual({'a', 'c'}, pccpt.transformation_parameters) self.assertIs(template.duration, pccpt.duration)
def test_nested_mapping_avoidance(self): template = DummyPulseTemplate(parameter_names={'foo', 'bar'}) st_1 = MappingPulseTemplate(template, parameter_mapping={'foo': 't*k'}, allow_partial_parameter_mapping=True) st_2 = MappingPulseTemplate(st_1, parameter_mapping={'bar': 't*l'}, allow_partial_parameter_mapping=True) self.assertIs(st_2.template, template) self.assertEqual(st_2.parameter_mapping, {'foo': 't*k', 'bar': 't*l'}) st_3 = MappingPulseTemplate(template, parameter_mapping={'foo': 't*k'}, allow_partial_parameter_mapping=True, identifier='käse') st_4 = MappingPulseTemplate(st_3, parameter_mapping={'bar': 't*l'}, allow_partial_parameter_mapping=True) self.assertIs(st_4.template, st_3) self.assertEqual(st_4.parameter_mapping, {'t': 't', 'k': 'k', 'bar': 't*l'})
def test_integral(self) -> None: dummy = DummyPulseTemplate(defined_channels={'A', 'B'}, parameter_names={'t1', 'i'}, integrals={ 'A': ExpressionScalar('t1-i*3.1'), 'B': ExpressionScalar('i') }) pulse = ForLoopPulseTemplate(dummy, 'i', (1, 8, 2)) expected = { 'A': ExpressionScalar('Sum(t1-3.1*(1+2*i), (i, 0, 3))'), 'B': ExpressionScalar('Sum((1+2*i), (i, 0, 3))') } self.assertEqual(expected, pulse.integral)
def test_init_single_subtemplate_requires_stop_external_params( self) -> None: subtemplate = DummyPulseTemplate(parameter_names={'foo'}, requires_stop=True, num_channels=2, duration=1.3) template = MultiChannelPulseTemplate([(subtemplate, { 'foo': "2.3 ** bar" }, [1, 0])], {'bar'}) self.assertEqual({'bar'}, template.parameter_names) self.assertEqual({ParameterDeclaration('bar')}, template.parameter_declarations) self.assertFalse(template.is_interruptable) self.assertTrue( template.requires_stop(dict(bar=ConstantParameter(3.5)), dict())) self.assertEqual(2, template.num_channels)
def test_get_scalar_value(self): lhs = 'x + y' rhs = DummyPulseTemplate(defined_channels={'u', 'v', 'w'}) arith = ArithmeticPulseTemplate(lhs, '-', rhs) parameters = dict(x=3, y=5, z=8) channel_mapping = dict(u='a', v='b', w=None) expected = dict(a=8, b=8) self.assertEqual(expected, arith._get_scalar_value(parameters=parameters, channel_mapping=channel_mapping)) lhs = {'u': 1., 'w': 3.} arith = ArithmeticPulseTemplate(lhs, '-', rhs) expected = dict(a=1.) self.assertEqual(expected, arith._get_scalar_value(parameters=parameters, channel_mapping=channel_mapping))
def test_get_overwritten_channels_values(self): template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'}, measurement_names={'M'}) overwritten_channels = {'Y': 'c', 'Z': 'a'} expected_overwritten_channel_values = {'Y': 1.2, 'Z': 3.4} pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels) real_parameters = {'c': 1.2, 'a': 3.4} self.assertEqual( expected_overwritten_channel_values, pccpt._get_overwritten_channels_values(real_parameters))
def test_non_atomic_subtemplates(self): non_atomic_pt = PulseTemplateStub(duration='t1', defined_channels={'A'}, parameter_names=set()) atomic_pt = DummyPulseTemplate(defined_channels={'B'}, duration='t1') non_atomic_mapping = MappingPulseTemplate(non_atomic_pt) with self.assertRaises(TypeError): AtomicMultiChannelPulseTemplate(non_atomic_pt) with self.assertRaises(TypeError): AtomicMultiChannelPulseTemplate(non_atomic_pt, atomic_pt) with self.assertRaises(TypeError): AtomicMultiChannelPulseTemplate(non_atomic_mapping, atomic_pt) with self.assertRaises(TypeError): AtomicMultiChannelPulseTemplate((non_atomic_pt, {'A': 'C'}), atomic_pt)
def test_get_serialization_data_minimal(self): dt = DummyPulseTemplate(parameter_names={'i'}) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('A', 'B')) def check_dt(to_dictify) -> str: self.assertIs(to_dictify, dt) return 'dt' serializer = DummySerializer(serialize_callback=check_dt) data = flt.get_serialization_data(serializer) expected_data = dict(body='dt', loop_range=('A', 'B', 1), loop_index='i') self.assertEqual(data, expected_data)
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))