def test_build_cannot_evaluate(self) -> None:
        sequencer = DummySequencer(DummySequencingHardware())
        block = DummyInstructionBlock()

        delegator = DummySequencingElement()
        body = DummySequencingElement()

        condition = SoftwareCondition(lambda loop_iteration: None)

        self.assertTrue(condition.requires_stop())
        self.assertRaises(
            ConditionEvaluationException, condition.build_sequence_loop, delegator, body, sequencer, [], block
        )
        self.assertRaises(
            ConditionEvaluationException, condition.build_sequence_branch, delegator, body, body, sequencer, [], block
        )
    def test_build_sequence_loop_false(self):
        sequencer = DummySequencer(DummySequencingHardware())
        block = DummyInstructionBlock()

        delegator = DummySequencingElement()
        body = DummySequencingElement()
        callback = IterationCallbackDummy(False)

        condition = SoftwareCondition(lambda loop_iteration: callback.callback(loop_iteration))
        condition.build_sequence_loop(delegator, body, sequencer, [], block)

        self.assertEqual(0, callback.loop_iteration)
        self.assertFalse(block.instructions)
        self.assertFalse(sequencer.sequencing_stacks)

        condition.build_sequence_loop(delegator, body, sequencer, [], block)
        self.assertEqual(0, callback.loop_iteration)
    def test_build_sequence_branch_true(self):
        sequencer = DummySequencer(DummySequencingHardware())
        block = DummyInstructionBlock()

        delegator = DummySequencingElement()
        if_branch = DummySequencingElement()
        else_branch = DummySequencingElement()
        callback = IterationCallbackDummy(True)

        condition = SoftwareCondition(lambda loop_iteration: callback.callback(loop_iteration))
        condition.build_sequence_branch(delegator, if_branch, else_branch, sequencer, [], block)

        self.assertEqual(0, callback.loop_iteration)
        self.assertFalse(block.instructions)
        self.assertEqual({block: [(if_branch, [])]}, sequencer.sequencing_stacks)

        condition.build_sequence_branch(delegator, if_branch, else_branch, sequencer, [], block)
        self.assertEqual(0, callback.loop_iteration)