# A greenlet that's killed before it is ever started
# should never be switched to
import gevent
import gevent.testing as greentest


class MyException(Exception):
    pass

class TestSwitch(greentest.TestCase):

    def setUp(self):
        super(TestSwitch, self).setUp()
        self.switched_to = [False, False]
        self.caught = None

    def should_never_run(self, i): # pragma: no cover
        self.switched_to[i] = True

    def check(self, g, g2):
        gevent.joinall((g, g2))
        self.assertEqual([False, False], self.switched_to)

        # They both have a GreenletExit as their value
        self.assertIsInstance(g.value, gevent.GreenletExit)
        self.assertIsInstance(g2.value, gevent.GreenletExit)

        # They both have no reported exc_info
        self.assertIsNone(g.exc_info)
        self.assertIsNone(g2.exc_info)
        self.assertIsNone(g.exception)
        self.assertIsNone(g2.exception)


    def test_gevent_kill(self):
        g = gevent.spawn(self.should_never_run, 0) # create but do not switch to
        g2 = gevent.spawn(self.should_never_run, 1) # create but do not switch to
        # Using gevent.kill
        gevent.kill(g)
        gevent.kill(g2)
        self.check(g, g2)

    def test_greenlet_kill(self):
        # killing directly
        g = gevent.spawn(self.should_never_run, 0)
        g2 = gevent.spawn(self.should_never_run, 1)
        g.kill()
        g2.kill()
        self.check(g, g2)

    def test_throw(self):
        # throwing
        g = gevent.spawn(self.should_never_run, 0)
        g2 = gevent.spawn(self.should_never_run, 1)
        g.throw(gevent.GreenletExit)
        g2.throw(gevent.GreenletExit)
        self.check(g, g2)


    def catcher(self):
        try:
            while True:
                gevent.sleep(0)
        except MyException as e:
            self.caught = e

    def test_kill_exception(self):
        # Killing with gevent.kill gets the right exception

        g = gevent.spawn(self.catcher)
        g.start()
        gevent.sleep()
        gevent.kill(g, MyException())
        gevent.sleep()

        self.assertIsInstance(self.caught, MyException)
        self.assertIsNone(g.exception, MyException)


if __name__ == '__main__':
    greentest.main()