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_requires_stop(self) -> None: condition = DummyCondition(requires_stop=False) conditions = {'foo_cond': condition} body = DummyPulseTemplate(requires_stop=False) t = WhileLoopPulseTemplate('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_requires_stop_condition_missing(self) -> None: conditions = dict(bar_condition=DummyCondition(requires_stop=True)) parameters = dict(foo=DummyParameter(326.272), bar=DummyParameter(-2624.23), hugo=DummyParameter(3.532)) with self.assertRaises(ConditionMissingException): self.template.requires_stop(parameters, conditions)
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_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_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_build_path_o2_m1_i2_tt_m1_i0_two_elements_main_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem1 = DummySequencingElement(False) elem2 = DummySequencingElement(False) sequencer.push(elem2, ps, cs) sequencer.push(elem1, ps, cs) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(elem1, sequence[0].elem) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertIs(elem2, sequence[1].elem) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(1, elem2.requires_stop_call_counter) self.assertEqual(1, elem2.build_call_counter) self.assertEqual(STOPInstruction(), sequence[2]) self.assertEqual(3, len(sequence))
def test_build_path_o2_m1_i2_tf_m2_i1_f_i1_f_two_elements_main_block_last_requires_stop_add_one_element_requires_stop_new_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} new_block = InstructionBlock() new_elem = DummySequencingElement(True) elem1 = DummySequencingElement(False, (new_block, [new_elem])) elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs) sequencer.push(elem1, ps, cs) sequence = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(elem1, sequence[0].elem) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, new_elem.parameters) self.assertEqual(cs, new_elem.conditions) self.assertEqual(1, new_elem.requires_stop_call_counter) self.assertEqual(0, new_elem.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o2_m2_i1_t_i1_t_m2_i0_i0_one_element_custom_block_one_element_main_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem_main = DummySequencingElement(False) sequencer.push(elem_main, ps, cs) target_block = InstructionBlock() elem_cstm = DummySequencingElement(False) sequencer.push(elem_cstm, ps, cs, target_block) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(elem_main, sequence[0].elem) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(1, elem_main.build_call_counter) self.assertIs(target_block, elem_cstm.target_block) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(1, elem_cstm.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o2_m2_i0_i2_tt_m2_i0_i0_two_elements_custom_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} target_block = InstructionBlock() elem2 = DummySequencingElement(False) sequencer.push(elem2, ps, cs, window_mapping=wm, target_block=target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, window_mapping=wm, target_block=target_block) sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertIs(target_block, elem2.target_block) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(1, elem2.requires_stop_call_counter) self.assertEqual(1, elem2.build_call_counter)
def test_build_path_o2_m2_i1_f_i2_tf_m2_i1_f_i1_f_two_elements_custom_block_last_requires_stop_one_element_requires_stop_main_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} target_block = InstructionBlock() elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs, target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, target_block) elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(2, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter)
def test_build_path_o1_m2_i1_f_i1_f_one_element_custom_and_main_block_requires_stop( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs) elem_cstm = DummySequencingElement(True) target_block = InstructionBlock() sequencer.push(elem_cstm, ps, cs, target_block) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(0, elem_cstm.build_call_counter)
def test_build_path_o2_m2_i0_i1_t_m2_i0_i0_one_element_custom_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} cm = {'A': 'B'} target_block = InstructionBlock() elem = DummySequencingElement(False) sequencer.push(elem, ps, cs, window_mapping=wm, channel_mapping=cm, target_block=target_block) sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(target_block, elem.target_block) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(wm, elem.window_mapping) self.assertEqual(cm, elem.channel_mapping) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(1, elem.build_call_counter)
def test_parameter_names_and_declarations(self) -> None: condition = DummyCondition() body = DummyPulseTemplate() t = WhileLoopPulseTemplate(condition, body) self.assertEqual(body.parameter_names, t.parameter_names) body.parameter_names_ = {'foo', 't', 'bar'} self.assertEqual(body.parameter_names, t.parameter_names)
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 test_is_interruptable(self) -> None: condition = DummyCondition() body = DummyPulseTemplate(is_interruptable=False) t = WhileLoopPulseTemplate(condition, body) self.assertFalse(t.is_interruptable) body.is_interruptable_ = True self.assertTrue(t.is_interruptable)
def test_integral(self) -> None: condition = DummyCondition() body = DummyPulseTemplate(defined_channels={'A', 'B'}) pulse = WhileLoopPulseTemplate(condition, body) self.assertEqual( { 'A': ExpressionScalar('nan'), 'B': ExpressionScalar('nan') }, pulse.integral)
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_push(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem = DummySequencingElement() sequencer.push(elem, ps, cs) self.assertFalse(sequencer.has_finished()) sequencer.build() self.assertEqual(ps, elem.parameters)
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_push_float_params(self) -> None: sequencer = Sequencer() ps = {'foo': 1, 'bar': 7.3} cs = {'foo': DummyCondition()} elem = DummySequencingElement() sequencer.push(elem, ps, cs) self.assertFalse(sequencer.has_finished()) sequencer.build() self.assertIsInstance(elem.parameters['foo'], ConstantParameter) self.assertIsInstance(elem.parameters['bar'], ConstantParameter) self.assertEqual(cs, elem.conditions)
def test_build_path_o2_m2_i2_tt_t_i2_tf_m2_i0_i1_f_two_elements_custom_block_last_requires_stop_two_element_main_block( self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} target_block = InstructionBlock() elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs, window_mapping=wm, target_block=target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, window_mapping=wm, target_block=target_block) elem_main2 = DummySequencingElement(False) sequencer.push(elem_main2, ps, cs) elem_main1 = DummySequencingElement(False) sequencer.push(elem_main1, ps, cs) sequence = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertIs(elem_main1, sequence[0].elem) self.assertEqual(ps, elem_main1.parameters) self.assertEqual(cs, elem_main1.conditions) self.assertEqual(1, elem_main1.requires_stop_call_counter) self.assertEqual(1, elem_main1.build_call_counter) self.assertIs(elem_main2, sequence[1].elem) self.assertEqual(ps, elem_main2.parameters) self.assertEqual(cs, elem_main2.conditions) self.assertEqual(1, elem_main2.requires_stop_call_counter) self.assertEqual(1, elem_main2.build_call_counter) self.assertEqual(STOPInstruction(), sequence[2]) self.assertEqual(3, len(sequence))
def test_build_path_o1_m1_i1_f_single_element_requires_stop_main_block(self) -> None: sequencer = Sequencer() elem = DummySequencingElement(True) ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} sequencer.push(elem, ps, cs) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(0, elem.build_call_counter)
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_path_o1_m2_i1_f_i0_one_element_custom_block_requires_stop(self) -> None: sequencer = Sequencer() elem = DummySequencingElement(True) ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {} target_block = InstructionBlock() sequencer.push(elem, ps, cs, window_mapping=wm, target_block=target_block) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(0, elem.build_call_counter)
def test_build_sequence(self) -> None: condition = DummyCondition() body = DummyPulseTemplate() t = LoopPulseTemplate('foo_cond', body) sequencer = DummySequencer() block = DummyInstructionBlock() parameters = {} conditions = {'foo_cond': condition} t.build_sequence(sequencer, parameters, conditions, block) expected_data = dict(delegator=t, body=body, sequencer=sequencer, parameters=parameters, conditions=conditions, instruction_block=block) self.assertEqual(expected_data, condition.loop_call_data) self.assertFalse(condition.branch_call_data) self.assertFalse(sequencer.sequencing_stacks)
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_build_sequence_parameter_missing(self) -> None: foo_condition = DummyCondition() conditions = dict(foo_condition=foo_condition) parameters = dict(foo=DummyParameter(326.272), bar=DummyParameter(-2624.23)) self.template.build_sequence(self.sequencer, parameters, conditions, self.block) self.assertFalse(foo_condition.loop_call_data) self.assertEqual( dict( delegator=self.template, if_branch=self.if_dummy, else_branch=self.else_dummy, sequencer=self.sequencer, parameters=parameters, conditions=conditions, instruction_block=self.block ), foo_condition.branch_call_data ) self.assertFalse(self.sequencer.sequencing_stacks) self.assertFalse(self.block.instructions)
def test_build_sequence(self) -> None: condition = DummyCondition() body = DummyPulseTemplate() t = WhileLoopPulseTemplate('foo_cond', body) sequencer = DummySequencer() block = DummyInstructionBlock() parameters = {} conditions = {'foo_cond': condition} measurement_mapping = {'swag': 'aufdrehen'} channel_mapping = {} t.build_sequence(sequencer, parameters, conditions, measurement_mapping, channel_mapping, block) expected_data = dict(delegator=t, body=body, sequencer=sequencer, parameters=parameters, conditions=conditions, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, instruction_block=block) self.assertEqual(expected_data, condition.loop_call_data) self.assertFalse(condition.branch_call_data) self.assertFalse(sequencer.sequencing_stacks)
def test_requires_stop(self) -> None: point = PointPulseTemplate([('foo', 'v'), ('bar', 0)], [0]) 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, point.requires_stop(parameter_set, condition_set))
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)