1
  Y   	ˆl–Ãa¾”ji?u	@»q¡\*bÑ¿�þZ-¬ÙJÔ HÈçÊ„Ž>ÏÉ_ŠI|¥�+Wé3ž¯a–ß=¿Jõ4Ÿº‚ œP/ÜnJbÑ¿É ?÷     	import sys
import unittest
import errno
import select
from supervisor.tests.base import Mock

from supervisor.poller import SelectPoller, PollPoller, KQueuePoller
from supervisor.poller import implements_poll, implements_kqueue
from supervisor.tests.base import DummyOptions

# this base class is used instead of unittest.TestCase to hide
# a TestCase subclass from test runner when the implementation is
# not available
SkipTestCase = object

class BasePollerTests(unittest.TestCase):
    def _makeOne(self, options):
        from supervisor.poller import BasePoller
        return BasePoller(options)

    def test_register_readable(self):
        inst = self._makeOne(None)
        self.assertRaises(NotImplementedError, inst.register_readable, None)

    def test_register_writable(self):
        inst = self._makeOne(None)
        self.assertRaises(NotImplementedError, inst.register_writable, None)

    def test_unregister_readable(self):
        inst = self._makeOne(None)
        self.assertRaises(NotImplementedError, inst.unregister_readable, None)

    def test_unregister_writable(self):
        inst = self._makeOne(None)
        self.assertRaises(NotImplementedError, inst.unregister_writable, None)

    def test_poll(self):
        inst = self._makeOne(None)
        self.assertRaises(NotImplementedError, inst.poll, None)

    def test_before_daemonize(self):
        inst = self._makeOne(None)
        self.assertEqual(inst.before_daemonize(), None)

    def test_after_daemonize(self):
        inst = self._makeOne(None)
        self.assertEqual(inst.after_daemonize(), None)

class SelectPollerTests(unittest.TestCase):

    def _makeOne(self, options):
        return SelectPoller(options)

    def test_register_readable(self):
        poller = self._makeOne(DummyOptions())
        poller.register_readable(6)
        poller.register_readable(7)
        self.assertEqual(sorted(poller.readables), [6,7])

    def test_register_writable(self):
        poller = self._makeOne(DummyOptions())
        poller.register_writable(6)
        poller.register_writable(7)
        self.assertEqual(sorted(poller.writables), [6,7])

    def test_unregister_readable(self):
        poller = self._makeOne(DummyOptions())
        poller.register_readable(6)
        poller.register_readable(7)
        poller.register_writable(8)
        poller.register_writable(9)
        poller.unregister_readable(6)
        poller.unregister_readable(9)
        poller.unregister_readable(100)  # not registered, ignore error
        self.assertEqual(list(poller.readables), [7])
        self.assertEqual(list(poller.writables), [8, 9])

    def test_unregister_writable(self):
        poller = self._makeOne(DummyOptions())
        poller.register_readable(6)
        poller.register_readable(7)
        poller.register_writable(8)
        poller.register_writable(6)
        poller.unregister_writable(7)
        poller.unregister_writable(6)
        poller.unregister_writable(100)  # not registered, ignore error
        self.assertEqual(list(poller.readables), [6, 7])
        self.assertEqual(list(poller.writables), [8])

    def test_poll_returns_readables_and_writables(self):
        _select = DummySelect(result={'readables': [6],
                                      'writables': [8]})
        poller = self._makeOne(DummyOptions())
        poller._select = _select
        poller.register_readable(6)
        poller.register_readable(7)
        poller.register_writable(8)
        readables, writables = poller.poll(1)
        self.assertEqual(readables, [6])
        self.assertEqual(writables, [8])

    def test_poll_ignores_eintr(self):
        _select = DummySelect(error=errno.EINTR)
        options = DummyOptions()
        poller = self._makeOne(options)
        poller._select = _select
        poller.register_readable(6)
        poller.poll(1)
        self.assertEqual(options.logger.data[0], 'EINTR encountered in poll')

    def test_poll_ignores_ebadf(self):
  