예제 #1
0
    def test_create(self):
        expt_a = Experiment()
        self.assertEqual(expt_a.step, None)

        step_d, step = simple_step()
        expt_b = Experiment(step)
        self.assertEqual(expt_b.step, step)
예제 #2
0
	def test_double_run (self):
		step_d, step = simple_step()

		# Initialisation
		expt = Experiment(step)

		# Run twice gives an error
		expt_d = expt.run()
		self.assertRaises(Exception, expt.run)

		step_d.callback(None)
예제 #3
0
    def test_double_run(self):
        step_d, step = simple_step()

        # Initialisation
        expt = Experiment(step)

        # Run twice gives an error
        expt_d = expt.run()
        self.assertRaises(Exception, expt.run)

        step_d.callback(None)
예제 #4
0
    def test_normal_run(self):
        step_d, step = simple_step()

        # Initialisation
        expt = Experiment(step)
        self.assertEqual(expt.state, State.READY)

        # Run
        expt_d = expt.run()
        self.assertEqual(expt.state, State.RUNNING)
        step.run.assert_called_once_with()

        result = "my_result"
        step_d.callback(result)

        self.assertEqual(expt.state, State.COMPLETE)
        self.assertEqual(expt_d.called, True)
예제 #5
0
	def test_normal_run (self):
		step_d, step = simple_step()

		# Initialisation
		expt = Experiment(step)
		self.assertEqual(expt.state, State.READY)

		# Run
		expt_d = expt.run()
		self.assertEqual(expt.state, State.RUNNING)
		step.run.assert_called_once_with()

		result = "my_result"
		step_d.callback(result)

		self.assertEqual(expt.state, State.COMPLETE)
		self.assertEqual(expt_d.called, True)
예제 #6
0
    def test_stop(self):
        from octopus.sequence import Stopped

        # Initialisation
        step_d, step = simple_step()
        expt = Experiment(step)
        expt_d = expt.run()

        # Stop
        self.assertEqual(expt.state, State.RUNNING)

        stop_d = expt.stop()
        step.abort.assert_called_once_with()
        self.assertEqual(expt.state, State.RUNNING)

        step_d.errback(Stopped())
        self.assertEqual(expt.state, State.ERROR)
        self.assertFailure(expt_d, Stopped)
        self.assertEqual(len(step.log.handlers), 0)
예제 #7
0
    def test_pause_resume(self):
        # Initialisation
        step_d, step = simple_step()
        expt = Experiment(step)
        expt_d = expt.run()

        # Pause
        pause_d = expt.pause()
        step.pause.assert_called_once_with()
        self.assertEqual(expt.state, State.PAUSED)
        self.assertEqual(pause_d.result, [None])

        # Resume
        resume_d = expt.resume()
        step.resume.assert_called_once_with()
        self.assertEqual(expt.state, State.RUNNING)
        self.assertEqual(resume_d.result, [None])

        step_d.callback(None)
예제 #8
0
	def test_run (self):
		m = simple_machine()
		step_d, step = simple_step()

		expt = Experiment(step)
		expt.register_machine(m)

		expt.run()
		self.assertEqual(expt.state, State.RUNNING)
		self.assertEqual(m.reset.call_count, 0)

		m.ready.callback(True)
		m.reset.assert_called_once_with()
		self.assertEqual(step.run.call_count, 0)

		m.reset_d.callback(True)
		step.run.assert_called_once_with()

		step_d.callback(None)
예제 #9
0
	def test_stop (self):
		from octopus.sequence import Stopped

		# Initialisation
		step_d, step = simple_step()
		expt = Experiment(step)
		expt_d = expt.run()

		# Stop
		self.assertEqual(expt.state, State.RUNNING)

		stop_d = expt.stop()
		step.abort.assert_called_once_with()
		self.assertEqual(expt.state, State.RUNNING)

		step_d.errback(Stopped())
		self.assertEqual(expt.state, State.ERROR)
		self.assertFailure(expt_d, Stopped)
		self.assertEqual(len(step.log.handlers), 0)
예제 #10
0
	def test_pause_resume (self):
		# Initialisation
		step_d, step = simple_step()
		expt = Experiment(step)
		expt_d = expt.run()

		# Pause
		pause_d = expt.pause()
		step.pause.assert_called_once_with()
		self.assertEqual(expt.state, State.PAUSED)
		self.assertEqual(pause_d.result, [None])

		# Resume
		resume_d = expt.resume()
		step.resume.assert_called_once_with()
		self.assertEqual(expt.state, State.RUNNING)
		self.assertEqual(resume_d.result, [None])

		step_d.callback(None)
예제 #11
0
    def test_run(self):
        m = simple_machine()
        step_d, step = simple_step()

        expt = Experiment(step)
        expt.register_machine(m)

        expt.run()
        self.assertEqual(expt.state, State.RUNNING)
        self.assertEqual(m.reset.call_count, 0)

        m.ready.callback(True)
        m.reset.assert_called_once_with()
        self.assertEqual(step.run.call_count, 0)

        m.reset_d.callback(True)
        step.run.assert_called_once_with()

        step_d.callback(None)
예제 #12
0
from twisted.internet import reactor
from twisted.python import log
from octopus.sequence.shortcuts import *
from octopus.experiment import Experiment

s = wait(2)
e = Experiment(s)
reactor.callLater(0.5, e.pause)
reactor.callLater(1, e.resume)
reactor.callLater(1.5, e.stop)
reactor.callLater(0, e.run)

s1 = wait(2)
e1 = Experiment(s1)
reactor.callLater(2.5, s1.abort)
reactor.callLater(2, e1.run)

s2 = wait(2)
e2 = Experiment(s2)
reactor.callLater(3.5, s2.cancel)
reactor.callLater(3, e2.run)

reactor.callLater(4, reactor.stop)
reactor.run()