Open Media Library Platform

Shared/lib/python2.7/site-packages/tornado/test/README

@@ -0,0 +1,4 @@
+Test coverage is almost non-existent, but it's a start.  Be sure to
+set PYTHONPATH apprioriately (generally to the root directory of your
+tornado checkout) when running tests to make sure you're getting the
+version of the tornado package that you expect.

Shared/lib/python2.7/site-packages/tornado/test/auth_test.py

@@ -0,0 +1,424 @@
+# These tests do not currently do much to verify the correct implementation
+# of the openid/oauth protocols, they just exercise the major code paths
+# and ensure that it doesn't blow up (e.g. with unicode/bytes issues in
+# python 3)
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+from tornado.auth import OpenIdMixin, OAuthMixin, OAuth2Mixin, TwitterMixin, GoogleMixin, AuthError
+from tornado.concurrent import Future
+from tornado.escape import json_decode
+from tornado import gen
+from tornado.log import gen_log
+from tornado.testing import AsyncHTTPTestCase, ExpectLog
+from tornado.util import u
+from tornado.web import RequestHandler, Application, asynchronous, HTTPError
+
+
+class OpenIdClientLoginHandler(RequestHandler, OpenIdMixin):
+    def initialize(self, test):
+        self._OPENID_ENDPOINT = test.get_url('/openid/server/authenticate')
+
+    @asynchronous
+    def get(self):
+        if self.get_argument('openid.mode', None):
+            self.get_authenticated_user(
+                self.on_user, http_client=self.settings['http_client'])
+            return
+        res = self.authenticate_redirect()
+        assert isinstance(res, Future)
+        assert res.done()
+
+    def on_user(self, user):
+        if user is None:
+            raise Exception("user is None")
+        self.finish(user)
+
+
+class OpenIdServerAuthenticateHandler(RequestHandler):
+    def post(self):
+        if self.get_argument('openid.mode') != 'check_authentication':
+            raise Exception("incorrect openid.mode %r")
+        self.write('is_valid:true')
+
+
+class OAuth1ClientLoginHandler(RequestHandler, OAuthMixin):
+    def initialize(self, test, version):
+        self._OAUTH_VERSION = version
+        self._OAUTH_REQUEST_TOKEN_URL = test.get_url('/oauth1/server/request_token')
+        self._OAUTH_AUTHORIZE_URL = test.get_url('/oauth1/server/authorize')
+        self._OAUTH_ACCESS_TOKEN_URL = test.get_url('/oauth1/server/access_token')
+
+    def _oauth_consumer_token(self):
+        return dict(key='asdf', secret='qwer')
+
+    @asynchronous
+    def get(self):
+        if self.get_argument('oauth_token', None):
+            self.get_authenticated_user(
+                self.on_user, http_client=self.settings['http_client'])
+            return
+        res = self.authorize_redirect(http_client=self.settings['http_client'])
+        assert isinstance(res, Future)
+
+    def on_user(self, user):
+        if user is None:
+            raise Exception("user is None")
+        self.finish(user)
+
+    def _oauth_get_user(self, access_token, callback):
+        if access_token != dict(key='uiop', secret='5678'):
+            raise Exception("incorrect access token %r" % access_token)
+        callback(dict(email='foo@example.com'))
+
+
+class OAuth1ClientRequestParametersHandler(RequestHandler, OAuthMixin):
+    def initialize(self, version):
+        self._OAUTH_VERSION = version
+
+    def _oauth_consumer_token(self):
+        return dict(key='asdf', secret='qwer')
+
+    def get(self):
+        params = self._oauth_request_parameters(
+            'http://www.example.com/api/asdf',
+            dict(key='uiop', secret='5678'),
+            parameters=dict(foo='bar'))
+        self.write(params)
+
+
+class OAuth1ServerRequestTokenHandler(RequestHandler):
+    def get(self):
+        self.write('oauth_token=zxcv&oauth_token_secret=1234')
+
+
+class OAuth1ServerAccessTokenHandler(RequestHandler):
+    def get(self):
+        self.write('oauth_token=uiop&oauth_token_secret=5678')
+
+
+class OAuth2ClientLoginHandler(RequestHandler, OAuth2Mixin):
+    def initialize(self, test):
+        self._OAUTH_AUTHORIZE_URL = test.get_url('/oauth2/server/authorize')
+
+    def get(self):
+        res = self.authorize_redirect()
+        assert isinstance(res, Future)
+        assert res.done()
+
+
+class TwitterClientHandler(RequestHandler, TwitterMixin):
+    def initialize(self, test):
+        self._OAUTH_REQUEST_TOKEN_URL = test.get_url('/oauth1/server/request_token')
+        self._OAUTH_ACCESS_TOKEN_URL = test.get_url('/twitter/server/access_token')
+        self._OAUTH_AUTHORIZE_URL = test.get_url('/oauth1/server/authorize')
+        self._TWITTER_BASE_URL = test.get_url('/twitter/api')
+
+    def get_auth_http_client(self):
+        return self.settings['http_client']
+
+
+class TwitterClientLoginHandler(TwitterClientHandler):
+    @asynchronous
+    def get(self):
+        if self.get_argument("oauth_token", None):
+            self.get_authenticated_user(self.on_user)
+            return
+        self.authorize_redirect()
+
+    def on_user(self, user):
+        if user is None:
+            raise Exception("user is None")
+        self.finish(user)
+
+
+class TwitterClientLoginGenEngineHandler(TwitterClientHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        if self.get_argument("oauth_token", None):
+            user = yield self.get_authenticated_user()
+            self.finish(user)
+        else:
+            # Old style: with @gen.engine we can ignore the Future from
+            # authorize_redirect.
+            self.authorize_redirect()
+
+
+class TwitterClientLoginGenCoroutineHandler(TwitterClientHandler):
+    @gen.coroutine
+    def get(self):
+        if self.get_argument("oauth_token", None):
+            user = yield self.get_authenticated_user()
+            self.finish(user)
+        else:
+            # New style: with @gen.coroutine the result must be yielded
+            # or else the request will be auto-finished too soon.
+            yield self.authorize_redirect()
+
+
+class TwitterClientShowUserHandler(TwitterClientHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        # TODO: would be nice to go through the login flow instead of
+        # cheating with a hard-coded access token.
+        response = yield gen.Task(self.twitter_request,
+                                  '/users/show/%s' % self.get_argument('name'),
+                                  access_token=dict(key='hjkl', secret='vbnm'))
+        if response is None:
+            self.set_status(500)
+            self.finish('error from twitter request')
+        else:
+            self.finish(response)
+
+
+class TwitterClientShowUserFutureHandler(TwitterClientHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        try:
+            response = yield self.twitter_request(
+                '/users/show/%s' % self.get_argument('name'),
+                access_token=dict(key='hjkl', secret='vbnm'))
+        except AuthError as e:
+            self.set_status(500)
+            self.finish(str(e))
+            return
+        assert response is not None
+        self.finish(response)
+
+
+class TwitterServerAccessTokenHandler(RequestHandler):
+    def get(self):
+        self.write('oauth_token=hjkl&oauth_token_secret=vbnm&screen_name=foo')
+
+
+class TwitterServerShowUserHandler(RequestHandler):
+    def get(self, screen_name):
+        if screen_name == 'error':
+            raise HTTPError(500)
+        assert 'oauth_nonce' in self.request.arguments
+        assert 'oauth_timestamp' in self.request.arguments
+        assert 'oauth_signature' in self.request.arguments
+        assert self.get_argument('oauth_consumer_key') == 'test_twitter_consumer_key'
+        assert self.get_argument('oauth_signature_method') == 'HMAC-SHA1'
+        assert self.get_argument('oauth_version') == '1.0'
+        assert self.get_argument('oauth_token') == 'hjkl'
+        self.write(dict(screen_name=screen_name, name=screen_name.capitalize()))
+
+
+class TwitterServerVerifyCredentialsHandler(RequestHandler):
+    def get(self):
+        assert 'oauth_nonce' in self.request.arguments
+        assert 'oauth_timestamp' in self.request.arguments
+        assert 'oauth_signature' in self.request.arguments
+        assert self.get_argument('oauth_consumer_key') == 'test_twitter_consumer_key'
+        assert self.get_argument('oauth_signature_method') == 'HMAC-SHA1'
+        assert self.get_argument('oauth_version') == '1.0'
+        assert self.get_argument('oauth_token') == 'hjkl'
+        self.write(dict(screen_name='foo', name='Foo'))
+
+
+class GoogleOpenIdClientLoginHandler(RequestHandler, GoogleMixin):
+    def initialize(self, test):
+        self._OPENID_ENDPOINT = test.get_url('/openid/server/authenticate')
+
+    @asynchronous
+    def get(self):
+        if self.get_argument("openid.mode", None):
+            self.get_authenticated_user(self.on_user)
+            return
+        res = self.authenticate_redirect()
+        assert isinstance(res, Future)
+        assert res.done()
+
+    def on_user(self, user):
+        if user is None:
+            raise Exception("user is None")
+        self.finish(user)
+
+    def get_auth_http_client(self):
+        return self.settings['http_client']
+
+
+class AuthTest(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application(
+            [
+                # test endpoints
+                ('/openid/client/login', OpenIdClientLoginHandler, dict(test=self)),
+                ('/oauth10/client/login', OAuth1ClientLoginHandler,
+                 dict(test=self, version='1.0')),
+                ('/oauth10/client/request_params',
+                 OAuth1ClientRequestParametersHandler,
+                 dict(version='1.0')),
+                ('/oauth10a/client/login', OAuth1ClientLoginHandler,
+                 dict(test=self, version='1.0a')),
+                ('/oauth10a/client/request_params',
+                 OAuth1ClientRequestParametersHandler,
+                 dict(version='1.0a')),
+                ('/oauth2/client/login', OAuth2ClientLoginHandler, dict(test=self)),
+
+                ('/twitter/client/login', TwitterClientLoginHandler, dict(test=self)),
+                ('/twitter/client/login_gen_engine', TwitterClientLoginGenEngineHandler, dict(test=self)),
+                ('/twitter/client/login_gen_coroutine', TwitterClientLoginGenCoroutineHandler, dict(test=self)),
+                ('/twitter/client/show_user', TwitterClientShowUserHandler, dict(test=self)),
+                ('/twitter/client/show_user_future', TwitterClientShowUserFutureHandler, dict(test=self)),
+                ('/google/client/openid_login', GoogleOpenIdClientLoginHandler, dict(test=self)),
+
+                # simulated servers
+                ('/openid/server/authenticate', OpenIdServerAuthenticateHandler),
+                ('/oauth1/server/request_token', OAuth1ServerRequestTokenHandler),
+                ('/oauth1/server/access_token', OAuth1ServerAccessTokenHandler),
+
+                ('/twitter/server/access_token', TwitterServerAccessTokenHandler),
+                (r'/twitter/api/users/show/(.*)\.json', TwitterServerShowUserHandler),
+                (r'/twitter/api/account/verify_credentials\.json', TwitterServerVerifyCredentialsHandler),
+            ],
+            http_client=self.http_client,
+            twitter_consumer_key='test_twitter_consumer_key',
+            twitter_consumer_secret='test_twitter_consumer_secret')
+
+    def test_openid_redirect(self):
+        response = self.fetch('/openid/client/login', follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue(
+            '/openid/server/authenticate?' in response.headers['Location'])
+
+    def test_openid_get_user(self):
+        response = self.fetch('/openid/client/login?openid.mode=blah&openid.ns.ax=http://openid.net/srv/ax/1.0&openid.ax.type.email=http://axschema.org/contact/email&openid.ax.value.email=foo@example.com')
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed["email"], "foo@example.com")
+
+    def test_oauth10_redirect(self):
+        response = self.fetch('/oauth10/client/login', follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue(response.headers['Location'].endswith(
+            '/oauth1/server/authorize?oauth_token=zxcv'))
+        # the cookie is base64('zxcv')|base64('1234')
+        self.assertTrue(
+            '_oauth_request_token="enhjdg==|MTIzNA=="' in response.headers['Set-Cookie'],
+            response.headers['Set-Cookie'])
+
+    def test_oauth10_get_user(self):
+        response = self.fetch(
+            '/oauth10/client/login?oauth_token=zxcv',
+            headers={'Cookie': '_oauth_request_token=enhjdg==|MTIzNA=='})
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed['email'], 'foo@example.com')
+        self.assertEqual(parsed['access_token'], dict(key='uiop', secret='5678'))
+
+    def test_oauth10_request_parameters(self):
+        response = self.fetch('/oauth10/client/request_params')
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed['oauth_consumer_key'], 'asdf')
+        self.assertEqual(parsed['oauth_token'], 'uiop')
+        self.assertTrue('oauth_nonce' in parsed)
+        self.assertTrue('oauth_signature' in parsed)
+
+    def test_oauth10a_redirect(self):
+        response = self.fetch('/oauth10a/client/login', follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue(response.headers['Location'].endswith(
+            '/oauth1/server/authorize?oauth_token=zxcv'))
+        # the cookie is base64('zxcv')|base64('1234')
+        self.assertTrue(
+            '_oauth_request_token="enhjdg==|MTIzNA=="' in response.headers['Set-Cookie'],
+            response.headers['Set-Cookie'])
+
+    def test_oauth10a_get_user(self):
+        response = self.fetch(
+            '/oauth10a/client/login?oauth_token=zxcv',
+            headers={'Cookie': '_oauth_request_token=enhjdg==|MTIzNA=='})
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed['email'], 'foo@example.com')
+        self.assertEqual(parsed['access_token'], dict(key='uiop', secret='5678'))
+
+    def test_oauth10a_request_parameters(self):
+        response = self.fetch('/oauth10a/client/request_params')
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed['oauth_consumer_key'], 'asdf')
+        self.assertEqual(parsed['oauth_token'], 'uiop')
+        self.assertTrue('oauth_nonce' in parsed)
+        self.assertTrue('oauth_signature' in parsed)
+
+    def test_oauth2_redirect(self):
+        response = self.fetch('/oauth2/client/login', follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue('/oauth2/server/authorize?' in response.headers['Location'])
+
+    def base_twitter_redirect(self, url):
+        # Same as test_oauth10a_redirect
+        response = self.fetch(url, follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue(response.headers['Location'].endswith(
+            '/oauth1/server/authorize?oauth_token=zxcv'))
+        # the cookie is base64('zxcv')|base64('1234')
+        self.assertTrue(
+            '_oauth_request_token="enhjdg==|MTIzNA=="' in response.headers['Set-Cookie'],
+            response.headers['Set-Cookie'])
+
+    def test_twitter_redirect(self):
+        self.base_twitter_redirect('/twitter/client/login')
+
+    def test_twitter_redirect_gen_engine(self):
+        self.base_twitter_redirect('/twitter/client/login_gen_engine')
+
+    def test_twitter_redirect_gen_coroutine(self):
+        self.base_twitter_redirect('/twitter/client/login_gen_coroutine')
+
+    def test_twitter_get_user(self):
+        response = self.fetch(
+            '/twitter/client/login?oauth_token=zxcv',
+            headers={'Cookie': '_oauth_request_token=enhjdg==|MTIzNA=='})
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed,
+                         {u('access_token'): {u('key'): u('hjkl'),
+                                              u('screen_name'): u('foo'),
+                                              u('secret'): u('vbnm')},
+                          u('name'): u('Foo'),
+                          u('screen_name'): u('foo'),
+                          u('username'): u('foo')})
+
+    def test_twitter_show_user(self):
+        response = self.fetch('/twitter/client/show_user?name=somebody')
+        response.rethrow()
+        self.assertEqual(json_decode(response.body),
+                         {'name': 'Somebody', 'screen_name': 'somebody'})
+
+    def test_twitter_show_user_error(self):
+        with ExpectLog(gen_log, 'Error response HTTP 500'):
+            response = self.fetch('/twitter/client/show_user?name=error')
+        self.assertEqual(response.code, 500)
+        self.assertEqual(response.body, b'error from twitter request')
+
+    def test_twitter_show_user_future(self):
+        response = self.fetch('/twitter/client/show_user_future?name=somebody')
+        response.rethrow()
+        self.assertEqual(json_decode(response.body),
+                         {'name': 'Somebody', 'screen_name': 'somebody'})
+
+    def test_twitter_show_user_future_error(self):
+        response = self.fetch('/twitter/client/show_user_future?name=error')
+        self.assertEqual(response.code, 500)
+        self.assertIn(b'Error response HTTP 500', response.body)
+
+    def test_google_redirect(self):
+        # same as test_openid_redirect
+        response = self.fetch('/google/client/openid_login', follow_redirects=False)
+        self.assertEqual(response.code, 302)
+        self.assertTrue(
+            '/openid/server/authenticate?' in response.headers['Location'])
+
+    def test_google_get_user(self):
+        response = self.fetch('/google/client/openid_login?openid.mode=blah&openid.ns.ax=http://openid.net/srv/ax/1.0&openid.ax.type.email=http://axschema.org/contact/email&openid.ax.value.email=foo@example.com', follow_redirects=False)
+        response.rethrow()
+        parsed = json_decode(response.body)
+        self.assertEqual(parsed["email"], "foo@example.com")

Shared/lib/python2.7/site-packages/tornado/test/concurrent_test.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python
+#
+# Copyright 2012 Facebook
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+from __future__ import absolute_import, division, print_function, with_statement
+
+import logging
+import re
+import socket
+import sys
+import traceback
+
+from tornado.concurrent import Future, return_future, ReturnValueIgnoredError
+from tornado.escape import utf8, to_unicode
+from tornado import gen
+from tornado.iostream import IOStream
+from tornado import stack_context
+from tornado.tcpserver import TCPServer
+from tornado.testing import AsyncTestCase, LogTrapTestCase, bind_unused_port, gen_test
+
+
+class ReturnFutureTest(AsyncTestCase):
+    @return_future
+    def sync_future(self, callback):
+        callback(42)
+
+    @return_future
+    def async_future(self, callback):
+        self.io_loop.add_callback(callback, 42)
+
+    @return_future
+    def immediate_failure(self, callback):
+        1 / 0
+
+    @return_future
+    def delayed_failure(self, callback):
+        self.io_loop.add_callback(lambda: 1 / 0)
+
+    @return_future
+    def return_value(self, callback):
+        # Note that the result of both running the callback and returning
+        # a value (or raising an exception) is unspecified; with current
+        # implementations the last event prior to callback resolution wins.
+        return 42
+
+    @return_future
+    def no_result_future(self, callback):
+        callback()
+
+    def test_immediate_failure(self):
+        with self.assertRaises(ZeroDivisionError):
+            # The caller sees the error just like a normal function.
+            self.immediate_failure(callback=self.stop)
+        # The callback is not run because the function failed synchronously.
+        self.io_loop.add_timeout(self.io_loop.time() + 0.05, self.stop)
+        result = self.wait()
+        self.assertIs(result, None)
+
+    def test_return_value(self):
+        with self.assertRaises(ReturnValueIgnoredError):
+            self.return_value(callback=self.stop)
+
+    def test_callback_kw(self):
+        future = self.sync_future(callback=self.stop)
+        result = self.wait()
+        self.assertEqual(result, 42)
+        self.assertEqual(future.result(), 42)
+
+    def test_callback_positional(self):
+        # When the callback is passed in positionally, future_wrap shouldn't
+        # add another callback in the kwargs.
+        future = self.sync_future(self.stop)
+        result = self.wait()
+        self.assertEqual(result, 42)
+        self.assertEqual(future.result(), 42)
+
+    def test_no_callback(self):
+        future = self.sync_future()
+        self.assertEqual(future.result(), 42)
+
+    def test_none_callback_kw(self):
+        # explicitly pass None as callback
+        future = self.sync_future(callback=None)
+        self.assertEqual(future.result(), 42)
+
+    def test_none_callback_pos(self):
+        future = self.sync_future(None)
+        self.assertEqual(future.result(), 42)
+
+    def test_async_future(self):
+        future = self.async_future()
+        self.assertFalse(future.done())
+        self.io_loop.add_future(future, self.stop)
+        future2 = self.wait()
+        self.assertIs(future, future2)
+        self.assertEqual(future.result(), 42)
+
+    @gen_test
+    def test_async_future_gen(self):
+        result = yield self.async_future()
+        self.assertEqual(result, 42)
+
+    def test_delayed_failure(self):
+        future = self.delayed_failure()
+        self.io_loop.add_future(future, self.stop)
+        future2 = self.wait()
+        self.assertIs(future, future2)
+        with self.assertRaises(ZeroDivisionError):
+            future.result()
+
+    def test_kw_only_callback(self):
+        @return_future
+        def f(**kwargs):
+            kwargs['callback'](42)
+        future = f()
+        self.assertEqual(future.result(), 42)
+
+    def test_error_in_callback(self):
+        self.sync_future(callback=lambda future: 1 / 0)
+        # The exception gets caught by our StackContext and will be re-raised
+        # when we wait.
+        self.assertRaises(ZeroDivisionError, self.wait)
+
+    def test_no_result_future(self):
+        future = self.no_result_future(self.stop)
+        result = self.wait()
+        self.assertIs(result, None)
+        # result of this future is undefined, but not an error
+        future.result()
+
+    def test_no_result_future_callback(self):
+        future = self.no_result_future(callback=lambda: self.stop())
+        result = self.wait()
+        self.assertIs(result, None)
+        future.result()
+
+    @gen_test
+    def test_future_traceback(self):
+        @return_future
+        @gen.engine
+        def f(callback):
+            yield gen.Task(self.io_loop.add_callback)
+            try:
+                1 / 0
+            except ZeroDivisionError:
+                self.expected_frame = traceback.extract_tb(
+                    sys.exc_info()[2], limit=1)[0]
+                raise
+        try:
+            yield f()
+            self.fail("didn't get expected exception")
+        except ZeroDivisionError:
+            tb = traceback.extract_tb(sys.exc_info()[2])
+            self.assertIn(self.expected_frame, tb)
+
+# The following series of classes demonstrate and test various styles
+# of use, with and without generators and futures.
+
+
+class CapServer(TCPServer):
+    def handle_stream(self, stream, address):
+        logging.info("handle_stream")
+        self.stream = stream
+        self.stream.read_until(b"\n", self.handle_read)
+
+    def handle_read(self, data):
+        logging.info("handle_read")
+        data = to_unicode(data)
+        if data == data.upper():
+            self.stream.write(b"error\talready capitalized\n")
+        else:
+            # data already has \n
+            self.stream.write(utf8("ok\t%s" % data.upper()))
+        self.stream.close()
+
+
+class CapError(Exception):
+    pass
+
+
+class BaseCapClient(object):
+    def __init__(self, port, io_loop):
+        self.port = port
+        self.io_loop = io_loop
+
+    def process_response(self, data):
+        status, message = re.match('(.*)\t(.*)\n', to_unicode(data)).groups()
+        if status == 'ok':
+            return message
+        else:
+            raise CapError(message)
+
+
+class ManualCapClient(BaseCapClient):
+    def capitalize(self, request_data, callback=None):
+        logging.info("capitalize")
+        self.request_data = request_data
+        self.stream = IOStream(socket.socket(), io_loop=self.io_loop)
+        self.stream.connect(('127.0.0.1', self.port),
+                            callback=self.handle_connect)
+        self.future = Future()
+        if callback is not None:
+            self.future.add_done_callback(
+                stack_context.wrap(lambda future: callback(future.result())))
+        return self.future
+
+    def handle_connect(self):
+        logging.info("handle_connect")
+        self.stream.write(utf8(self.request_data + "\n"))
+        self.stream.read_until(b'\n', callback=self.handle_read)
+
+    def handle_read(self, data):
+        logging.info("handle_read")
+        self.stream.close()
+        try:
+            self.future.set_result(self.process_response(data))
+        except CapError as e:
+            self.future.set_exception(e)
+
+
+class DecoratorCapClient(BaseCapClient):
+    @return_future
+    def capitalize(self, request_data, callback):
+        logging.info("capitalize")
+        self.request_data = request_data
+        self.stream = IOStream(socket.socket(), io_loop=self.io_loop)
+        self.stream.connect(('127.0.0.1', self.port),
+                            callback=self.handle_connect)
+        self.callback = callback
+
+    def handle_connect(self):
+        logging.info("handle_connect")
+        self.stream.write(utf8(self.request_data + "\n"))
+        self.stream.read_until(b'\n', callback=self.handle_read)
+
+    def handle_read(self, data):
+        logging.info("handle_read")
+        self.stream.close()
+        self.callback(self.process_response(data))
+
+
+class GeneratorCapClient(BaseCapClient):
+    @return_future
+    @gen.engine
+    def capitalize(self, request_data, callback):
+        logging.info('capitalize')
+        stream = IOStream(socket.socket(), io_loop=self.io_loop)
+        logging.info('connecting')
+        yield gen.Task(stream.connect, ('127.0.0.1', self.port))
+        stream.write(utf8(request_data + '\n'))
+        logging.info('reading')
+        data = yield gen.Task(stream.read_until, b'\n')
+        logging.info('returning')
+        stream.close()
+        callback(self.process_response(data))
+
+
+class ClientTestMixin(object):
+    def setUp(self):
+        super(ClientTestMixin, self).setUp()
+        self.server = CapServer(io_loop=self.io_loop)
+        sock, port = bind_unused_port()
+        self.server.add_sockets([sock])
+        self.client = self.client_class(io_loop=self.io_loop, port=port)
+
+    def tearDown(self):
+        self.server.stop()
+        super(ClientTestMixin, self).tearDown()
+
+    def test_callback(self):
+        self.client.capitalize("hello", callback=self.stop)
+        result = self.wait()
+        self.assertEqual(result, "HELLO")
+
+    def test_callback_error(self):
+        self.client.capitalize("HELLO", callback=self.stop)
+        self.assertRaisesRegexp(CapError, "already capitalized", self.wait)
+
+    def test_future(self):
+        future = self.client.capitalize("hello")
+        self.io_loop.add_future(future, self.stop)
+        self.wait()
+        self.assertEqual(future.result(), "HELLO")
+
+    def test_future_error(self):
+        future = self.client.capitalize("HELLO")
+        self.io_loop.add_future(future, self.stop)
+        self.wait()
+        self.assertRaisesRegexp(CapError, "already capitalized", future.result)
+
+    def test_generator(self):
+        @gen.engine
+        def f():
+            result = yield self.client.capitalize("hello")
+            self.assertEqual(result, "HELLO")
+            self.stop()
+        f()
+        self.wait()
+
+    def test_generator_error(self):
+        @gen.engine
+        def f():
+            with self.assertRaisesRegexp(CapError, "already capitalized"):
+                yield self.client.capitalize("HELLO")
+            self.stop()
+        f()
+        self.wait()
+
+
+class ManualClientTest(ClientTestMixin, AsyncTestCase, LogTrapTestCase):
+    client_class = ManualCapClient
+
+
+class DecoratorClientTest(ClientTestMixin, AsyncTestCase, LogTrapTestCase):
+    client_class = DecoratorCapClient
+
+
+class GeneratorClientTest(ClientTestMixin, AsyncTestCase, LogTrapTestCase):
+    client_class = GeneratorCapClient

Shared/lib/python2.7/site-packages/tornado/test/csv_translations/fr_FR.csv

@@ -0,0 +1 @@
+"school","école"

Shared/lib/python2.7/site-packages/tornado/test/curl_httpclient_test.py

@@ -0,0 +1,99 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+from hashlib import md5
+
+from tornado.httpclient import HTTPRequest
+from tornado.stack_context import ExceptionStackContext
+from tornado.testing import AsyncHTTPTestCase
+from tornado.test import httpclient_test
+from tornado.test.util import unittest
+from tornado.web import Application, RequestHandler
+
+try:
+    import pycurl
+except ImportError:
+    pycurl = None
+
+if pycurl is not None:
+    from tornado.curl_httpclient import CurlAsyncHTTPClient
+
+
+@unittest.skipIf(pycurl is None, "pycurl module not present")
+class CurlHTTPClientCommonTestCase(httpclient_test.HTTPClientCommonTestCase):
+    def get_http_client(self):
+        client = CurlAsyncHTTPClient(io_loop=self.io_loop)
+        # make sure AsyncHTTPClient magic doesn't give us the wrong class
+        self.assertTrue(isinstance(client, CurlAsyncHTTPClient))
+        return client
+
+
+class DigestAuthHandler(RequestHandler):
+    def get(self):
+        realm = 'test'
+        opaque = 'asdf'
+        # Real implementations would use a random nonce.
+        nonce = "1234"
+        username = 'foo'
+        password = 'bar'
+
+        auth_header = self.request.headers.get('Authorization', None)
+        if auth_header is not None:
+            auth_mode, params = auth_header.split(' ', 1)
+            assert auth_mode == 'Digest'
+            param_dict = {}
+            for pair in params.split(','):
+                k, v = pair.strip().split('=', 1)
+                if v[0] == '"' and v[-1] == '"':
+                    v = v[1:-1]
+                param_dict[k] = v
+            assert param_dict['realm'] == realm
+            assert param_dict['opaque'] == opaque
+            assert param_dict['nonce'] == nonce
+            assert param_dict['username'] == username
+            assert param_dict['uri'] == self.request.path
+            h1 = md5('%s:%s:%s' % (username, realm, password)).hexdigest()
+            h2 = md5('%s:%s' % (self.request.method,
+                                self.request.path)).hexdigest()
+            digest = md5('%s:%s:%s' % (h1, nonce, h2)).hexdigest()
+            if digest == param_dict['response']:
+                self.write('ok')
+            else:
+                self.write('fail')
+        else:
+            self.set_status(401)
+            self.set_header('WWW-Authenticate',
+                            'Digest realm="%s", nonce="%s", opaque="%s"' %
+                            (realm, nonce, opaque))
+
+
+@unittest.skipIf(pycurl is None, "pycurl module not present")
+class CurlHTTPClientTestCase(AsyncHTTPTestCase):
+    def setUp(self):
+        super(CurlHTTPClientTestCase, self).setUp()
+        self.http_client = CurlAsyncHTTPClient(self.io_loop)
+
+    def get_app(self):
+        return Application([
+            ('/digest', DigestAuthHandler),
+        ])
+
+    def test_prepare_curl_callback_stack_context(self):
+        exc_info = []
+
+        def error_handler(typ, value, tb):
+            exc_info.append((typ, value, tb))
+            self.stop()
+            return True
+
+        with ExceptionStackContext(error_handler):
+            request = HTTPRequest(self.get_url('/'),
+                                  prepare_curl_callback=lambda curl: 1 / 0)
+        self.http_client.fetch(request, callback=self.stop)
+        self.wait()
+        self.assertEqual(1, len(exc_info))
+        self.assertIs(exc_info[0][0], ZeroDivisionError)
+
+    def test_digest_auth(self):
+        response = self.fetch('/digest', auth_mode='digest',
+                              auth_username='foo', auth_password='bar')
+        self.assertEqual(response.body, b'ok')

Shared/lib/python2.7/site-packages/tornado/test/escape_test.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+import tornado.escape
+
+from tornado.escape import utf8, xhtml_escape, xhtml_unescape, url_escape, url_unescape, to_unicode, json_decode, json_encode
+from tornado.util import u, unicode_type, bytes_type
+from tornado.test.util import unittest
+
+linkify_tests = [
+    # (input, linkify_kwargs, expected_output)
+
+    ("hello http://world.com/!", {},
+     u('hello <a href="http://world.com/">http://world.com/</a>!')),
+
+    ("hello http://world.com/with?param=true&stuff=yes", {},
+     u('hello <a href="http://world.com/with?param=true&amp;stuff=yes">http://world.com/with?param=true&amp;stuff=yes</a>')),
+
+    # an opened paren followed by many chars killed Gruber's regex
+    ("http://url.com/w(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", {},
+     u('<a href="http://url.com/w">http://url.com/w</a>(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')),
+
+    # as did too many dots at the end
+    ("http://url.com/withmany.......................................", {},
+     u('<a href="http://url.com/withmany">http://url.com/withmany</a>.......................................')),
+
+    ("http://url.com/withmany((((((((((((((((((((((((((((((((((a)", {},
+     u('<a href="http://url.com/withmany">http://url.com/withmany</a>((((((((((((((((((((((((((((((((((a)')),
+
+    # some examples from http://daringfireball.net/2009/11/liberal_regex_for_matching_urls
+    # plus a fex extras (such as multiple parentheses).
+    ("http://foo.com/blah_blah", {},
+     u('<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>')),
+
+    ("http://foo.com/blah_blah/", {},
+     u('<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>')),
+
+    ("(Something like http://foo.com/blah_blah)", {},
+     u('(Something like <a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>)')),
+
+    ("http://foo.com/blah_blah_(wikipedia)", {},
+     u('<a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>')),
+
+    ("http://foo.com/blah_(blah)_(wikipedia)_blah", {},
+     u('<a href="http://foo.com/blah_(blah)_(wikipedia)_blah">http://foo.com/blah_(blah)_(wikipedia)_blah</a>')),
+
+    ("(Something like http://foo.com/blah_blah_(wikipedia))", {},
+     u('(Something like <a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>)')),
+
+    ("http://foo.com/blah_blah.", {},
+     u('<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>.')),
+
+    ("http://foo.com/blah_blah/.", {},
+     u('<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>.')),
+
+    ("<http://foo.com/blah_blah>", {},
+     u('&lt;<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>&gt;')),
+
+    ("<http://foo.com/blah_blah/>", {},
+     u('&lt;<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>&gt;')),
+
+    ("http://foo.com/blah_blah,", {},
+     u('<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>,')),
+
+    ("http://www.example.com/wpstyle/?p=364.", {},
+     u('<a href="http://www.example.com/wpstyle/?p=364">http://www.example.com/wpstyle/?p=364</a>.')),
+
+    ("rdar://1234",
+     {"permitted_protocols": ["http", "rdar"]},
+     u('<a href="rdar://1234">rdar://1234</a>')),
+
+    ("rdar:/1234",
+     {"permitted_protocols": ["rdar"]},
+     u('<a href="rdar:/1234">rdar:/1234</a>')),
+
+    ("http://userid:password@example.com:8080", {},
+     u('<a href="http://userid:password@example.com:8080">http://userid:password@example.com:8080</a>')),
+
+    ("http://userid@example.com", {},
+     u('<a href="http://userid@example.com">http://userid@example.com</a>')),
+
+    ("http://userid@example.com:8080", {},
+     u('<a href="http://userid@example.com:8080">http://userid@example.com:8080</a>')),
+
+    ("http://userid:password@example.com", {},
+     u('<a href="http://userid:password@example.com">http://userid:password@example.com</a>')),
+
+    ("message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e",
+     {"permitted_protocols": ["http", "message"]},
+     u('<a href="message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e">message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e</a>')),
+
+    (u("http://\u27a1.ws/\u4a39"), {},
+     u('<a href="http://\u27a1.ws/\u4a39">http://\u27a1.ws/\u4a39</a>')),
+
+    ("<tag>http://example.com</tag>", {},
+     u('&lt;tag&gt;<a href="http://example.com">http://example.com</a>&lt;/tag&gt;')),
+
+    ("Just a www.example.com link.", {},
+     u('Just a <a href="http://www.example.com">www.example.com</a> link.')),
+
+    ("Just a www.example.com link.",
+     {"require_protocol": True},
+     u('Just a www.example.com link.')),
+
+    ("A http://reallylong.com/link/that/exceedsthelenglimit.html",
+     {"require_protocol": True, "shorten": True},
+     u('A <a href="http://reallylong.com/link/that/exceedsthelenglimit.html" title="http://reallylong.com/link/that/exceedsthelenglimit.html">http://reallylong.com/link...</a>')),
+
+    ("A http://reallylongdomainnamethatwillbetoolong.com/hi!",
+     {"shorten": True},
+     u('A <a href="http://reallylongdomainnamethatwillbetoolong.com/hi" title="http://reallylongdomainnamethatwillbetoolong.com/hi">http://reallylongdomainnametha...</a>!')),
+
+    ("A file:///passwords.txt and http://web.com link", {},
+     u('A file:///passwords.txt and <a href="http://web.com">http://web.com</a> link')),
+
+    ("A file:///passwords.txt and http://web.com link",
+     {"permitted_protocols": ["file"]},
+     u('A <a href="file:///passwords.txt">file:///passwords.txt</a> and http://web.com link')),
+
+    ("www.external-link.com",
+     {"extra_params": 'rel="nofollow" class="external"'},
+     u('<a href="http://www.external-link.com" rel="nofollow" class="external">www.external-link.com</a>')),
+
+    ("www.external-link.com and www.internal-link.com/blogs extra",
+     {"extra_params": lambda href: 'class="internal"' if href.startswith("http://www.internal-link.com") else 'rel="nofollow" class="external"'},
+     u('<a href="http://www.external-link.com" rel="nofollow" class="external">www.external-link.com</a> and <a href="http://www.internal-link.com/blogs" class="internal">www.internal-link.com/blogs</a> extra')),
+
+    ("www.external-link.com",
+     {"extra_params": lambda href: '    rel="nofollow" class="external"  '},
+     u('<a href="http://www.external-link.com" rel="nofollow" class="external">www.external-link.com</a>')),
+]
+
+
+class EscapeTestCase(unittest.TestCase):
+    def test_linkify(self):
+        for text, kwargs, html in linkify_tests:
+            linked = tornado.escape.linkify(text, **kwargs)
+            self.assertEqual(linked, html)
+
+    def test_xhtml_escape(self):
+        tests = [
+            ("<foo>", "&lt;foo&gt;"),
+            (u("<foo>"), u("&lt;foo&gt;")),
+            (b"<foo>", b"&lt;foo&gt;"),
+
+            ("<>&\"", "&lt;&gt;&amp;&quot;"),
+            ("&amp;", "&amp;amp;"),
+
+            (u("<\u00e9>"), u("&lt;\u00e9&gt;")),
+            (b"<\xc3\xa9>", b"&lt;\xc3\xa9&gt;"),
+        ]
+        for unescaped, escaped in tests:
+            self.assertEqual(utf8(xhtml_escape(unescaped)), utf8(escaped))
+            self.assertEqual(utf8(unescaped), utf8(xhtml_unescape(escaped)))
+
+    def test_url_escape_unicode(self):
+        tests = [
+            # byte strings are passed through as-is
+            (u('\u00e9').encode('utf8'), '%C3%A9'),
+            (u('\u00e9').encode('latin1'), '%E9'),
+
+            # unicode strings become utf8
+            (u('\u00e9'), '%C3%A9'),
+        ]
+        for unescaped, escaped in tests:
+            self.assertEqual(url_escape(unescaped), escaped)
+
+    def test_url_unescape_unicode(self):
+        tests = [
+            ('%C3%A9', u('\u00e9'), 'utf8'),
+            ('%C3%A9', u('\u00c3\u00a9'), 'latin1'),
+            ('%C3%A9', utf8(u('\u00e9')), None),
+        ]
+        for escaped, unescaped, encoding in tests:
+            # input strings to url_unescape should only contain ascii
+            # characters, but make sure the function accepts both byte
+            # and unicode strings.
+            self.assertEqual(url_unescape(to_unicode(escaped), encoding), unescaped)
+            self.assertEqual(url_unescape(utf8(escaped), encoding), unescaped)
+
+    def test_url_escape_quote_plus(self):
+        unescaped = '+ #%'
+        plus_escaped = '%2B+%23%25'
+        escaped = '%2B%20%23%25'
+        self.assertEqual(url_escape(unescaped), plus_escaped)
+        self.assertEqual(url_escape(unescaped, plus=False), escaped)
+        self.assertEqual(url_unescape(plus_escaped), unescaped)
+        self.assertEqual(url_unescape(escaped, plus=False), unescaped)
+        self.assertEqual(url_unescape(plus_escaped, encoding=None),
+                         utf8(unescaped))
+        self.assertEqual(url_unescape(escaped, encoding=None, plus=False),
+                         utf8(unescaped))
+
+    def test_escape_return_types(self):
+        # On python2 the escape methods should generally return the same
+        # type as their argument
+        self.assertEqual(type(xhtml_escape("foo")), str)
+        self.assertEqual(type(xhtml_escape(u("foo"))), unicode_type)
+
+    def test_json_decode(self):
+        # json_decode accepts both bytes and unicode, but strings it returns
+        # are always unicode.
+        self.assertEqual(json_decode(b'"foo"'), u("foo"))
+        self.assertEqual(json_decode(u('"foo"')), u("foo"))
+
+        # Non-ascii bytes are interpreted as utf8
+        self.assertEqual(json_decode(utf8(u('"\u00e9"'))), u("\u00e9"))
+
+    def test_json_encode(self):
+        # json deals with strings, not bytes.  On python 2 byte strings will
+        # convert automatically if they are utf8; on python 3 byte strings
+        # are not allowed.
+        self.assertEqual(json_decode(json_encode(u("\u00e9"))), u("\u00e9"))
+        if bytes_type is str:
+            self.assertEqual(json_decode(json_encode(utf8(u("\u00e9")))), u("\u00e9"))
+            self.assertRaises(UnicodeDecodeError, json_encode, b"\xe9")

Shared/lib/python2.7/site-packages/tornado/test/gen_test.py

@@ -0,0 +1,913 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import contextlib
+import functools
+import sys
+import textwrap
+import time
+import platform
+import weakref
+
+from tornado.concurrent import return_future
+from tornado.escape import url_escape
+from tornado.httpclient import AsyncHTTPClient
+from tornado.ioloop import IOLoop
+from tornado.log import app_log
+from tornado import stack_context
+from tornado.testing import AsyncHTTPTestCase, AsyncTestCase, ExpectLog, gen_test
+from tornado.test.util import unittest, skipOnTravis
+from tornado.web import Application, RequestHandler, asynchronous, HTTPError
+
+from tornado import gen
+
+
+skipBefore33 = unittest.skipIf(sys.version_info < (3, 3), 'PEP 380 not available')
+skipNotCPython = unittest.skipIf(platform.python_implementation() != 'CPython',
+                                 'Not CPython implementation')
+
+
+class GenEngineTest(AsyncTestCase):
+    def setUp(self):
+        super(GenEngineTest, self).setUp()
+        self.named_contexts = []
+
+    def named_context(self, name):
+        @contextlib.contextmanager
+        def context():
+            self.named_contexts.append(name)
+            try:
+                yield
+            finally:
+                self.assertEqual(self.named_contexts.pop(), name)
+        return context
+
+    def run_gen(self, f):
+        f()
+        return self.wait()
+
+    def delay_callback(self, iterations, callback, arg):
+        """Runs callback(arg) after a number of IOLoop iterations."""
+        if iterations == 0:
+            callback(arg)
+        else:
+            self.io_loop.add_callback(functools.partial(
+                self.delay_callback, iterations - 1, callback, arg))
+
+    @return_future
+    def async_future(self, result, callback):
+        self.io_loop.add_callback(callback, result)
+
+    def test_no_yield(self):
+        @gen.engine
+        def f():
+            self.stop()
+        self.run_gen(f)
+
+    def test_inline_cb(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback("k1"))()
+            res = yield gen.Wait("k1")
+            self.assertTrue(res is None)
+            self.stop()
+        self.run_gen(f)
+
+    def test_ioloop_cb(self):
+        @gen.engine
+        def f():
+            self.io_loop.add_callback((yield gen.Callback("k1")))
+            yield gen.Wait("k1")
+            self.stop()
+        self.run_gen(f)
+
+    def test_exception_phase1(self):
+        @gen.engine
+        def f():
+            1 / 0
+        self.assertRaises(ZeroDivisionError, self.run_gen, f)
+
+    def test_exception_phase2(self):
+        @gen.engine
+        def f():
+            self.io_loop.add_callback((yield gen.Callback("k1")))
+            yield gen.Wait("k1")
+            1 / 0
+        self.assertRaises(ZeroDivisionError, self.run_gen, f)
+
+    def test_exception_in_task_phase1(self):
+        def fail_task(callback):
+            1 / 0
+
+        @gen.engine
+        def f():
+            try:
+                yield gen.Task(fail_task)
+                raise Exception("did not get expected exception")
+            except ZeroDivisionError:
+                self.stop()
+        self.run_gen(f)
+
+    def test_exception_in_task_phase2(self):
+        # This is the case that requires the use of stack_context in gen.engine
+        def fail_task(callback):
+            self.io_loop.add_callback(lambda: 1 / 0)
+
+        @gen.engine
+        def f():
+            try:
+                yield gen.Task(fail_task)
+                raise Exception("did not get expected exception")
+            except ZeroDivisionError:
+                self.stop()
+        self.run_gen(f)
+
+    def test_with_arg(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback("k1"))(42)
+            res = yield gen.Wait("k1")
+            self.assertEqual(42, res)
+            self.stop()
+        self.run_gen(f)
+
+    def test_with_arg_tuple(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback((1, 2)))((3, 4))
+            res = yield gen.Wait((1, 2))
+            self.assertEqual((3, 4), res)
+            self.stop()
+        self.run_gen(f)
+
+    def test_key_reuse(self):
+        @gen.engine
+        def f():
+            yield gen.Callback("k1")
+            yield gen.Callback("k1")
+            self.stop()
+        self.assertRaises(gen.KeyReuseError, self.run_gen, f)
+
+    def test_key_reuse_tuple(self):
+        @gen.engine
+        def f():
+            yield gen.Callback((1, 2))
+            yield gen.Callback((1, 2))
+            self.stop()
+        self.assertRaises(gen.KeyReuseError, self.run_gen, f)
+
+    def test_key_mismatch(self):
+        @gen.engine
+        def f():
+            yield gen.Callback("k1")
+            yield gen.Wait("k2")
+            self.stop()
+        self.assertRaises(gen.UnknownKeyError, self.run_gen, f)
+
+    def test_key_mismatch_tuple(self):
+        @gen.engine
+        def f():
+            yield gen.Callback((1, 2))
+            yield gen.Wait((2, 3))
+            self.stop()
+        self.assertRaises(gen.UnknownKeyError, self.run_gen, f)
+
+    def test_leaked_callback(self):
+        @gen.engine
+        def f():
+            yield gen.Callback("k1")
+            self.stop()
+        self.assertRaises(gen.LeakedCallbackError, self.run_gen, f)
+
+    def test_leaked_callback_tuple(self):
+        @gen.engine
+        def f():
+            yield gen.Callback((1, 2))
+            self.stop()
+        self.assertRaises(gen.LeakedCallbackError, self.run_gen, f)
+
+    def test_parallel_callback(self):
+        @gen.engine
+        def f():
+            for k in range(3):
+                self.io_loop.add_callback((yield gen.Callback(k)))
+            yield gen.Wait(1)
+            self.io_loop.add_callback((yield gen.Callback(3)))
+            yield gen.Wait(0)
+            yield gen.Wait(3)
+            yield gen.Wait(2)
+            self.stop()
+        self.run_gen(f)
+
+    def test_bogus_yield(self):
+        @gen.engine
+        def f():
+            yield 42
+        self.assertRaises(gen.BadYieldError, self.run_gen, f)
+
+    def test_bogus_yield_tuple(self):
+        @gen.engine
+        def f():
+            yield (1, 2)
+        self.assertRaises(gen.BadYieldError, self.run_gen, f)
+
+    def test_reuse(self):
+        @gen.engine
+        def f():
+            self.io_loop.add_callback((yield gen.Callback(0)))
+            yield gen.Wait(0)
+            self.stop()
+        self.run_gen(f)
+        self.run_gen(f)
+
+    def test_task(self):
+        @gen.engine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            self.stop()
+        self.run_gen(f)
+
+    def test_wait_all(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback("k1"))("v1")
+            (yield gen.Callback("k2"))("v2")
+            results = yield gen.WaitAll(["k1", "k2"])
+            self.assertEqual(results, ["v1", "v2"])
+            self.stop()
+        self.run_gen(f)
+
+    def test_exception_in_yield(self):
+        @gen.engine
+        def f():
+            try:
+                yield gen.Wait("k1")
+                raise Exception("did not get expected exception")
+            except gen.UnknownKeyError:
+                pass
+            self.stop()
+        self.run_gen(f)
+
+    def test_resume_after_exception_in_yield(self):
+        @gen.engine
+        def f():
+            try:
+                yield gen.Wait("k1")
+                raise Exception("did not get expected exception")
+            except gen.UnknownKeyError:
+                pass
+            (yield gen.Callback("k2"))("v2")
+            self.assertEqual((yield gen.Wait("k2")), "v2")
+            self.stop()
+        self.run_gen(f)
+
+    def test_orphaned_callback(self):
+        @gen.engine
+        def f():
+            self.orphaned_callback = yield gen.Callback(1)
+        try:
+            self.run_gen(f)
+            raise Exception("did not get expected exception")
+        except gen.LeakedCallbackError:
+            pass
+        self.orphaned_callback()
+
+    def test_multi(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback("k1"))("v1")
+            (yield gen.Callback("k2"))("v2")
+            results = yield [gen.Wait("k1"), gen.Wait("k2")]
+            self.assertEqual(results, ["v1", "v2"])
+            self.stop()
+        self.run_gen(f)
+
+    def test_multi_delayed(self):
+        @gen.engine
+        def f():
+            # callbacks run at different times
+            responses = yield [
+                gen.Task(self.delay_callback, 3, arg="v1"),
+                gen.Task(self.delay_callback, 1, arg="v2"),
+            ]
+            self.assertEqual(responses, ["v1", "v2"])
+            self.stop()
+        self.run_gen(f)
+
+    @skipOnTravis
+    @gen_test
+    def test_multi_performance(self):
+        # Yielding a list used to have quadratic performance; make
+        # sure a large list stays reasonable.  On my laptop a list of
+        # 2000 used to take 1.8s, now it takes 0.12.
+        start = time.time()
+        yield [gen.Task(self.io_loop.add_callback) for i in range(2000)]
+        end = time.time()
+        self.assertLess(end - start, 1.0)
+
+    @gen_test
+    def test_future(self):
+        result = yield self.async_future(1)
+        self.assertEqual(result, 1)
+
+    @gen_test
+    def test_multi_future(self):
+        results = yield [self.async_future(1), self.async_future(2)]
+        self.assertEqual(results, [1, 2])
+
+    def test_arguments(self):
+        @gen.engine
+        def f():
+            (yield gen.Callback("noargs"))()
+            self.assertEqual((yield gen.Wait("noargs")), None)
+            (yield gen.Callback("1arg"))(42)
+            self.assertEqual((yield gen.Wait("1arg")), 42)
+
+            (yield gen.Callback("kwargs"))(value=42)
+            result = yield gen.Wait("kwargs")
+            self.assertTrue(isinstance(result, gen.Arguments))
+            self.assertEqual(((), dict(value=42)), result)
+            self.assertEqual(dict(value=42), result.kwargs)
+
+            (yield gen.Callback("2args"))(42, 43)
+            result = yield gen.Wait("2args")
+            self.assertTrue(isinstance(result, gen.Arguments))
+            self.assertEqual(((42, 43), {}), result)
+            self.assertEqual((42, 43), result.args)
+
+            def task_func(callback):
+                callback(None, error="foo")
+            result = yield gen.Task(task_func)
+            self.assertTrue(isinstance(result, gen.Arguments))
+            self.assertEqual(((None,), dict(error="foo")), result)
+
+            self.stop()
+        self.run_gen(f)
+
+    def test_stack_context_leak(self):
+        # regression test: repeated invocations of a gen-based
+        # function should not result in accumulated stack_contexts
+        def _stack_depth():
+            head = stack_context._state.contexts[1]
+            length = 0
+
+            while head is not None:
+                length += 1
+                head = head.old_contexts[1]
+
+            return length
+
+        @gen.engine
+        def inner(callback):
+            yield gen.Task(self.io_loop.add_callback)
+            callback()
+
+        @gen.engine
+        def outer():
+            for i in range(10):
+                yield gen.Task(inner)
+
+            stack_increase = _stack_depth() - initial_stack_depth
+            self.assertTrue(stack_increase <= 2)
+            self.stop()
+        initial_stack_depth = _stack_depth()
+        self.run_gen(outer)
+
+    def test_stack_context_leak_exception(self):
+        # same as previous, but with a function that exits with an exception
+        @gen.engine
+        def inner(callback):
+            yield gen.Task(self.io_loop.add_callback)
+            1 / 0
+
+        @gen.engine
+        def outer():
+            for i in range(10):
+                try:
+                    yield gen.Task(inner)
+                except ZeroDivisionError:
+                    pass
+            stack_increase = len(stack_context._state.contexts) - initial_stack_depth
+            self.assertTrue(stack_increase <= 2)
+            self.stop()
+        initial_stack_depth = len(stack_context._state.contexts)
+        self.run_gen(outer)
+
+    def function_with_stack_context(self, callback):
+        # Technically this function should stack_context.wrap its callback
+        # upon entry.  However, it is very common for this step to be
+        # omitted.
+        def step2():
+            self.assertEqual(self.named_contexts, ['a'])
+            self.io_loop.add_callback(callback)
+
+        with stack_context.StackContext(self.named_context('a')):
+            self.io_loop.add_callback(step2)
+
+    @gen_test
+    def test_wait_transfer_stack_context(self):
+        # Wait should not pick up contexts from where callback was invoked,
+        # even if that function improperly fails to wrap its callback.
+        cb = yield gen.Callback('k1')
+        self.function_with_stack_context(cb)
+        self.assertEqual(self.named_contexts, [])
+        yield gen.Wait('k1')
+        self.assertEqual(self.named_contexts, [])
+
+    @gen_test
+    def test_task_transfer_stack_context(self):
+        yield gen.Task(self.function_with_stack_context)
+        self.assertEqual(self.named_contexts, [])
+
+    def test_raise_after_stop(self):
+        # This pattern will be used in the following tests so make sure
+        # the exception propagates as expected.
+        @gen.engine
+        def f():
+            self.stop()
+            1 / 0
+
+        with self.assertRaises(ZeroDivisionError):
+            self.run_gen(f)
+
+    def test_sync_raise_return(self):
+        # gen.Return is allowed in @gen.engine, but it may not be used
+        # to return a value.
+        @gen.engine
+        def f():
+            self.stop(42)
+            raise gen.Return()
+
+        result = self.run_gen(f)
+        self.assertEqual(result, 42)
+
+    def test_async_raise_return(self):
+        @gen.engine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            self.stop(42)
+            raise gen.Return()
+
+        result = self.run_gen(f)
+        self.assertEqual(result, 42)
+
+    def test_sync_raise_return_value(self):
+        @gen.engine
+        def f():
+            raise gen.Return(42)
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    def test_sync_raise_return_value_tuple(self):
+        @gen.engine
+        def f():
+            raise gen.Return((1, 2))
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    def test_async_raise_return_value(self):
+        @gen.engine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            raise gen.Return(42)
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    def test_async_raise_return_value_tuple(self):
+        @gen.engine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            raise gen.Return((1, 2))
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    def test_return_value(self):
+        # It is an error to apply @gen.engine to a function that returns
+        # a value.
+        @gen.engine
+        def f():
+            return 42
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    def test_return_value_tuple(self):
+        # It is an error to apply @gen.engine to a function that returns
+        # a value.
+        @gen.engine
+        def f():
+            return (1, 2)
+
+        with self.assertRaises(gen.ReturnValueIgnoredError):
+            self.run_gen(f)
+
+    @skipNotCPython
+    def test_task_refcounting(self):
+        # On CPython, tasks and their arguments should be released immediately
+        # without waiting for garbage collection.
+        @gen.engine
+        def f():
+            class Foo(object):
+                pass
+            arg = Foo()
+            self.arg_ref = weakref.ref(arg)
+            task = gen.Task(self.io_loop.add_callback, arg=arg)
+            self.task_ref = weakref.ref(task)
+            yield task
+            self.stop()
+
+        self.run_gen(f)
+        self.assertIs(self.arg_ref(), None)
+        self.assertIs(self.task_ref(), None)
+
+
+class GenCoroutineTest(AsyncTestCase):
+    def setUp(self):
+        # Stray StopIteration exceptions can lead to tests exiting prematurely,
+        # so we need explicit checks here to make sure the tests run all
+        # the way through.
+        self.finished = False
+        super(GenCoroutineTest, self).setUp()
+
+    def tearDown(self):
+        super(GenCoroutineTest, self).tearDown()
+        assert self.finished
+
+    @gen_test
+    def test_sync_gen_return(self):
+        @gen.coroutine
+        def f():
+            raise gen.Return(42)
+        result = yield f()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @gen_test
+    def test_async_gen_return(self):
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            raise gen.Return(42)
+        result = yield f()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @gen_test
+    def test_sync_return(self):
+        @gen.coroutine
+        def f():
+            return 42
+        result = yield f()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @skipBefore33
+    @gen_test
+    def test_async_return(self):
+        # It is a compile-time error to return a value in a generator
+        # before Python 3.3, so we must test this with exec.
+        # Flatten the real global and local namespace into our fake globals:
+        # it's all global from the perspective of f().
+        global_namespace = dict(globals(), **locals())
+        local_namespace = {}
+        exec(textwrap.dedent("""
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            return 42
+        """), global_namespace, local_namespace)
+        result = yield local_namespace['f']()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @skipBefore33
+    @gen_test
+    def test_async_early_return(self):
+        # A yield statement exists but is not executed, which means
+        # this function "returns" via an exception.  This exception
+        # doesn't happen before the exception handling is set up.
+        global_namespace = dict(globals(), **locals())
+        local_namespace = {}
+        exec(textwrap.dedent("""
+        @gen.coroutine
+        def f():
+            if True:
+                return 42
+            yield gen.Task(self.io_loop.add_callback)
+        """), global_namespace, local_namespace)
+        result = yield local_namespace['f']()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @gen_test
+    def test_sync_return_no_value(self):
+        @gen.coroutine
+        def f():
+            return
+        result = yield f()
+        self.assertEqual(result, None)
+        self.finished = True
+
+    @gen_test
+    def test_async_return_no_value(self):
+        # Without a return value we don't need python 3.3.
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            return
+        result = yield f()
+        self.assertEqual(result, None)
+        self.finished = True
+
+    @gen_test
+    def test_sync_raise(self):
+        @gen.coroutine
+        def f():
+            1 / 0
+        # The exception is raised when the future is yielded
+        # (or equivalently when its result method is called),
+        # not when the function itself is called).
+        future = f()
+        with self.assertRaises(ZeroDivisionError):
+            yield future
+        self.finished = True
+
+    @gen_test
+    def test_async_raise(self):
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            1 / 0
+        future = f()
+        with self.assertRaises(ZeroDivisionError):
+            yield future
+        self.finished = True
+
+    @gen_test
+    def test_pass_callback(self):
+        @gen.coroutine
+        def f():
+            raise gen.Return(42)
+        result = yield gen.Task(f)
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @gen_test
+    def test_replace_yieldpoint_exception(self):
+        # Test exception handling: a coroutine can catch one exception
+        # raised by a yield point and raise a different one.
+        @gen.coroutine
+        def f1():
+            1 / 0
+
+        @gen.coroutine
+        def f2():
+            try:
+                yield f1()
+            except ZeroDivisionError:
+                raise KeyError()
+
+        future = f2()
+        with self.assertRaises(KeyError):
+            yield future
+        self.finished = True
+
+    @gen_test
+    def test_swallow_yieldpoint_exception(self):
+        # Test exception handling: a coroutine can catch an exception
+        # raised by a yield point and not raise a different one.
+        @gen.coroutine
+        def f1():
+            1 / 0
+
+        @gen.coroutine
+        def f2():
+            try:
+                yield f1()
+            except ZeroDivisionError:
+                raise gen.Return(42)
+
+        result = yield f2()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+    @gen_test
+    def test_replace_context_exception(self):
+        # Test exception handling: exceptions thrown into the stack context
+        # can be caught and replaced.
+        @gen.coroutine
+        def f2():
+            self.io_loop.add_callback(lambda: 1 / 0)
+            try:
+                yield gen.Task(self.io_loop.add_timeout,
+                               self.io_loop.time() + 10)
+            except ZeroDivisionError:
+                raise KeyError()
+
+        future = f2()
+        with self.assertRaises(KeyError):
+            yield future
+        self.finished = True
+
+    @gen_test
+    def test_swallow_context_exception(self):
+        # Test exception handling: exceptions thrown into the stack context
+        # can be caught and ignored.
+        @gen.coroutine
+        def f2():
+            self.io_loop.add_callback(lambda: 1 / 0)
+            try:
+                yield gen.Task(self.io_loop.add_timeout,
+                               self.io_loop.time() + 10)
+            except ZeroDivisionError:
+                raise gen.Return(42)
+
+        result = yield f2()
+        self.assertEqual(result, 42)
+        self.finished = True
+
+
+class GenSequenceHandler(RequestHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        self.io_loop = self.request.connection.stream.io_loop
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        self.write("1")
+        self.io_loop.add_callback((yield gen.Callback("k2")))
+        yield gen.Wait("k2")
+        self.write("2")
+        # reuse an old key
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        self.finish("3")
+
+
+class GenCoroutineSequenceHandler(RequestHandler):
+    @gen.coroutine
+    def get(self):
+        self.io_loop = self.request.connection.stream.io_loop
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        self.write("1")
+        self.io_loop.add_callback((yield gen.Callback("k2")))
+        yield gen.Wait("k2")
+        self.write("2")
+        # reuse an old key
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        self.finish("3")
+
+
+class GenCoroutineUnfinishedSequenceHandler(RequestHandler):
+    @asynchronous
+    @gen.coroutine
+    def get(self):
+        self.io_loop = self.request.connection.stream.io_loop
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        self.write("1")
+        self.io_loop.add_callback((yield gen.Callback("k2")))
+        yield gen.Wait("k2")
+        self.write("2")
+        # reuse an old key
+        self.io_loop.add_callback((yield gen.Callback("k1")))
+        yield gen.Wait("k1")
+        # just write, don't finish
+        self.write("3")
+
+
+class GenTaskHandler(RequestHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        io_loop = self.request.connection.stream.io_loop
+        client = AsyncHTTPClient(io_loop=io_loop)
+        response = yield gen.Task(client.fetch, self.get_argument('url'))
+        response.rethrow()
+        self.finish(b"got response: " + response.body)
+
+
+class GenExceptionHandler(RequestHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        # This test depends on the order of the two decorators.
+        io_loop = self.request.connection.stream.io_loop
+        yield gen.Task(io_loop.add_callback)
+        raise Exception("oops")
+
+
+class GenCoroutineExceptionHandler(RequestHandler):
+    @asynchronous
+    @gen.coroutine
+    def get(self):
+        # This test depends on the order of the two decorators.
+        io_loop = self.request.connection.stream.io_loop
+        yield gen.Task(io_loop.add_callback)
+        raise Exception("oops")
+
+
+class GenYieldExceptionHandler(RequestHandler):
+    @asynchronous
+    @gen.engine
+    def get(self):
+        io_loop = self.request.connection.stream.io_loop
+        # Test the interaction of the two stack_contexts.
+
+        def fail_task(callback):
+            io_loop.add_callback(lambda: 1 / 0)
+        try:
+            yield gen.Task(fail_task)
+            raise Exception("did not get expected exception")
+        except ZeroDivisionError:
+            self.finish('ok')
+
+
+class UndecoratedCoroutinesHandler(RequestHandler):
+    @gen.coroutine
+    def prepare(self):
+        self.chunks = []
+        yield gen.Task(IOLoop.current().add_callback)
+        self.chunks.append('1')
+
+    @gen.coroutine
+    def get(self):
+        self.chunks.append('2')
+        yield gen.Task(IOLoop.current().add_callback)
+        self.chunks.append('3')
+        yield gen.Task(IOLoop.current().add_callback)
+        self.write(''.join(self.chunks))
+
+
+class AsyncPrepareErrorHandler(RequestHandler):
+    @gen.coroutine
+    def prepare(self):
+        yield gen.Task(IOLoop.current().add_callback)
+        raise HTTPError(403)
+
+    def get(self):
+        self.finish('ok')
+
+
+class GenWebTest(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([
+            ('/sequence', GenSequenceHandler),
+            ('/coroutine_sequence', GenCoroutineSequenceHandler),
+            ('/coroutine_unfinished_sequence',
+             GenCoroutineUnfinishedSequenceHandler),
+            ('/task', GenTaskHandler),
+            ('/exception', GenExceptionHandler),
+            ('/coroutine_exception', GenCoroutineExceptionHandler),
+            ('/yield_exception', GenYieldExceptionHandler),
+            ('/undecorated_coroutine', UndecoratedCoroutinesHandler),
+            ('/async_prepare_error', AsyncPrepareErrorHandler),
+        ])
+
+    def test_sequence_handler(self):
+        response = self.fetch('/sequence')
+        self.assertEqual(response.body, b"123")
+
+    def test_coroutine_sequence_handler(self):
+        response = self.fetch('/coroutine_sequence')
+        self.assertEqual(response.body, b"123")
+
+    def test_coroutine_unfinished_sequence_handler(self):
+        response = self.fetch('/coroutine_unfinished_sequence')
+        self.assertEqual(response.body, b"123")
+
+    def test_task_handler(self):
+        response = self.fetch('/task?url=%s' % url_escape(self.get_url('/sequence')))
+        self.assertEqual(response.body, b"got response: 123")
+
+    def test_exception_handler(self):
+        # Make sure we get an error and not a timeout
+        with ExpectLog(app_log, "Uncaught exception GET /exception"):
+            response = self.fetch('/exception')
+        self.assertEqual(500, response.code)
+
+    def test_coroutine_exception_handler(self):
+        # Make sure we get an error and not a timeout
+        with ExpectLog(app_log, "Uncaught exception GET /coroutine_exception"):
+            response = self.fetch('/coroutine_exception')
+        self.assertEqual(500, response.code)
+
+    def test_yield_exception_handler(self):
+        response = self.fetch('/yield_exception')
+        self.assertEqual(response.body, b'ok')
+
+    def test_undecorated_coroutines(self):
+        response = self.fetch('/undecorated_coroutine')
+        self.assertEqual(response.body, b'123')
+
+    def test_async_prepare_error_handler(self):
+        response = self.fetch('/async_prepare_error')
+        self.assertEqual(response.code, 403)
+
+if __name__ == '__main__':
+    unittest.main()

Shared/lib/python2.7/site-packages/tornado/test/gettext_translations/fr_FR/LC_MESSAGES/tornado_test.po

@@ -0,0 +1,22 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2012-06-14 01:10-0700\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: extract_me.py:1
+msgid "school"
+msgstr "école"

Shared/lib/python2.7/site-packages/tornado/test/httpclient_test.py

@@ -0,0 +1,471 @@
+#!/usr/bin/env python
+
+from __future__ import absolute_import, division, print_function, with_statement
+
+import base64
+import binascii
+from contextlib import closing
+import functools
+import sys
+import threading
+
+from tornado.escape import utf8
+from tornado.httpclient import HTTPRequest, HTTPResponse, _RequestProxy, HTTPError, HTTPClient
+from tornado.httpserver import HTTPServer
+from tornado.ioloop import IOLoop
+from tornado.iostream import IOStream
+from tornado.log import gen_log
+from tornado import netutil
+from tornado.stack_context import ExceptionStackContext, NullContext
+from tornado.testing import AsyncHTTPTestCase, bind_unused_port, gen_test, ExpectLog
+from tornado.test.util import unittest
+from tornado.util import u, bytes_type
+from tornado.web import Application, RequestHandler, url
+
+try:
+    from io import BytesIO  # python 3
+except ImportError:
+    from cStringIO import StringIO as BytesIO
+
+
+class HelloWorldHandler(RequestHandler):
+    def get(self):
+        name = self.get_argument("name", "world")
+        self.set_header("Content-Type", "text/plain")
+        self.finish("Hello %s!" % name)
+
+
+class PostHandler(RequestHandler):
+    def post(self):
+        self.finish("Post arg1: %s, arg2: %s" % (
+            self.get_argument("arg1"), self.get_argument("arg2")))
+
+
+class ChunkHandler(RequestHandler):
+    def get(self):
+        self.write("asdf")
+        self.flush()
+        self.write("qwer")
+
+
+class AuthHandler(RequestHandler):
+    def get(self):
+        self.finish(self.request.headers["Authorization"])
+
+
+class CountdownHandler(RequestHandler):
+    def get(self, count):
+        count = int(count)
+        if count > 0:
+            self.redirect(self.reverse_url("countdown", count - 1))
+        else:
+            self.write("Zero")
+
+
+class EchoPostHandler(RequestHandler):
+    def post(self):
+        self.write(self.request.body)
+
+
+class UserAgentHandler(RequestHandler):
+    def get(self):
+        self.write(self.request.headers.get('User-Agent', 'User agent not set'))
+
+
+class ContentLength304Handler(RequestHandler):
+    def get(self):
+        self.set_status(304)
+        self.set_header('Content-Length', 42)
+
+    def _clear_headers_for_304(self):
+        # Tornado strips content-length from 304 responses, but here we
+        # want to simulate servers that include the headers anyway.
+        pass
+
+
+class AllMethodsHandler(RequestHandler):
+    SUPPORTED_METHODS = RequestHandler.SUPPORTED_METHODS + ('OTHER',)
+
+    def method(self):
+        self.write(self.request.method)
+
+    get = post = put = delete = options = patch = other = method
+
+# These tests end up getting run redundantly: once here with the default
+# HTTPClient implementation, and then again in each implementation's own
+# test suite.
+
+
+class HTTPClientCommonTestCase(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([
+            url("/hello", HelloWorldHandler),
+            url("/post", PostHandler),
+            url("/chunk", ChunkHandler),
+            url("/auth", AuthHandler),
+            url("/countdown/([0-9]+)", CountdownHandler, name="countdown"),
+            url("/echopost", EchoPostHandler),
+            url("/user_agent", UserAgentHandler),
+            url("/304_with_content_length", ContentLength304Handler),
+            url("/all_methods", AllMethodsHandler),
+        ], gzip=True)
+
+    def test_hello_world(self):
+        response = self.fetch("/hello")
+        self.assertEqual(response.code, 200)
+        self.assertEqual(response.headers["Content-Type"], "text/plain")
+        self.assertEqual(response.body, b"Hello world!")
+        self.assertEqual(int(response.request_time), 0)
+
+        response = self.fetch("/hello?name=Ben")
+        self.assertEqual(response.body, b"Hello Ben!")
+
+    def test_streaming_callback(self):
+        # streaming_callback is also tested in test_chunked
+        chunks = []
+        response = self.fetch("/hello",
+                              streaming_callback=chunks.append)
+        # with streaming_callback, data goes to the callback and not response.body
+        self.assertEqual(chunks, [b"Hello world!"])
+        self.assertFalse(response.body)
+
+    def test_post(self):
+        response = self.fetch("/post", method="POST",
+                              body="arg1=foo&arg2=bar")
+        self.assertEqual(response.code, 200)
+        self.assertEqual(response.body, b"Post arg1: foo, arg2: bar")
+
+    def test_chunked(self):
+        response = self.fetch("/chunk")
+        self.assertEqual(response.body, b"asdfqwer")
+
+        chunks = []
+        response = self.fetch("/chunk",
+                              streaming_callback=chunks.append)
+        self.assertEqual(chunks, [b"asdf", b"qwer"])
+        self.assertFalse(response.body)
+
+    def test_chunked_close(self):
+        # test case in which chunks spread read-callback processing
+        # over several ioloop iterations, but the connection is already closed.
+        sock, port = bind_unused_port()
+        with closing(sock):
+            def write_response(stream, request_data):
+                stream.write(b"""\
+HTTP/1.1 200 OK
+Transfer-Encoding: chunked
+
+1
+1
+1
+2
+0
+
+""".replace(b"\n", b"\r\n"), callback=stream.close)
+
+            def accept_callback(conn, address):
+                # fake an HTTP server using chunked encoding where the final chunks
+                # and connection close all happen at once
+                stream = IOStream(conn, io_loop=self.io_loop)
+                stream.read_until(b"\r\n\r\n",
+                                  functools.partial(write_response, stream))
+            netutil.add_accept_handler(sock, accept_callback, self.io_loop)
+            self.http_client.fetch("http://127.0.0.1:%d/" % port, self.stop)
+            resp = self.wait()
+            resp.rethrow()
+            self.assertEqual(resp.body, b"12")
+            self.io_loop.remove_handler(sock.fileno())
+
+    def test_streaming_stack_context(self):
+        chunks = []
+        exc_info = []
+
+        def error_handler(typ, value, tb):
+            exc_info.append((typ, value, tb))
+            return True
+
+        def streaming_cb(chunk):
+            chunks.append(chunk)
+            if chunk == b'qwer':
+                1 / 0
+
+        with ExceptionStackContext(error_handler):
+            self.fetch('/chunk', streaming_callback=streaming_cb)
+
+        self.assertEqual(chunks, [b'asdf', b'qwer'])
+        self.assertEqual(1, len(exc_info))
+        self.assertIs(exc_info[0][0], ZeroDivisionError)
+
+    def test_basic_auth(self):
+        self.assertEqual(self.fetch("/auth", auth_username="Aladdin",
+                                    auth_password="open sesame").body,
+                         b"Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+
+    def test_basic_auth_explicit_mode(self):
+        self.assertEqual(self.fetch("/auth", auth_username="Aladdin",
+                                    auth_password="open sesame",
+                                    auth_mode="basic").body,
+                         b"Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+
+    def test_unsupported_auth_mode(self):
+        # curl and simple clients handle errors a bit differently; the
+        # important thing is that they don't fall back to basic auth
+        # on an unknown mode.
+        with ExpectLog(gen_log, "uncaught exception", required=False):
+            with self.assertRaises((ValueError, HTTPError)):
+                response = self.fetch("/auth", auth_username="Aladdin",
+                                      auth_password="open sesame",
+                                      auth_mode="asdf")
+                response.rethrow()
+
+    def test_follow_redirect(self):
+        response = self.fetch("/countdown/2", follow_redirects=False)
+        self.assertEqual(302, response.code)
+        self.assertTrue(response.headers["Location"].endswith("/countdown/1"))
+
+        response = self.fetch("/countdown/2")
+        self.assertEqual(200, response.code)
+        self.assertTrue(response.effective_url.endswith("/countdown/0"))
+        self.assertEqual(b"Zero", response.body)
+
+    def test_credentials_in_url(self):
+        url = self.get_url("/auth").replace("http://", "http://me:secret@")
+        self.http_client.fetch(url, self.stop)
+        response = self.wait()
+        self.assertEqual(b"Basic " + base64.b64encode(b"me:secret"),
+                         response.body)
+
+    def test_body_encoding(self):
+        unicode_body = u("\xe9")
+        byte_body = binascii.a2b_hex(b"e9")
+
+        # unicode string in body gets converted to utf8
+        response = self.fetch("/echopost", method="POST", body=unicode_body,
+                              headers={"Content-Type": "application/blah"})
+        self.assertEqual(response.headers["Content-Length"], "2")
+        self.assertEqual(response.body, utf8(unicode_body))
+
+        # byte strings pass through directly
+        response = self.fetch("/echopost", method="POST",
+                              body=byte_body,
+                              headers={"Content-Type": "application/blah"})
+        self.assertEqual(response.headers["Content-Length"], "1")
+        self.assertEqual(response.body, byte_body)
+
+        # Mixing unicode in headers and byte string bodies shouldn't
+        # break anything
+        response = self.fetch("/echopost", method="POST", body=byte_body,
+                              headers={"Content-Type": "application/blah"},
+                              user_agent=u("foo"))
+        self.assertEqual(response.headers["Content-Length"], "1")
+        self.assertEqual(response.body, byte_body)
+
+    def test_types(self):
+        response = self.fetch("/hello")
+        self.assertEqual(type(response.body), bytes_type)
+        self.assertEqual(type(response.headers["Content-Type"]), str)
+        self.assertEqual(type(response.code), int)
+        self.assertEqual(type(response.effective_url), str)
+
+    def test_header_callback(self):
+        first_line = []
+        headers = {}
+        chunks = []
+
+        def header_callback(header_line):
+            if header_line.startswith('HTTP/'):
+                first_line.append(header_line)
+            elif header_line != '\r\n':
+                k, v = header_line.split(':', 1)
+                headers[k] = v.strip()
+
+        def streaming_callback(chunk):
+            # All header callbacks are run before any streaming callbacks,
+            # so the header data is available to process the data as it
+            # comes in.
+            self.assertEqual(headers['Content-Type'], 'text/html; charset=UTF-8')
+            chunks.append(chunk)
+
+        self.fetch('/chunk', header_callback=header_callback,
+                   streaming_callback=streaming_callback)
+        self.assertEqual(len(first_line), 1)
+        self.assertRegexpMatches(first_line[0], 'HTTP/1.[01] 200 OK\r\n')
+        self.assertEqual(chunks, [b'asdf', b'qwer'])
+
+    def test_header_callback_stack_context(self):
+        exc_info = []
+
+        def error_handler(typ, value, tb):
+            exc_info.append((typ, value, tb))
+            return True
+
+        def header_callback(header_line):
+            if header_line.startswith('Content-Type:'):
+                1 / 0
+
+        with ExceptionStackContext(error_handler):
+            self.fetch('/chunk', header_callback=header_callback)
+        self.assertEqual(len(exc_info), 1)
+        self.assertIs(exc_info[0][0], ZeroDivisionError)
+
+    def test_configure_defaults(self):
+        defaults = dict(user_agent='TestDefaultUserAgent')
+        # Construct a new instance of the configured client class
+        client = self.http_client.__class__(self.io_loop, force_instance=True,
+                                            defaults=defaults)
+        client.fetch(self.get_url('/user_agent'), callback=self.stop)
+        response = self.wait()
+        self.assertEqual(response.body, b'TestDefaultUserAgent')
+        client.close()
+
+    def test_304_with_content_length(self):
+        # According to the spec 304 responses SHOULD NOT include
+        # Content-Length or other entity headers, but some servers do it
+        # anyway.
+        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
+        response = self.fetch('/304_with_content_length')
+        self.assertEqual(response.code, 304)
+        self.assertEqual(response.headers['Content-Length'], '42')
+
+    def test_final_callback_stack_context(self):
+        # The final callback should be run outside of the httpclient's
+        # stack_context.  We want to ensure that there is not stack_context
+        # between the user's callback and the IOLoop, so monkey-patch
+        # IOLoop.handle_callback_exception and disable the test harness's
+        # context with a NullContext.
+        # Note that this does not apply to secondary callbacks (header
+        # and streaming_callback), as errors there must be seen as errors
+        # by the http client so it can clean up the connection.
+        exc_info = []
+
+        def handle_callback_exception(callback):
+            exc_info.append(sys.exc_info())
+            self.stop()
+        self.io_loop.handle_callback_exception = handle_callback_exception
+        with NullContext():
+            self.http_client.fetch(self.get_url('/hello'),
+                                   lambda response: 1 / 0)
+        self.wait()
+        self.assertEqual(exc_info[0][0], ZeroDivisionError)
+
+    @gen_test
+    def test_future_interface(self):
+        response = yield self.http_client.fetch(self.get_url('/hello'))
+        self.assertEqual(response.body, b'Hello world!')
+
+    @gen_test
+    def test_future_http_error(self):
+        try:
+            yield self.http_client.fetch(self.get_url('/notfound'))
+        except HTTPError as e:
+            self.assertEqual(e.code, 404)
+            self.assertEqual(e.response.code, 404)
+
+    @gen_test
+    def test_reuse_request_from_response(self):
+        # The response.request attribute should be an HTTPRequest, not
+        # a _RequestProxy.
+        # This test uses self.http_client.fetch because self.fetch calls
+        # self.get_url on the input unconditionally.
+        url = self.get_url('/hello')
+        response = yield self.http_client.fetch(url)
+        self.assertEqual(response.request.url, url)
+        self.assertTrue(isinstance(response.request, HTTPRequest))
+        response2 = yield self.http_client.fetch(response.request)
+        self.assertEqual(response2.body, b'Hello world!')
+
+    def test_all_methods(self):
+        for method in ['GET', 'DELETE', 'OPTIONS']:
+            response = self.fetch('/all_methods', method=method)
+            self.assertEqual(response.body, utf8(method))
+        for method in ['POST', 'PUT', 'PATCH']:
+            response = self.fetch('/all_methods', method=method, body=b'')
+            self.assertEqual(response.body, utf8(method))
+        response = self.fetch('/all_methods', method='HEAD')
+        self.assertEqual(response.body, b'')
+        response = self.fetch('/all_methods', method='OTHER',
+                              allow_nonstandard_methods=True)
+        self.assertEqual(response.body, b'OTHER')
+
+
+class RequestProxyTest(unittest.TestCase):
+    def test_request_set(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/',
+                                          user_agent='foo'),
+                              dict())
+        self.assertEqual(proxy.user_agent, 'foo')
+
+    def test_default_set(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/'),
+                              dict(network_interface='foo'))
+        self.assertEqual(proxy.network_interface, 'foo')
+
+    def test_both_set(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/',
+                                          proxy_host='foo'),
+                              dict(proxy_host='bar'))
+        self.assertEqual(proxy.proxy_host, 'foo')
+
+    def test_neither_set(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/'),
+                              dict())
+        self.assertIs(proxy.auth_username, None)
+
+    def test_bad_attribute(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/'),
+                              dict())
+        with self.assertRaises(AttributeError):
+            proxy.foo
+
+    def test_defaults_none(self):
+        proxy = _RequestProxy(HTTPRequest('http://example.com/'), None)
+        self.assertIs(proxy.auth_username, None)
+
+
+class HTTPResponseTestCase(unittest.TestCase):
+    def test_str(self):
+        response = HTTPResponse(HTTPRequest('http://example.com'),
+                                200, headers={}, buffer=BytesIO())
+        s = str(response)
+        self.assertTrue(s.startswith('HTTPResponse('))
+        self.assertIn('code=200', s)
+
+
+class SyncHTTPClientTest(unittest.TestCase):
+    def setUp(self):
+        if IOLoop.configured_class().__name__ == 'TwistedIOLoop':
+            # TwistedIOLoop only supports the global reactor, so we can't have
+            # separate IOLoops for client and server threads.
+            raise unittest.SkipTest(
+                'Sync HTTPClient not compatible with TwistedIOLoop')
+        self.server_ioloop = IOLoop()
+
+        sock, self.port = bind_unused_port()
+        app = Application([('/', HelloWorldHandler)])
+        server = HTTPServer(app, io_loop=self.server_ioloop)
+        server.add_socket(sock)
+
+        self.server_thread = threading.Thread(target=self.server_ioloop.start)
+        self.server_thread.start()
+
+        self.http_client = HTTPClient()
+
+    def tearDown(self):
+        self.server_ioloop.add_callback(self.server_ioloop.stop)
+        self.server_thread.join()
+        self.http_client.close()
+        self.server_ioloop.close(all_fds=True)
+
+    def get_url(self, path):
+        return 'http://localhost:%d%s' % (self.port, path)
+
+    def test_sync_client(self):
+        response = self.http_client.fetch(self.get_url('/'))
+        self.assertEqual(b'Hello world!', response.body)
+
+    def test_sync_client_error(self):
+        # Synchronous HTTPClient raises errors directly; no need for
+        # response.rethrow()
+        with self.assertRaises(HTTPError) as assertion:
+            self.http_client.fetch(self.get_url('/notfound'))
+        self.assertEqual(assertion.exception.code, 404)

Shared/lib/python2.7/site-packages/tornado/test/httpserver_test.py

@@ -0,0 +1,661 @@
+#!/usr/bin/env python
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+from tornado import httpclient, simple_httpclient, netutil
+from tornado.escape import json_decode, utf8, _unicode, recursive_unicode, native_str
+from tornado.httpserver import HTTPServer
+from tornado.httputil import HTTPHeaders
+from tornado.iostream import IOStream
+from tornado.log import gen_log
+from tornado.netutil import ssl_options_to_context, Resolver
+from tornado.simple_httpclient import SimpleAsyncHTTPClient
+from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, ExpectLog
+from tornado.test.util import unittest
+from tornado.util import u, bytes_type
+from tornado.web import Application, RequestHandler, asynchronous
+from contextlib import closing
+import datetime
+import os
+import shutil
+import socket
+import ssl
+import sys
+import tempfile
+
+
+class HandlerBaseTestCase(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([('/', self.__class__.Handler)])
+
+    def fetch_json(self, *args, **kwargs):
+        response = self.fetch(*args, **kwargs)
+        response.rethrow()
+        return json_decode(response.body)
+
+
+class HelloWorldRequestHandler(RequestHandler):
+    def initialize(self, protocol="http"):
+        self.expected_protocol = protocol
+
+    def get(self):
+        if self.request.protocol != self.expected_protocol:
+            raise Exception("unexpected protocol")
+        self.finish("Hello world")
+
+    def post(self):
+        self.finish("Got %d bytes in POST" % len(self.request.body))
+
+
+# In pre-1.0 versions of openssl, SSLv23 clients always send SSLv2
+# ClientHello messages, which are rejected by SSLv3 and TLSv1
+# servers.  Note that while the OPENSSL_VERSION_INFO was formally
+# introduced in python3.2, it was present but undocumented in
+# python 2.7
+skipIfOldSSL = unittest.skipIf(
+    getattr(ssl, 'OPENSSL_VERSION_INFO', (0, 0)) < (1, 0),
+    "old version of ssl module and/or openssl")
+
+
+class BaseSSLTest(AsyncHTTPSTestCase):
+    def get_app(self):
+        return Application([('/', HelloWorldRequestHandler,
+                             dict(protocol="https"))])
+
+
+class SSLTestMixin(object):
+    def get_ssl_options(self):
+        return dict(ssl_version=self.get_ssl_version(),
+                    **AsyncHTTPSTestCase.get_ssl_options())
+
+    def get_ssl_version(self):
+        raise NotImplementedError()
+
+    def test_ssl(self):
+        response = self.fetch('/')
+        self.assertEqual(response.body, b"Hello world")
+
+    def test_large_post(self):
+        response = self.fetch('/',
+                              method='POST',
+                              body='A' * 5000)
+        self.assertEqual(response.body, b"Got 5000 bytes in POST")
+
+    def test_non_ssl_request(self):
+        # Make sure the server closes the connection when it gets a non-ssl
+        # connection, rather than waiting for a timeout or otherwise
+        # misbehaving.
+        with ExpectLog(gen_log, '(SSL Error|uncaught exception)'):
+            self.http_client.fetch(self.get_url("/").replace('https:', 'http:'),
+                                   self.stop,
+                                   request_timeout=3600,
+                                   connect_timeout=3600)
+            response = self.wait()
+        self.assertEqual(response.code, 599)
+
+# Python's SSL implementation differs significantly between versions.
+# For example, SSLv3 and TLSv1 throw an exception if you try to read
+# from the socket before the handshake is complete, but the default
+# of SSLv23 allows it.
+
+
+class SSLv23Test(BaseSSLTest, SSLTestMixin):
+    def get_ssl_version(self):
+        return ssl.PROTOCOL_SSLv23
+
+
+@skipIfOldSSL
+class SSLv3Test(BaseSSLTest, SSLTestMixin):
+    def get_ssl_version(self):
+        return ssl.PROTOCOL_SSLv3
+
+
+@skipIfOldSSL
+class TLSv1Test(BaseSSLTest, SSLTestMixin):
+    def get_ssl_version(self):
+        return ssl.PROTOCOL_TLSv1
+
+
+@unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present')
+class SSLContextTest(BaseSSLTest, SSLTestMixin):
+    def get_ssl_options(self):
+        context = ssl_options_to_context(
+            AsyncHTTPSTestCase.get_ssl_options(self))
+        assert isinstance(context, ssl.SSLContext)
+        return context
+
+
+class BadSSLOptionsTest(unittest.TestCase):
+    def test_missing_arguments(self):
+        application = Application()
+        self.assertRaises(KeyError, HTTPServer, application, ssl_options={
+            "keyfile": "/__missing__.crt",
+        })
+
+    def test_missing_key(self):
+        """A missing SSL key should cause an immediate exception."""
+
+        application = Application()
+        module_dir = os.path.dirname(__file__)
+        existing_certificate = os.path.join(module_dir, 'test.crt')
+
+        self.assertRaises(ValueError, HTTPServer, application, ssl_options={
+                          "certfile": "/__mising__.crt",
+                          })
+        self.assertRaises(ValueError, HTTPServer, application, ssl_options={
+                          "certfile": existing_certificate,
+                          "keyfile": "/__missing__.key"
+                          })
+
+        # This actually works because both files exist
+        HTTPServer(application, ssl_options={
+                   "certfile": existing_certificate,
+                   "keyfile": existing_certificate
+                   })
+
+
+class MultipartTestHandler(RequestHandler):
+    def post(self):
+        self.finish({"header": self.request.headers["X-Header-Encoding-Test"],
+                     "argument": self.get_argument("argument"),
+                     "filename": self.request.files["files"][0].filename,
+                     "filebody": _unicode(self.request.files["files"][0]["body"]),
+                     })
+
+
+class RawRequestHTTPConnection(simple_httpclient._HTTPConnection):
+    def set_request(self, request):
+        self.__next_request = request
+
+    def _on_connect(self):
+        self.stream.write(self.__next_request)
+        self.__next_request = None
+        self.stream.read_until(b"\r\n\r\n", self._on_headers)
+
+# This test is also called from wsgi_test
+
+
+class HTTPConnectionTest(AsyncHTTPTestCase):
+    def get_handlers(self):
+        return [("/multipart", MultipartTestHandler),
+                ("/hello", HelloWorldRequestHandler)]
+
+    def get_app(self):
+        return Application(self.get_handlers())
+
+    def raw_fetch(self, headers, body):
+        with closing(Resolver(io_loop=self.io_loop)) as resolver:
+            with closing(SimpleAsyncHTTPClient(self.io_loop,
+                                               resolver=resolver)) as client:
+                conn = RawRequestHTTPConnection(
+                    self.io_loop, client,
+                    httpclient._RequestProxy(
+                        httpclient.HTTPRequest(self.get_url("/")),
+                        dict(httpclient.HTTPRequest._DEFAULTS)),
+                    None, self.stop,
+                    1024 * 1024, resolver)
+                conn.set_request(
+                    b"\r\n".join(headers +
+                                 [utf8("Content-Length: %d\r\n" % len(body))]) +
+                    b"\r\n" + body)
+                response = self.wait()
+                response.rethrow()
+                return response
+
+    def test_multipart_form(self):
+        # Encodings here are tricky:  Headers are latin1, bodies can be
+        # anything (we use utf8 by default).
+        response = self.raw_fetch([
+            b"POST /multipart HTTP/1.0",
+            b"Content-Type: multipart/form-data; boundary=1234567890",
+            b"X-Header-encoding-test: \xe9",
+        ],
+            b"\r\n".join([
+            b"Content-Disposition: form-data; name=argument",
+            b"",
+            u("\u00e1").encode("utf-8"),
+            b"--1234567890",
+            u('Content-Disposition: form-data; name="files"; filename="\u00f3"').encode("utf8"),
+            b"",
+            u("\u00fa").encode("utf-8"),
+            b"--1234567890--",
+            b"",
+            ]))
+        data = json_decode(response.body)
+        self.assertEqual(u("\u00e9"), data["header"])
+        self.assertEqual(u("\u00e1"), data["argument"])
+        self.assertEqual(u("\u00f3"), data["filename"])
+        self.assertEqual(u("\u00fa"), data["filebody"])
+
+    def test_100_continue(self):
+        # Run through a 100-continue interaction by hand:
+        # When given Expect: 100-continue, we get a 100 response after the
+        # headers, and then the real response after the body.
+        stream = IOStream(socket.socket(), io_loop=self.io_loop)
+        stream.connect(("localhost", self.get_http_port()), callback=self.stop)
+        self.wait()
+        stream.write(b"\r\n".join([b"POST /hello HTTP/1.1",
+                                   b"Content-Length: 1024",
+                                   b"Expect: 100-continue",
+                                   b"Connection: close",
+                                   b"\r\n"]), callback=self.stop)
+        self.wait()
+        stream.read_until(b"\r\n\r\n", self.stop)
+        data = self.wait()
+        self.assertTrue(data.startswith(b"HTTP/1.1 100 "), data)
+        stream.write(b"a" * 1024)
+        stream.read_until(b"\r\n", self.stop)
+        first_line = self.wait()
+        self.assertTrue(first_line.startswith(b"HTTP/1.1 200"), first_line)
+        stream.read_until(b"\r\n\r\n", self.stop)
+        header_data = self.wait()
+        headers = HTTPHeaders.parse(native_str(header_data.decode('latin1')))
+        stream.read_bytes(int(headers["Content-Length"]), self.stop)
+        body = self.wait()
+        self.assertEqual(body, b"Got 1024 bytes in POST")
+        stream.close()
+
+
+class EchoHandler(RequestHandler):
+    def get(self):
+        self.write(recursive_unicode(self.request.arguments))
+
+    def post(self):
+        self.write(recursive_unicode(self.request.arguments))
+
+
+class TypeCheckHandler(RequestHandler):
+    def prepare(self):
+        self.errors = {}
+        fields = [
+            ('method', str),
+            ('uri', str),
+            ('version', str),
+            ('remote_ip', str),
+            ('protocol', str),
+            ('host', str),
+            ('path', str),
+            ('query', str),
+        ]
+        for field, expected_type in fields:
+            self.check_type(field, getattr(self.request, field), expected_type)
+
+        self.check_type('header_key', list(self.request.headers.keys())[0], str)
+        self.check_type('header_value', list(self.request.headers.values())[0], str)
+
+        self.check_type('cookie_key', list(self.request.cookies.keys())[0], str)
+        self.check_type('cookie_value', list(self.request.cookies.values())[0].value, str)
+        # secure cookies
+
+        self.check_type('arg_key', list(self.request.arguments.keys())[0], str)
+        self.check_type('arg_value', list(self.request.arguments.values())[0][0], bytes_type)
+
+    def post(self):
+        self.check_type('body', self.request.body, bytes_type)
+        self.write(self.errors)
+
+    def get(self):
+        self.write(self.errors)
+
+    def check_type(self, name, obj, expected_type):
+        actual_type = type(obj)
+        if expected_type != actual_type:
+            self.errors[name] = "expected %s, got %s" % (expected_type,
+                                                         actual_type)
+
+
+class HTTPServerTest(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([("/echo", EchoHandler),
+                            ("/typecheck", TypeCheckHandler),
+                            ("//doubleslash", EchoHandler),
+                            ])
+
+    def test_query_string_encoding(self):
+        response = self.fetch("/echo?foo=%C3%A9")
+        data = json_decode(response.body)
+        self.assertEqual(data, {u("foo"): [u("\u00e9")]})
+
+    def test_empty_query_string(self):
+        response = self.fetch("/echo?foo=&foo=")
+        data = json_decode(response.body)
+        self.assertEqual(data, {u("foo"): [u(""), u("")]})
+
+    def test_empty_post_parameters(self):
+        response = self.fetch("/echo", method="POST", body="foo=&bar=")
+        data = json_decode(response.body)
+        self.assertEqual(data, {u("foo"): [u("")], u("bar"): [u("")]})
+
+    def test_types(self):
+        headers = {"Cookie": "foo=bar"}
+        response = self.fetch("/typecheck?foo=bar", headers=headers)
+        data = json_decode(response.body)
+        self.assertEqual(data, {})
+
+        response = self.fetch("/typecheck", method="POST", body="foo=bar", headers=headers)
+        data = json_decode(response.body)
+        self.assertEqual(data, {})
+
+    def test_double_slash(self):
+        # urlparse.urlsplit (which tornado.httpserver used to use
+        # incorrectly) would parse paths beginning with "//" as
+        # protocol-relative urls.
+        response = self.fetch("//doubleslash")
+        self.assertEqual(200, response.code)
+        self.assertEqual(json_decode(response.body), {})
+
+
+class HTTPServerRawTest(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([
+            ('/echo', EchoHandler),
+        ])
+
+    def setUp(self):
+        super(HTTPServerRawTest, self).setUp()
+        self.stream = IOStream(socket.socket())
+        self.stream.connect(('localhost', self.get_http_port()), self.stop)
+        self.wait()
+
+    def tearDown(self):
+        self.stream.close()
+        super(HTTPServerRawTest, self).tearDown()
+
+    def test_empty_request(self):
+        self.stream.close()
+        self.io_loop.add_timeout(datetime.timedelta(seconds=0.001), self.stop)
+        self.wait()
+
+    def test_malformed_first_line(self):
+        with ExpectLog(gen_log, '.*Malformed HTTP request line'):
+            self.stream.write(b'asdf\r\n\r\n')
+            # TODO: need an async version of ExpectLog so we don't need
+            # hard-coded timeouts here.
+            self.io_loop.add_timeout(datetime.timedelta(seconds=0.01),
+                                     self.stop)
+            self.wait()
+
+    def test_malformed_headers(self):
+        with ExpectLog(gen_log, '.*Malformed HTTP headers'):
+            self.stream.write(b'GET / HTTP/1.0\r\nasdf\r\n\r\n')
+            self.io_loop.add_timeout(datetime.timedelta(seconds=0.01),
+                                     self.stop)
+            self.wait()
+
+
+class XHeaderTest(HandlerBaseTestCase):
+    class Handler(RequestHandler):
+        def get(self):
+            self.write(dict(remote_ip=self.request.remote_ip,
+                            remote_protocol=self.request.protocol))
+
+    def get_httpserver_options(self):
+        return dict(xheaders=True)
+
+    def test_ip_headers(self):
+        self.assertEqual(self.fetch_json("/")["remote_ip"], "127.0.0.1")
+
+        valid_ipv4 = {"X-Real-IP": "4.4.4.4"}
+        self.assertEqual(
+            self.fetch_json("/", headers=valid_ipv4)["remote_ip"],
+            "4.4.4.4")
+
+        valid_ipv4_list = {"X-Forwarded-For": "127.0.0.1, 4.4.4.4"}
+        self.assertEqual(
+            self.fetch_json("/", headers=valid_ipv4_list)["remote_ip"],
+            "4.4.4.4")
+
+        valid_ipv6 = {"X-Real-IP": "2620:0:1cfe:face:b00c::3"}
+        self.assertEqual(
+            self.fetch_json("/", headers=valid_ipv6)["remote_ip"],
+            "2620:0:1cfe:face:b00c::3")
+
+        valid_ipv6_list = {"X-Forwarded-For": "::1, 2620:0:1cfe:face:b00c::3"}
+        self.assertEqual(
+            self.fetch_json("/", headers=valid_ipv6_list)["remote_ip"],
+            "2620:0:1cfe:face:b00c::3")
+
+        invalid_chars = {"X-Real-IP": "4.4.4.4<script>"}
+        self.assertEqual(
+            self.fetch_json("/", headers=invalid_chars)["remote_ip"],
+            "127.0.0.1")
+
+        invalid_chars_list = {"X-Forwarded-For": "4.4.4.4, 5.5.5.5<script>"}
+        self.assertEqual(
+            self.fetch_json("/", headers=invalid_chars_list)["remote_ip"],
+            "127.0.0.1")
+
+        invalid_host = {"X-Real-IP": "www.google.com"}
+        self.assertEqual(
+            self.fetch_json("/", headers=invalid_host)["remote_ip"],
+            "127.0.0.1")
+
+    def test_scheme_headers(self):
+        self.assertEqual(self.fetch_json("/")["remote_protocol"], "http")
+
+        https_scheme = {"X-Scheme": "https"}
+        self.assertEqual(
+            self.fetch_json("/", headers=https_scheme)["remote_protocol"],
+            "https")
+
+        https_forwarded = {"X-Forwarded-Proto": "https"}
+        self.assertEqual(
+            self.fetch_json("/", headers=https_forwarded)["remote_protocol"],
+            "https")
+
+        bad_forwarded = {"X-Forwarded-Proto": "unknown"}
+        self.assertEqual(
+            self.fetch_json("/", headers=bad_forwarded)["remote_protocol"],
+            "http")
+
+
+class SSLXHeaderTest(AsyncHTTPSTestCase, HandlerBaseTestCase):
+    def get_app(self):
+        return Application([('/', XHeaderTest.Handler)])
+
+    def get_httpserver_options(self):
+        output = super(SSLXHeaderTest, self).get_httpserver_options()
+        output['xheaders'] = True
+        return output
+
+    def test_request_without_xprotocol(self):
+        self.assertEqual(self.fetch_json("/")["remote_protocol"], "https")
+
+        http_scheme = {"X-Scheme": "http"}
+        self.assertEqual(
+            self.fetch_json("/", headers=http_scheme)["remote_protocol"], "http")
+
+        bad_scheme = {"X-Scheme": "unknown"}
+        self.assertEqual(
+            self.fetch_json("/", headers=bad_scheme)["remote_protocol"], "https")
+
+
+class ManualProtocolTest(HandlerBaseTestCase):
+    class Handler(RequestHandler):
+        def get(self):
+            self.write(dict(protocol=self.request.protocol))
+
+    def get_httpserver_options(self):
+        return dict(protocol='https')
+
+    def test_manual_protocol(self):
+        self.assertEqual(self.fetch_json('/')['protocol'], 'https')
+
+
+@unittest.skipIf(not hasattr(socket, 'AF_UNIX') or sys.platform == 'cygwin',
+                 "unix sockets not supported on this platform")
+class UnixSocketTest(AsyncTestCase):
+    """HTTPServers can listen on Unix sockets too.
+
+    Why would you want to do this?  Nginx can proxy to backends listening
+    on unix sockets, for one thing (and managing a namespace for unix
+    sockets can be easier than managing a bunch of TCP port numbers).
+
+    Unfortunately, there's no way to specify a unix socket in a url for
+    an HTTP client, so we have to test this by hand.
+    """
+    def setUp(self):
+        super(UnixSocketTest, self).setUp()
+        self.tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+        super(UnixSocketTest, self).tearDown()
+
+    def test_unix_socket(self):
+        sockfile = os.path.join(self.tmpdir, "test.sock")
+        sock = netutil.bind_unix_socket(sockfile)
+        app = Application([("/hello", HelloWorldRequestHandler)])
+        server = HTTPServer(app, io_loop=self.io_loop)
+        server.add_socket(sock)
+        stream = IOStream(socket.socket(socket.AF_UNIX), io_loop=self.io_loop)
+        stream.connect(sockfile, self.stop)
+        self.wait()
+        stream.write(b"GET /hello HTTP/1.0\r\n\r\n")
+        stream.read_until(b"\r\n", self.stop)
+        response = self.wait()
+        self.assertEqual(response, b"HTTP/1.0 200 OK\r\n")
+        stream.read_until(b"\r\n\r\n", self.stop)
+        headers = HTTPHeaders.parse(self.wait().decode('latin1'))
+        stream.read_bytes(int(headers["Content-Length"]), self.stop)
+        body = self.wait()
+        self.assertEqual(body, b"Hello world")
+        stream.close()
+        server.stop()
+
+
+class KeepAliveTest(AsyncHTTPTestCase):
+    """Tests various scenarios for HTTP 1.1 keep-alive support.
+
+    These tests don't use AsyncHTTPClient because we want to control
+    connection reuse and closing.
+    """
+    def get_app(self):
+        class HelloHandler(RequestHandler):
+            def get(self):
+                self.finish('Hello world')
+
+        class LargeHandler(RequestHandler):
+            def get(self):
+                # 512KB should be bigger than the socket buffers so it will
+                # be written out in chunks.
+                self.write(''.join(chr(i % 256) * 1024 for i in range(512)))
+
+        class FinishOnCloseHandler(RequestHandler):
+            @asynchronous
+            def get(self):
+                self.flush()
+
+            def on_connection_close(self):
+                # This is not very realistic, but finishing the request
+                # from the close callback has the right timing to mimic
+                # some errors seen in the wild.
+                self.finish('closed')
+
+        return Application([('/', HelloHandler),
+                            ('/large', LargeHandler),
+                            ('/finish_on_close', FinishOnCloseHandler)])
+
+    def setUp(self):
+        super(KeepAliveTest, self).setUp()
+        self.http_version = b'HTTP/1.1'
+
+    def tearDown(self):
+        # We just closed the client side of the socket; let the IOLoop run
+        # once to make sure the server side got the message.
+        self.io_loop.add_timeout(datetime.timedelta(seconds=0.001), self.stop)
+        self.wait()
+
+        if hasattr(self, 'stream'):
+            self.stream.close()
+        super(KeepAliveTest, self).tearDown()
+
+    # The next few methods are a crude manual http client
+    def connect(self):
+        self.stream = IOStream(socket.socket(), io_loop=self.io_loop)
+        self.stream.connect(('localhost', self.get_http_port()), self.stop)
+        self.wait()
+
+    def read_headers(self):
+        self.stream.read_until(b'\r\n', self.stop)
+        first_line = self.wait()
+        self.assertTrue(first_line.startswith(self.http_version + b' 200'), first_line)
+        self.stream.read_until(b'\r\n\r\n', self.stop)
+        header_bytes = self.wait()
+        headers = HTTPHeaders.parse(header_bytes.decode('latin1'))
+        return headers
+
+    def read_response(self):
+        headers = self.read_headers()
+        self.stream.read_bytes(int(headers['Content-Length']), self.stop)
+        body = self.wait()
+        self.assertEqual(b'Hello world', body)
+
+    def close(self):
+        self.stream.close()
+        del self.stream
+
+    def test_two_requests(self):
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.1\r\n\r\n')
+        self.read_response()
+        self.stream.write(b'GET / HTTP/1.1\r\n\r\n')
+        self.read_response()
+        self.close()
+
+    def test_request_close(self):
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.1\r\nConnection: close\r\n\r\n')
+        self.read_response()
+        self.stream.read_until_close(callback=self.stop)
+        data = self.wait()
+        self.assertTrue(not data)
+        self.close()
+
+    # keepalive is supported for http 1.0 too, but it's opt-in
+    def test_http10(self):
+        self.http_version = b'HTTP/1.0'
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.0\r\n\r\n')
+        self.read_response()
+        self.stream.read_until_close(callback=self.stop)
+        data = self.wait()
+        self.assertTrue(not data)
+        self.close()
+
+    def test_http10_keepalive(self):
+        self.http_version = b'HTTP/1.0'
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n')
+        self.read_response()
+        self.stream.write(b'GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n')
+        self.read_response()
+        self.close()
+
+    def test_pipelined_requests(self):
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\n\r\n')
+        self.read_response()
+        self.read_response()
+        self.close()
+
+    def test_pipelined_cancel(self):
+        self.connect()
+        self.stream.write(b'GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\n\r\n')
+        # only read once
+        self.read_response()
+        self.close()
+
+    def test_cancel_during_download(self):
+        self.connect()
+        self.stream.write(b'GET /large HTTP/1.1\r\n\r\n')
+        self.read_headers()
+        self.stream.read_bytes(1024, self.stop)
+        self.wait()
+        self.close()
+
+    def test_finish_while_closed(self):
+        self.connect()
+        self.stream.write(b'GET /finish_on_close HTTP/1.1\r\n\r\n')
+        self.read_headers()
+        self.close()

Shared/lib/python2.7/site-packages/tornado/test/httputil_test.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+from tornado.httputil import url_concat, parse_multipart_form_data, HTTPHeaders, format_timestamp
+from tornado.escape import utf8
+from tornado.log import gen_log
+from tornado.testing import ExpectLog
+from tornado.test.util import unittest
+
+import datetime
+import logging
+import time
+
+
+class TestUrlConcat(unittest.TestCase):
+
+    def test_url_concat_no_query_params(self):
+        url = url_concat(
+            "https://localhost/path",
+            [('y', 'y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?y=y&z=z")
+
+    def test_url_concat_encode_args(self):
+        url = url_concat(
+            "https://localhost/path",
+            [('y', '/y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?y=%2Fy&z=z")
+
+    def test_url_concat_trailing_q(self):
+        url = url_concat(
+            "https://localhost/path?",
+            [('y', 'y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?y=y&z=z")
+
+    def test_url_concat_q_with_no_trailing_amp(self):
+        url = url_concat(
+            "https://localhost/path?x",
+            [('y', 'y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?x&y=y&z=z")
+
+    def test_url_concat_trailing_amp(self):
+        url = url_concat(
+            "https://localhost/path?x&",
+            [('y', 'y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?x&y=y&z=z")
+
+    def test_url_concat_mult_params(self):
+        url = url_concat(
+            "https://localhost/path?a=1&b=2",
+            [('y', 'y'), ('z', 'z')],
+        )
+        self.assertEqual(url, "https://localhost/path?a=1&b=2&y=y&z=z")
+
+    def test_url_concat_no_params(self):
+        url = url_concat(
+            "https://localhost/path?r=1&t=2",
+            [],
+        )
+        self.assertEqual(url, "https://localhost/path?r=1&t=2")
+
+
+class MultipartFormDataTest(unittest.TestCase):
+    def test_file_upload(self):
+        data = b"""\
+--1234
+Content-Disposition: form-data; name="files"; filename="ab.txt"
+
+Foo
+--1234--""".replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        parse_multipart_form_data(b"1234", data, args, files)
+        file = files["files"][0]
+        self.assertEqual(file["filename"], "ab.txt")
+        self.assertEqual(file["body"], b"Foo")
+
+    def test_unquoted_names(self):
+        # quotes are optional unless special characters are present
+        data = b"""\
+--1234
+Content-Disposition: form-data; name=files; filename=ab.txt
+
+Foo
+--1234--""".replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        parse_multipart_form_data(b"1234", data, args, files)
+        file = files["files"][0]
+        self.assertEqual(file["filename"], "ab.txt")
+        self.assertEqual(file["body"], b"Foo")
+
+    def test_special_filenames(self):
+        filenames = ['a;b.txt',
+                     'a"b.txt',
+                     'a";b.txt',
+                     'a;"b.txt',
+                     'a";";.txt',
+                     'a\\"b.txt',
+                     'a\\b.txt',
+                     ]
+        for filename in filenames:
+            logging.debug("trying filename %r", filename)
+            data = """\
+--1234
+Content-Disposition: form-data; name="files"; filename="%s"
+
+Foo
+--1234--""" % filename.replace('\\', '\\\\').replace('"', '\\"')
+            data = utf8(data.replace("\n", "\r\n"))
+            args = {}
+            files = {}
+            parse_multipart_form_data(b"1234", data, args, files)
+            file = files["files"][0]
+            self.assertEqual(file["filename"], filename)
+            self.assertEqual(file["body"], b"Foo")
+
+    def test_boundary_starts_and_ends_with_quotes(self):
+        data = b'''\
+--1234
+Content-Disposition: form-data; name="files"; filename="ab.txt"
+
+Foo
+--1234--'''.replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        parse_multipart_form_data(b'"1234"', data, args, files)
+        file = files["files"][0]
+        self.assertEqual(file["filename"], "ab.txt")
+        self.assertEqual(file["body"], b"Foo")
+
+    def test_missing_headers(self):
+        data = b'''\
+--1234
+
+Foo
+--1234--'''.replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        with ExpectLog(gen_log, "multipart/form-data missing headers"):
+            parse_multipart_form_data(b"1234", data, args, files)
+        self.assertEqual(files, {})
+
+    def test_invalid_content_disposition(self):
+        data = b'''\
+--1234
+Content-Disposition: invalid; name="files"; filename="ab.txt"
+
+Foo
+--1234--'''.replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        with ExpectLog(gen_log, "Invalid multipart/form-data"):
+            parse_multipart_form_data(b"1234", data, args, files)
+        self.assertEqual(files, {})
+
+    def test_line_does_not_end_with_correct_line_break(self):
+        data = b'''\
+--1234
+Content-Disposition: form-data; name="files"; filename="ab.txt"
+
+Foo--1234--'''.replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        with ExpectLog(gen_log, "Invalid multipart/form-data"):
+            parse_multipart_form_data(b"1234", data, args, files)
+        self.assertEqual(files, {})
+
+    def test_content_disposition_header_without_name_parameter(self):
+        data = b"""\
+--1234
+Content-Disposition: form-data; filename="ab.txt"
+
+Foo
+--1234--""".replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        with ExpectLog(gen_log, "multipart/form-data value missing name"):
+            parse_multipart_form_data(b"1234", data, args, files)
+        self.assertEqual(files, {})
+
+    def test_data_after_final_boundary(self):
+        # The spec requires that data after the final boundary be ignored.
+        # http://www.w3.org/Protocols/rfc1341/7_2_Multipart.html
+        # In practice, some libraries include an extra CRLF after the boundary.
+        data = b"""\
+--1234
+Content-Disposition: form-data; name="files"; filename="ab.txt"
+
+Foo
+--1234--
+""".replace(b"\n", b"\r\n")
+        args = {}
+        files = {}
+        parse_multipart_form_data(b"1234", data, args, files)
+        file = files["files"][0]
+        self.assertEqual(file["filename"], "ab.txt")
+        self.assertEqual(file["body"], b"Foo")
+
+
+class HTTPHeadersTest(unittest.TestCase):
+    def test_multi_line(self):
+        # Lines beginning with whitespace are appended to the previous line
+        # with any leading whitespace replaced by a single space.
+        # Note that while multi-line headers are a part of the HTTP spec,
+        # their use is strongly discouraged.
+        data = """\
+Foo: bar
+ baz
+Asdf: qwer
+\tzxcv
+Foo: even
+     more
+     lines
+""".replace("\n", "\r\n")
+        headers = HTTPHeaders.parse(data)
+        self.assertEqual(headers["asdf"], "qwer zxcv")
+        self.assertEqual(headers.get_list("asdf"), ["qwer zxcv"])
+        self.assertEqual(headers["Foo"], "bar baz,even more lines")
+        self.assertEqual(headers.get_list("foo"), ["bar baz", "even more lines"])
+        self.assertEqual(sorted(list(headers.get_all())),
+                         [("Asdf", "qwer zxcv"),
+                          ("Foo", "bar baz"),
+                          ("Foo", "even more lines")])
+
+
+class FormatTimestampTest(unittest.TestCase):
+    # Make sure that all the input types are supported.
+    TIMESTAMP = 1359312200.503611
+    EXPECTED = 'Sun, 27 Jan 2013 18:43:20 GMT'
+
+    def check(self, value):
+        self.assertEqual(format_timestamp(value), self.EXPECTED)
+
+    def test_unix_time_float(self):
+        self.check(self.TIMESTAMP)
+
+    def test_unix_time_int(self):
+        self.check(int(self.TIMESTAMP))
+
+    def test_struct_time(self):
+        self.check(time.gmtime(self.TIMESTAMP))
+
+    def test_time_tuple(self):
+        tup = tuple(time.gmtime(self.TIMESTAMP))
+        self.assertEqual(9, len(tup))
+        self.check(tup)
+
+    def test_datetime(self):
+        self.check(datetime.datetime.utcfromtimestamp(self.TIMESTAMP))

Shared/lib/python2.7/site-packages/tornado/test/import_test.py

@@ -0,0 +1,45 @@
+from __future__ import absolute_import, division, print_function, with_statement
+from tornado.test.util import unittest
+
+
+class ImportTest(unittest.TestCase):
+    def test_import_everything(self):
+        # Some of our modules are not otherwise tested.  Import them
+        # all (unless they have external dependencies) here to at
+        # least ensure that there are no syntax errors.
+        import tornado.auth
+        import tornado.autoreload
+        import tornado.concurrent
+        # import tornado.curl_httpclient  # depends on pycurl
+        import tornado.escape
+        import tornado.gen
+        import tornado.httpclient
+        import tornado.httpserver
+        import tornado.httputil
+        import tornado.ioloop
+        import tornado.iostream
+        import tornado.locale
+        import tornado.log
+        import tornado.netutil
+        import tornado.options
+        import tornado.process
+        import tornado.simple_httpclient
+        import tornado.stack_context
+        import tornado.tcpserver
+        import tornado.template
+        import tornado.testing
+        import tornado.util
+        import tornado.web
+        import tornado.websocket
+        import tornado.wsgi
+
+    # for modules with dependencies, if those dependencies can be loaded,
+    # load them too.
+
+    def test_import_pycurl(self):
+        try:
+            import pycurl
+        except ImportError:
+            pass
+        else:
+            import tornado.curl_httpclient

Shared/lib/python2.7/site-packages/tornado/test/ioloop_test.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+import contextlib
+import datetime
+import functools
+import socket
+import sys
+import threading
+import time
+
+from tornado import gen
+from tornado.ioloop import IOLoop, TimeoutError
+from tornado.stack_context import ExceptionStackContext, StackContext, wrap, NullContext
+from tornado.testing import AsyncTestCase, bind_unused_port
+from tornado.test.util import unittest, skipIfNonUnix, skipOnTravis
+
+try:
+    from concurrent import futures
+except ImportError:
+    futures = None
+
+
+class TestIOLoop(AsyncTestCase):
+    @skipOnTravis
+    def test_add_callback_wakeup(self):
+        # Make sure that add_callback from inside a running IOLoop
+        # wakes up the IOLoop immediately instead of waiting for a timeout.
+        def callback():
+            self.called = True
+            self.stop()
+
+        def schedule_callback():
+            self.called = False
+            self.io_loop.add_callback(callback)
+            # Store away the time so we can check if we woke up immediately
+            self.start_time = time.time()
+        self.io_loop.add_timeout(self.io_loop.time(), schedule_callback)
+        self.wait()
+        self.assertAlmostEqual(time.time(), self.start_time, places=2)
+        self.assertTrue(self.called)
+
+    @skipOnTravis
+    def test_add_callback_wakeup_other_thread(self):
+        def target():
+            # sleep a bit to let the ioloop go into its poll loop
+            time.sleep(0.01)
+            self.stop_time = time.time()
+            self.io_loop.add_callback(self.stop)
+        thread = threading.Thread(target=target)
+        self.io_loop.add_callback(thread.start)
+        self.wait()
+        self.assertAlmostEqual(time.time(), self.stop_time, places=2)
+        thread.join()
+
+    def test_add_timeout_timedelta(self):
+        self.io_loop.add_timeout(datetime.timedelta(microseconds=1), self.stop)
+        self.wait()
+
+    def test_multiple_add(self):
+        sock, port = bind_unused_port()
+        try:
+            self.io_loop.add_handler(sock.fileno(), lambda fd, events: None,
+                                     IOLoop.READ)
+            # Attempting to add the same handler twice fails
+            # (with a platform-dependent exception)
+            self.assertRaises(Exception, self.io_loop.add_handler,
+                              sock.fileno(), lambda fd, events: None,
+                              IOLoop.READ)
+        finally:
+            self.io_loop.remove_handler(sock.fileno())
+            sock.close()
+
+    def test_remove_without_add(self):
+        # remove_handler should not throw an exception if called on an fd
+        # was never added.
+        sock, port = bind_unused_port()
+        try:
+            self.io_loop.remove_handler(sock.fileno())
+        finally:
+            sock.close()
+
+    def test_add_callback_from_signal(self):
+        # cheat a little bit and just run this normally, since we can't
+        # easily simulate the races that happen with real signal handlers
+        self.io_loop.add_callback_from_signal(self.stop)
+        self.wait()
+
+    def test_add_callback_from_signal_other_thread(self):
+        # Very crude test, just to make sure that we cover this case.
+        # This also happens to be the first test where we run an IOLoop in
+        # a non-main thread.
+        other_ioloop = IOLoop()
+        thread = threading.Thread(target=other_ioloop.start)
+        thread.start()
+        other_ioloop.add_callback_from_signal(other_ioloop.stop)
+        thread.join()
+        other_ioloop.close()
+
+    def test_add_callback_while_closing(self):
+        # Issue #635: add_callback() should raise a clean exception
+        # if called while another thread is closing the IOLoop.
+        closing = threading.Event()
+
+        def target():
+            other_ioloop.add_callback(other_ioloop.stop)
+            other_ioloop.start()
+            closing.set()
+            other_ioloop.close(all_fds=True)
+        other_ioloop = IOLoop()
+        thread = threading.Thread(target=target)
+        thread.start()
+        closing.wait()
+        for i in range(1000):
+            try:
+                other_ioloop.add_callback(lambda: None)
+            except RuntimeError as e:
+                self.assertEqual("IOLoop is closing", str(e))
+                break
+
+    def test_handle_callback_exception(self):
+        # IOLoop.handle_callback_exception can be overridden to catch
+        # exceptions in callbacks.
+        def handle_callback_exception(callback):
+            self.assertIs(sys.exc_info()[0], ZeroDivisionError)
+            self.stop()
+        self.io_loop.handle_callback_exception = handle_callback_exception
+        with NullContext():
+            # remove the test StackContext that would see this uncaught
+            # exception as a test failure.
+            self.io_loop.add_callback(lambda: 1 / 0)
+        self.wait()
+
+    @skipIfNonUnix  # just because socketpair is so convenient
+    def test_read_while_writeable(self):
+        # Ensure that write events don't come in while we're waiting for
+        # a read and haven't asked for writeability. (the reverse is
+        # difficult to test for)
+        client, server = socket.socketpair()
+        try:
+            def handler(fd, events):
+                self.assertEqual(events, IOLoop.READ)
+                self.stop()
+            self.io_loop.add_handler(client.fileno(), handler, IOLoop.READ)
+            self.io_loop.add_timeout(self.io_loop.time() + 0.01,
+                                     functools.partial(server.send, b'asdf'))
+            self.wait()
+            self.io_loop.remove_handler(client.fileno())
+        finally:
+            client.close()
+            server.close()
+
+    def test_remove_timeout_after_fire(self):
+        # It is not an error to call remove_timeout after it has run.
+        handle = self.io_loop.add_timeout(self.io_loop.time(), self.stop())
+        self.wait()
+        self.io_loop.remove_timeout(handle)
+
+    def test_remove_timeout_cleanup(self):
+        # Add and remove enough callbacks to trigger cleanup.
+        # Not a very thorough test, but it ensures that the cleanup code
+        # gets executed and doesn't blow up.  This test is only really useful
+        # on PollIOLoop subclasses, but it should run silently on any
+        # implementation.
+        for i in range(2000):
+            timeout = self.io_loop.add_timeout(self.io_loop.time() + 3600,
+                                               lambda: None)
+            self.io_loop.remove_timeout(timeout)
+        # HACK: wait two IOLoop iterations for the GC to happen.
+        self.io_loop.add_callback(lambda: self.io_loop.add_callback(self.stop))
+        self.wait()
+
+
+# Deliberately not a subclass of AsyncTestCase so the IOLoop isn't
+# automatically set as current.
+class TestIOLoopCurrent(unittest.TestCase):
+    def setUp(self):
+        self.io_loop = IOLoop()
+
+    def tearDown(self):
+        self.io_loop.close()
+
+    def test_current(self):
+        def f():
+            self.current_io_loop = IOLoop.current()
+            self.io_loop.stop()
+        self.io_loop.add_callback(f)
+        self.io_loop.start()
+        self.assertIs(self.current_io_loop, self.io_loop)
+
+
+class TestIOLoopAddCallback(AsyncTestCase):
+    def setUp(self):
+        super(TestIOLoopAddCallback, self).setUp()
+        self.active_contexts = []
+
+    def add_callback(self, callback, *args, **kwargs):
+        self.io_loop.add_callback(callback, *args, **kwargs)
+
+    @contextlib.contextmanager
+    def context(self, name):
+        self.active_contexts.append(name)
+        yield
+        self.assertEqual(self.active_contexts.pop(), name)
+
+    def test_pre_wrap(self):
+        # A pre-wrapped callback is run in the context in which it was
+        # wrapped, not when it was added to the IOLoop.
+        def f1():
+            self.assertIn('c1', self.active_contexts)
+            self.assertNotIn('c2', self.active_contexts)
+            self.stop()
+
+        with StackContext(functools.partial(self.context, 'c1')):
+            wrapped = wrap(f1)
+
+        with StackContext(functools.partial(self.context, 'c2')):
+            self.add_callback(wrapped)
+
+        self.wait()
+
+    def test_pre_wrap_with_args(self):
+        # Same as test_pre_wrap, but the function takes arguments.
+        # Implementation note: The function must not be wrapped in a
+        # functools.partial until after it has been passed through
+        # stack_context.wrap
+        def f1(foo, bar):
+            self.assertIn('c1', self.active_contexts)
+            self.assertNotIn('c2', self.active_contexts)
+            self.stop((foo, bar))
+
+        with StackContext(functools.partial(self.context, 'c1')):
+            wrapped = wrap(f1)
+
+        with StackContext(functools.partial(self.context, 'c2')):
+            self.add_callback(wrapped, 1, bar=2)
+
+        result = self.wait()
+        self.assertEqual(result, (1, 2))
+
+
+class TestIOLoopAddCallbackFromSignal(TestIOLoopAddCallback):
+    # Repeat the add_callback tests using add_callback_from_signal
+    def add_callback(self, callback, *args, **kwargs):
+        self.io_loop.add_callback_from_signal(callback, *args, **kwargs)
+
+
+@unittest.skipIf(futures is None, "futures module not present")
+class TestIOLoopFutures(AsyncTestCase):
+    def test_add_future_threads(self):
+        with futures.ThreadPoolExecutor(1) as pool:
+            self.io_loop.add_future(pool.submit(lambda: None),
+                                    lambda future: self.stop(future))
+            future = self.wait()
+            self.assertTrue(future.done())
+            self.assertTrue(future.result() is None)
+
+    def test_add_future_stack_context(self):
+        ready = threading.Event()
+
+        def task():
+            # we must wait for the ioloop callback to be scheduled before
+            # the task completes to ensure that add_future adds the callback
+            # asynchronously (which is the scenario in which capturing
+            # the stack_context matters)
+            ready.wait(1)
+            assert ready.isSet(), "timed out"
+            raise Exception("worker")
+
+        def callback(future):
+            self.future = future
+            raise Exception("callback")
+
+        def handle_exception(typ, value, traceback):
+            self.exception = value
+            self.stop()
+            return True
+
+        # stack_context propagates to the ioloop callback, but the worker
+        # task just has its exceptions caught and saved in the Future.
+        with futures.ThreadPoolExecutor(1) as pool:
+            with ExceptionStackContext(handle_exception):
+                self.io_loop.add_future(pool.submit(task), callback)
+            ready.set()
+        self.wait()
+
+        self.assertEqual(self.exception.args[0], "callback")
+        self.assertEqual(self.future.exception().args[0], "worker")
+
+
+class TestIOLoopRunSync(unittest.TestCase):
+    def setUp(self):
+        self.io_loop = IOLoop()
+
+    def tearDown(self):
+        self.io_loop.close()
+
+    def test_sync_result(self):
+        self.assertEqual(self.io_loop.run_sync(lambda: 42), 42)
+
+    def test_sync_exception(self):
+        with self.assertRaises(ZeroDivisionError):
+            self.io_loop.run_sync(lambda: 1 / 0)
+
+    def test_async_result(self):
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            raise gen.Return(42)
+        self.assertEqual(self.io_loop.run_sync(f), 42)
+
+    def test_async_exception(self):
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_callback)
+            1 / 0
+        with self.assertRaises(ZeroDivisionError):
+            self.io_loop.run_sync(f)
+
+    def test_current(self):
+        def f():
+            self.assertIs(IOLoop.current(), self.io_loop)
+        self.io_loop.run_sync(f)
+
+    def test_timeout(self):
+        @gen.coroutine
+        def f():
+            yield gen.Task(self.io_loop.add_timeout, self.io_loop.time() + 1)
+        self.assertRaises(TimeoutError, self.io_loop.run_sync, f, timeout=0.01)
+
+if __name__ == "__main__":
+    unittest.main()

Shared/lib/python2.7/site-packages/tornado/test/iostream_test.py

@@ -0,0 +1,545 @@
+from __future__ import absolute_import, division, print_function, with_statement
+from tornado import netutil
+from tornado.ioloop import IOLoop
+from tornado.iostream import IOStream, SSLIOStream, PipeIOStream
+from tornado.log import gen_log, app_log
+from tornado.netutil import ssl_wrap_socket
+from tornado.stack_context import NullContext
+from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, bind_unused_port, ExpectLog
+from tornado.test.util import unittest, skipIfNonUnix
+from tornado.web import RequestHandler, Application
+import errno
+import logging
+import os
+import platform
+import socket
+import ssl
+import sys
+
+
+class HelloHandler(RequestHandler):
+    def get(self):
+        self.write("Hello")
+
+
+class TestIOStreamWebMixin(object):
+    def _make_client_iostream(self):
+        raise NotImplementedError()
+
+    def get_app(self):
+        return Application([('/', HelloHandler)])
+
+    def test_connection_closed(self):
+        # When a server sends a response and then closes the connection,
+        # the client must be allowed to read the data before the IOStream
+        # closes itself.  Epoll reports closed connections with a separate
+        # EPOLLRDHUP event delivered at the same time as the read event,
+        # while kqueue reports them as a second read/write event with an EOF
+        # flag.
+        response = self.fetch("/", headers={"Connection": "close"})
+        response.rethrow()
+
+    def test_read_until_close(self):
+        stream = self._make_client_iostream()
+        stream.connect(('localhost', self.get_http_port()), callback=self.stop)
+        self.wait()
+        stream.write(b"GET / HTTP/1.0\r\n\r\n")
+
+        stream.read_until_close(self.stop)
+        data = self.wait()
+        self.assertTrue(data.startswith(b"HTTP/1.0 200"))
+        self.assertTrue(data.endswith(b"Hello"))
+
+    def test_read_zero_bytes(self):
+        self.stream = self._make_client_iostream()
+        self.stream.connect(("localhost", self.get_http_port()),
+                            callback=self.stop)
+        self.wait()
+        self.stream.write(b"GET / HTTP/1.0\r\n\r\n")
+
+        # normal read
+        self.stream.read_bytes(9, self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"HTTP/1.0 ")
+
+        # zero bytes
+        self.stream.read_bytes(0, self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"")
+
+        # another normal read
+        self.stream.read_bytes(3, self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"200")
+
+        self.stream.close()
+
+    def test_write_while_connecting(self):
+        stream = self._make_client_iostream()
+        connected = [False]
+
+        def connected_callback():
+            connected[0] = True
+            self.stop()
+        stream.connect(("localhost", self.get_http_port()),
+                       callback=connected_callback)
+        # unlike the previous tests, try to write before the connection
+        # is complete.
+        written = [False]
+
+        def write_callback():
+            written[0] = True
+            self.stop()
+        stream.write(b"GET / HTTP/1.0\r\nConnection: close\r\n\r\n",
+                     callback=write_callback)
+        self.assertTrue(not connected[0])
+        # by the time the write has flushed, the connection callback has
+        # also run
+        try:
+            self.wait(lambda: connected[0] and written[0])
+        finally:
+            logging.debug((connected, written))
+
+        stream.read_until_close(self.stop)
+        data = self.wait()
+        self.assertTrue(data.endswith(b"Hello"))
+
+        stream.close()
+
+
+class TestIOStreamMixin(object):
+    def _make_server_iostream(self, connection, **kwargs):
+        raise NotImplementedError()
+
+    def _make_client_iostream(self, connection, **kwargs):
+        raise NotImplementedError()
+
+    def make_iostream_pair(self, **kwargs):
+        listener, port = bind_unused_port()
+        streams = [None, None]
+
+        def accept_callback(connection, address):
+            streams[0] = self._make_server_iostream(connection, **kwargs)
+            if isinstance(streams[0], SSLIOStream):
+                # HACK: The SSL handshake won't complete (and
+                # therefore the client connect callback won't be
+                # run)until the server side has tried to do something
+                # with the connection.  For these tests we want both
+                # sides to connect before we do anything else with the
+                # connection, so we must cause some dummy activity on the
+                # server.  If this turns out to be useful for real apps
+                # it should have a cleaner interface.
+                streams[0]._add_io_state(IOLoop.READ)
+            self.stop()
+
+        def connect_callback():
+            streams[1] = client_stream
+            self.stop()
+        netutil.add_accept_handler(listener, accept_callback,
+                                   io_loop=self.io_loop)
+        client_stream = self._make_client_iostream(socket.socket(), **kwargs)
+        client_stream.connect(('127.0.0.1', port),
+                              callback=connect_callback)
+        self.wait(condition=lambda: all(streams))
+        self.io_loop.remove_handler(listener.fileno())
+        listener.close()
+        return streams
+
+    def test_streaming_callback_with_data_in_buffer(self):
+        server, client = self.make_iostream_pair()
+        client.write(b"abcd\r\nefgh")
+        server.read_until(b"\r\n", self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"abcd\r\n")
+
+        def closed_callback(chunk):
+            self.fail()
+        server.read_until_close(callback=closed_callback,
+                                streaming_callback=self.stop)
+        # self.io_loop.add_timeout(self.io_loop.time() + 0.01, self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"efgh")
+        server.close()
+        client.close()
+
+    def test_write_zero_bytes(self):
+        # Attempting to write zero bytes should run the callback without
+        # going into an infinite loop.
+        server, client = self.make_iostream_pair()
+        server.write(b'', callback=self.stop)
+        self.wait()
+        # As a side effect, the stream is now listening for connection
+        # close (if it wasn't already), but is not listening for writes
+        self.assertEqual(server._state, IOLoop.READ | IOLoop.ERROR)
+        server.close()
+        client.close()
+
+    def test_connection_refused(self):
+        # When a connection is refused, the connect callback should not
+        # be run.  (The kqueue IOLoop used to behave differently from the
+        # epoll IOLoop in this respect)
+        server_socket, port = bind_unused_port()
+        server_socket.close()
+        stream = IOStream(socket.socket(), self.io_loop)
+        self.connect_called = False
+
+        def connect_callback():
+            self.connect_called = True
+        stream.set_close_callback(self.stop)
+        # log messages vary by platform and ioloop implementation
+        with ExpectLog(gen_log, ".*", required=False):
+            stream.connect(("localhost", port), connect_callback)
+            self.wait()
+        self.assertFalse(self.connect_called)
+        self.assertTrue(isinstance(stream.error, socket.error), stream.error)
+        if sys.platform != 'cygwin':
+            # cygwin's errnos don't match those used on native windows python
+            self.assertEqual(stream.error.args[0], errno.ECONNREFUSED)
+
+    def test_gaierror(self):
+        # Test that IOStream sets its exc_info on getaddrinfo error
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+        stream = IOStream(s, io_loop=self.io_loop)
+        stream.set_close_callback(self.stop)
+        # To reliably generate a gaierror we use a malformed domain name
+        # instead of a name that's simply unlikely to exist (since
+        # opendns and some ISPs return bogus addresses for nonexistent
+        # domains instead of the proper error codes).
+        with ExpectLog(gen_log, "Connect error"):
+            stream.connect(('an invalid domain', 54321))
+            self.assertTrue(isinstance(stream.error, socket.gaierror), stream.error)
+
+    def test_read_callback_error(self):
+        # Test that IOStream sets its exc_info when a read callback throws
+        server, client = self.make_iostream_pair()
+        try:
+            server.set_close_callback(self.stop)
+            with ExpectLog(
+                app_log, "(Uncaught exception|Exception in callback)"
+            ):
+                # Clear ExceptionStackContext so IOStream catches error
+                with NullContext():
+                    server.read_bytes(1, callback=lambda data: 1 / 0)
+                client.write(b"1")
+                self.wait()
+            self.assertTrue(isinstance(server.error, ZeroDivisionError))
+        finally:
+            server.close()
+            client.close()
+
+    def test_streaming_callback(self):
+        server, client = self.make_iostream_pair()
+        try:
+            chunks = []
+            final_called = []
+
+            def streaming_callback(data):
+                chunks.append(data)
+                self.stop()
+
+            def final_callback(data):
+                self.assertFalse(data)
+                final_called.append(True)
+                self.stop()
+            server.read_bytes(6, callback=final_callback,
+                              streaming_callback=streaming_callback)
+            client.write(b"1234")
+            self.wait(condition=lambda: chunks)
+            client.write(b"5678")
+            self.wait(condition=lambda: final_called)
+            self.assertEqual(chunks, [b"1234", b"56"])
+
+            # the rest of the last chunk is still in the buffer
+            server.read_bytes(2, callback=self.stop)
+            data = self.wait()
+            self.assertEqual(data, b"78")
+        finally:
+            server.close()
+            client.close()
+
+    def test_streaming_until_close(self):
+        server, client = self.make_iostream_pair()
+        try:
+            chunks = []
+            closed = [False]
+
+            def streaming_callback(data):
+                chunks.append(data)
+                self.stop()
+            def close_callback(data):
+                assert not data, data
+                closed[0] = True
+                self.stop()
+            client.read_until_close(callback=close_callback,
+                                    streaming_callback=streaming_callback)
+            server.write(b"1234")
+            self.wait(condition=lambda: len(chunks) == 1)
+            server.write(b"5678", self.stop)
+            self.wait()
+            server.close()
+            self.wait(condition=lambda: closed[0])
+            self.assertEqual(chunks, [b"1234", b"5678"])
+        finally:
+            server.close()
+            client.close()
+
+    def test_delayed_close_callback(self):
+        # The scenario:  Server closes the connection while there is a pending
+        # read that can be served out of buffered data.  The client does not
+        # run the close_callback as soon as it detects the close, but rather
+        # defers it until after the buffered read has finished.
+        server, client = self.make_iostream_pair()
+        try:
+            client.set_close_callback(self.stop)
+            server.write(b"12")
+            chunks = []
+
+            def callback1(data):
+                chunks.append(data)
+                client.read_bytes(1, callback2)
+                server.close()
+
+            def callback2(data):
+                chunks.append(data)
+            client.read_bytes(1, callback1)
+            self.wait()  # stopped by close_callback
+            self.assertEqual(chunks, [b"1", b"2"])
+        finally:
+            server.close()
+            client.close()
+
+    def test_close_buffered_data(self):
+        # Similar to the previous test, but with data stored in the OS's
+        # socket buffers instead of the IOStream's read buffer.  Out-of-band
+        # close notifications must be delayed until all data has been
+        # drained into the IOStream buffer. (epoll used to use out-of-band
+        # close events with EPOLLRDHUP, but no longer)
+        #
+        # This depends on the read_chunk_size being smaller than the
+        # OS socket buffer, so make it small.
+        server, client = self.make_iostream_pair(read_chunk_size=256)
+        try:
+            server.write(b"A" * 512)
+            client.read_bytes(256, self.stop)
+            data = self.wait()
+            self.assertEqual(b"A" * 256, data)
+            server.close()
+            # Allow the close to propagate to the client side of the
+            # connection.  Using add_callback instead of add_timeout
+            # doesn't seem to work, even with multiple iterations
+            self.io_loop.add_timeout(self.io_loop.time() + 0.01, self.stop)
+            self.wait()
+            client.read_bytes(256, self.stop)
+            data = self.wait()
+            self.assertEqual(b"A" * 256, data)
+        finally:
+            server.close()
+            client.close()
+
+    def test_read_until_close_after_close(self):
+        # Similar to test_delayed_close_callback, but read_until_close takes
+        # a separate code path so test it separately.
+        server, client = self.make_iostream_pair()
+        client.set_close_callback(self.stop)
+        try:
+            server.write(b"1234")
+            server.close()
+            self.wait()
+            client.read_until_close(self.stop)
+            data = self.wait()
+            self.assertEqual(data, b"1234")
+        finally:
+            server.close()
+            client.close()
+
+    def test_streaming_read_until_close_after_close(self):
+        # Same as the preceding test but with a streaming_callback.
+        # All data should go through the streaming callback,
+        # and the final read callback just gets an empty string.
+        server, client = self.make_iostream_pair()
+        client.set_close_callback(self.stop)
+        try:
+            server.write(b"1234")
+            server.close()
+            self.wait()
+            streaming_data = []
+            client.read_until_close(self.stop,
+                                    streaming_callback=streaming_data.append)
+            data = self.wait()
+            self.assertEqual(b'', data)
+            self.assertEqual(b''.join(streaming_data), b"1234")
+        finally:
+            server.close()
+            client.close()
+
+    def test_large_read_until(self):
+        # Performance test: read_until used to have a quadratic component
+        # so a read_until of 4MB would take 8 seconds; now it takes 0.25
+        # seconds.
+        server, client = self.make_iostream_pair()
+        try:
+            # This test fails on pypy with ssl.  I think it's because
+            # pypy's gc defeats moves objects, breaking the
+            # "frozen write buffer" assumption.
+            if (isinstance(server, SSLIOStream) and
+                    platform.python_implementation() == 'PyPy'):
+                raise unittest.SkipTest(
+                    "pypy gc causes problems with openssl")
+            NUM_KB = 4096
+            for i in range(NUM_KB):
+                client.write(b"A" * 1024)
+            client.write(b"\r\n")
+            server.read_until(b"\r\n", self.stop)
+            data = self.wait()
+            self.assertEqual(len(data), NUM_KB * 1024 + 2)
+        finally:
+            server.close()
+            client.close()
+
+    def test_close_callback_with_pending_read(self):
+        # Regression test for a bug that was introduced in 2.3
+        # where the IOStream._close_callback would never be called
+        # if there were pending reads.
+        OK = b"OK\r\n"
+        server, client = self.make_iostream_pair()
+        client.set_close_callback(self.stop)
+        try:
+            server.write(OK)
+            client.read_until(b"\r\n", self.stop)
+            res = self.wait()
+            self.assertEqual(res, OK)
+
+            server.close()
+            client.read_until(b"\r\n", lambda x: x)
+            # If _close_callback (self.stop) is not called,
+            # an AssertionError: Async operation timed out after 5 seconds
+            # will be raised.
+            res = self.wait()
+            self.assertTrue(res is None)
+        finally:
+            server.close()
+            client.close()
+
+    @skipIfNonUnix
+    def test_inline_read_error(self):
+        # An error on an inline read is raised without logging (on the
+        # assumption that it will eventually be noticed or logged further
+        # up the stack).
+        #
+        # This test is posix-only because windows os.close() doesn't work
+        # on socket FDs, but we can't close the socket object normally
+        # because we won't get the error we want if the socket knows
+        # it's closed.
+        server, client = self.make_iostream_pair()
+        try:
+            os.close(server.socket.fileno())
+            with self.assertRaises(socket.error):
+                server.read_bytes(1, lambda data: None)
+        finally:
+            server.close()
+            client.close()
+
+    def test_async_read_error_logging(self):
+        # Socket errors on asynchronous reads should be logged (but only
+        # once).
+        server, client = self.make_iostream_pair()
+        server.set_close_callback(self.stop)
+        try:
+            # Start a read that will be fullfilled asynchronously.
+            server.read_bytes(1, lambda data: None)
+            client.write(b'a')
+            # Stub out read_from_fd to make it fail.
+
+            def fake_read_from_fd():
+                os.close(server.socket.fileno())
+                server.__class__.read_from_fd(server)
+            server.read_from_fd = fake_read_from_fd
+            # This log message is from _handle_read (not read_from_fd).
+            with ExpectLog(gen_log, "error on read"):
+                self.wait()
+        finally:
+            server.close()
+            client.close()
+
+
+class TestIOStreamWebHTTP(TestIOStreamWebMixin, AsyncHTTPTestCase):
+    def _make_client_iostream(self):
+        return IOStream(socket.socket(), io_loop=self.io_loop)
+
+
+class TestIOStreamWebHTTPS(TestIOStreamWebMixin, AsyncHTTPSTestCase):
+    def _make_client_iostream(self):
+        return SSLIOStream(socket.socket(), io_loop=self.io_loop)
+
+
+class TestIOStream(TestIOStreamMixin, AsyncTestCase):
+    def _make_server_iostream(self, connection, **kwargs):
+        return IOStream(connection, **kwargs)
+
+    def _make_client_iostream(self, connection, **kwargs):
+        return IOStream(connection, **kwargs)
+
+
+class TestIOStreamSSL(TestIOStreamMixin, AsyncTestCase):
+    def _make_server_iostream(self, connection, **kwargs):
+        ssl_options = dict(
+            certfile=os.path.join(os.path.dirname(__file__), 'test.crt'),
+            keyfile=os.path.join(os.path.dirname(__file__), 'test.key'),
+        )
+        connection = ssl.wrap_socket(connection,
+                                     server_side=True,
+                                     do_handshake_on_connect=False,
+                                     **ssl_options)
+        return SSLIOStream(connection, io_loop=self.io_loop, **kwargs)
+
+    def _make_client_iostream(self, connection, **kwargs):
+        return SSLIOStream(connection, io_loop=self.io_loop, **kwargs)
+
+
+# This will run some tests that are basically redundant but it's the
+# simplest way to make sure that it works to pass an SSLContext
+# instead of an ssl_options dict to the SSLIOStream constructor.
+@unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present')
+class TestIOStreamSSLContext(TestIOStreamMixin, AsyncTestCase):
+    def _make_server_iostream(self, connection, **kwargs):
+        context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        context.load_cert_chain(
+            os.path.join(os.path.dirname(__file__), 'test.crt'),
+            os.path.join(os.path.dirname(__file__), 'test.key'))
+        connection = ssl_wrap_socket(connection, context,
+                                     server_side=True,
+                                     do_handshake_on_connect=False)
+        return SSLIOStream(connection, io_loop=self.io_loop, **kwargs)
+
+    def _make_client_iostream(self, connection, **kwargs):
+        context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        return SSLIOStream(connection, io_loop=self.io_loop,
+                           ssl_options=context, **kwargs)
+
+
+@skipIfNonUnix
+class TestPipeIOStream(AsyncTestCase):
+    def test_pipe_iostream(self):
+        r, w = os.pipe()
+
+        rs = PipeIOStream(r, io_loop=self.io_loop)
+        ws = PipeIOStream(w, io_loop=self.io_loop)
+
+        ws.write(b"hel")
+        ws.write(b"lo world")
+
+        rs.read_until(b' ', callback=self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"hello ")
+
+        rs.read_bytes(3, self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"wor")
+
+        ws.close()
+
+        rs.read_until_close(self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"ld")
+
+        rs.close()

Shared/lib/python2.7/site-packages/tornado/test/locale_test.py

@@ -0,0 +1,59 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import datetime
+import os
+import tornado.locale
+from tornado.escape import utf8
+from tornado.test.util import unittest
+from tornado.util import u, unicode_type
+
+
+class TranslationLoaderTest(unittest.TestCase):
+    # TODO: less hacky way to get isolated tests
+    SAVE_VARS = ['_translations', '_supported_locales', '_use_gettext']
+
+    def clear_locale_cache(self):
+        if hasattr(tornado.locale.Locale, '_cache'):
+            del tornado.locale.Locale._cache
+
+    def setUp(self):
+        self.saved = {}
+        for var in TranslationLoaderTest.SAVE_VARS:
+            self.saved[var] = getattr(tornado.locale, var)
+        self.clear_locale_cache()
+
+    def tearDown(self):
+        for k, v in self.saved.items():
+            setattr(tornado.locale, k, v)
+        self.clear_locale_cache()
+
+    def test_csv(self):
+        tornado.locale.load_translations(
+            os.path.join(os.path.dirname(__file__), 'csv_translations'))
+        locale = tornado.locale.get("fr_FR")
+        self.assertTrue(isinstance(locale, tornado.locale.CSVLocale))
+        self.assertEqual(locale.translate("school"), u("\u00e9cole"))
+
+    def test_gettext(self):
+        tornado.locale.load_gettext_translations(
+            os.path.join(os.path.dirname(__file__), 'gettext_translations'),
+            "tornado_test")
+        locale = tornado.locale.get("fr_FR")
+        self.assertTrue(isinstance(locale, tornado.locale.GettextLocale))
+        self.assertEqual(locale.translate("school"), u("\u00e9cole"))
+
+
+class LocaleDataTest(unittest.TestCase):
+    def test_non_ascii_name(self):
+        name = tornado.locale.LOCALE_NAMES['es_LA']['name']
+        self.assertTrue(isinstance(name, unicode_type))
+        self.assertEqual(name, u('Espa\u00f1ol'))
+        self.assertEqual(utf8(name), b'Espa\xc3\xb1ol')
+
+
+class EnglishTest(unittest.TestCase):
+    def test_format_date(self):
+        locale = tornado.locale.get('en_US')
+        date = datetime.datetime(2013, 4, 28, 18, 35)
+        self.assertEqual(locale.format_date(date, full_format=True),
+                         'April 28, 2013 at 6:35 pm')

Shared/lib/python2.7/site-packages/tornado/test/log_test.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+#
+# Copyright 2012 Facebook
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+from __future__ import absolute_import, division, print_function, with_statement
+
+import contextlib
+import glob
+import logging
+import os
+import re
+import tempfile
+import warnings
+
+from tornado.escape import utf8
+from tornado.log import LogFormatter, define_logging_options, enable_pretty_logging
+from tornado.options import OptionParser
+from tornado.test.util import unittest
+from tornado.util import u, bytes_type, basestring_type
+
+
+@contextlib.contextmanager
+def ignore_bytes_warning():
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', category=BytesWarning)
+        yield
+
+
+class LogFormatterTest(unittest.TestCase):
+    # Matches the output of a single logging call (which may be multiple lines
+    # if a traceback was included, so we use the DOTALL option)
+    LINE_RE = re.compile(b"(?s)\x01\\[E [0-9]{6} [0-9]{2}:[0-9]{2}:[0-9]{2} log_test:[0-9]+\\]\x02 (.*)")
+
+    def setUp(self):
+        self.formatter = LogFormatter(color=False)
+        # Fake color support.  We can't guarantee anything about the $TERM
+        # variable when the tests are run, so just patch in some values
+        # for testing.  (testing with color off fails to expose some potential
+        # encoding issues from the control characters)
+        self.formatter._colors = {
+            logging.ERROR: u("\u0001"),
+        }
+        self.formatter._normal = u("\u0002")
+        self.formatter._color = True
+        # construct a Logger directly to bypass getLogger's caching
+        self.logger = logging.Logger('LogFormatterTest')
+        self.logger.propagate = False
+        self.tempdir = tempfile.mkdtemp()
+        self.filename = os.path.join(self.tempdir, 'log.out')
+        self.handler = self.make_handler(self.filename)
+        self.handler.setFormatter(self.formatter)
+        self.logger.addHandler(self.handler)
+
+    def tearDown(self):
+        self.handler.close()
+        os.unlink(self.filename)
+        os.rmdir(self.tempdir)
+
+    def make_handler(self, filename):
+        # Base case: default setup without explicit encoding.
+        # In python 2, supports arbitrary byte strings and unicode objects
+        # that contain only ascii.  In python 3, supports ascii-only unicode
+        # strings (but byte strings will be repr'd automatically).
+        return logging.FileHandler(filename)
+
+    def get_output(self):
+        with open(self.filename, "rb") as f:
+            line = f.read().strip()
+            m = LogFormatterTest.LINE_RE.match(line)
+            if m:
+                return m.group(1)
+            else:
+                raise Exception("output didn't match regex: %r" % line)
+
+    def test_basic_logging(self):
+        self.logger.error("foo")
+        self.assertEqual(self.get_output(), b"foo")
+
+    def test_bytes_logging(self):
+        with ignore_bytes_warning():
+            # This will be "\xe9" on python 2 or "b'\xe9'" on python 3
+            self.logger.error(b"\xe9")
+            self.assertEqual(self.get_output(), utf8(repr(b"\xe9")))
+
+    def test_utf8_logging(self):
+        self.logger.error(u("\u00e9").encode("utf8"))
+        if issubclass(bytes_type, basestring_type):
+            # on python 2, utf8 byte strings (and by extension ascii byte
+            # strings) are passed through as-is.
+            self.assertEqual(self.get_output(), utf8(u("\u00e9")))
+        else:
+            # on python 3, byte strings always get repr'd even if
+            # they're ascii-only, so this degenerates into another
+            # copy of test_bytes_logging.
+            self.assertEqual(self.get_output(), utf8(repr(utf8(u("\u00e9")))))
+
+    def test_bytes_exception_logging(self):
+        try:
+            raise Exception(b'\xe9')
+        except Exception:
+            self.logger.exception('caught exception')
+        # This will be "Exception: \xe9" on python 2 or
+        # "Exception: b'\xe9'" on python 3.
+        output = self.get_output()
+        self.assertRegexpMatches(output, br'Exception.*\\xe9')
+        # The traceback contains newlines, which should not have been escaped.
+        self.assertNotIn(br'\n', output)
+
+
+class UnicodeLogFormatterTest(LogFormatterTest):
+    def make_handler(self, filename):
+        # Adding an explicit encoding configuration allows non-ascii unicode
+        # strings in both python 2 and 3, without changing the behavior
+        # for byte strings.
+        return logging.FileHandler(filename, encoding="utf8")
+
+    def test_unicode_logging(self):
+        self.logger.error(u("\u00e9"))
+        self.assertEqual(self.get_output(), utf8(u("\u00e9")))
+
+
+class EnablePrettyLoggingTest(unittest.TestCase):
+    def setUp(self):
+        super(EnablePrettyLoggingTest, self).setUp()
+        self.options = OptionParser()
+        define_logging_options(self.options)
+        self.logger = logging.Logger('tornado.test.log_test.EnablePrettyLoggingTest')
+        self.logger.propagate = False
+
+    def test_log_file(self):
+        tmpdir = tempfile.mkdtemp()
+        try:
+            self.options.log_file_prefix = tmpdir + '/test_log'
+            enable_pretty_logging(options=self.options, logger=self.logger)
+            self.assertEqual(1, len(self.logger.handlers))
+            self.logger.error('hello')
+            self.logger.handlers[0].flush()
+            filenames = glob.glob(tmpdir + '/test_log*')
+            self.assertEqual(1, len(filenames))
+            with open(filenames[0]) as f:
+                self.assertRegexpMatches(f.read(), r'^\[E [^]]*\] hello$')
+        finally:
+            for handler in self.logger.handlers:
+                handler.flush()
+                handler.close()
+            for filename in glob.glob(tmpdir + '/test_log*'):
+                os.unlink(filename)
+            os.rmdir(tmpdir)

Shared/lib/python2.7/site-packages/tornado/test/netutil_test.py

@@ -0,0 +1,84 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import socket
+
+from tornado.netutil import BlockingResolver, ThreadedResolver, is_valid_ip
+from tornado.testing import AsyncTestCase, gen_test
+from tornado.test.util import unittest
+
+try:
+    from concurrent import futures
+except ImportError:
+    futures = None
+
+try:
+    import pycares
+except ImportError:
+    pycares = None
+else:
+    from tornado.platform.caresresolver import CaresResolver
+
+try:
+    import twisted
+except ImportError:
+    twisted = None
+else:
+    from tornado.platform.twisted import TwistedResolver
+
+
+class _ResolverTestMixin(object):
+    def test_localhost(self):
+        self.resolver.resolve('localhost', 80, callback=self.stop)
+        result = self.wait()
+        self.assertIn((socket.AF_INET, ('127.0.0.1', 80)), result)
+
+    @gen_test
+    def test_future_interface(self):
+        addrinfo = yield self.resolver.resolve('localhost', 80,
+                                               socket.AF_UNSPEC)
+        self.assertIn((socket.AF_INET, ('127.0.0.1', 80)),
+                      addrinfo)
+
+
+class BlockingResolverTest(AsyncTestCase, _ResolverTestMixin):
+    def setUp(self):
+        super(BlockingResolverTest, self).setUp()
+        self.resolver = BlockingResolver(io_loop=self.io_loop)
+
+
+@unittest.skipIf(futures is None, "futures module not present")
+class ThreadedResolverTest(AsyncTestCase, _ResolverTestMixin):
+    def setUp(self):
+        super(ThreadedResolverTest, self).setUp()
+        self.resolver = ThreadedResolver(io_loop=self.io_loop)
+
+    def tearDown(self):
+        self.resolver.close()
+        super(ThreadedResolverTest, self).tearDown()
+
+
+@unittest.skipIf(pycares is None, "pycares module not present")
+class CaresResolverTest(AsyncTestCase, _ResolverTestMixin):
+    def setUp(self):
+        super(CaresResolverTest, self).setUp()
+        self.resolver = CaresResolver(io_loop=self.io_loop)
+
+
+@unittest.skipIf(twisted is None, "twisted module not present")
+@unittest.skipIf(getattr(twisted, '__version__', '0.0') < "12.1", "old version of twisted")
+class TwistedResolverTest(AsyncTestCase, _ResolverTestMixin):
+    def setUp(self):
+        super(TwistedResolverTest, self).setUp()
+        self.resolver = TwistedResolver(io_loop=self.io_loop)
+
+
+class IsValidIPTest(unittest.TestCase):
+    def test_is_valid_ip(self):
+        self.assertTrue(is_valid_ip('127.0.0.1'))
+        self.assertTrue(is_valid_ip('4.4.4.4'))
+        self.assertTrue(is_valid_ip('::1'))
+        self.assertTrue(is_valid_ip('2620:0:1cfe:face:b00c::3'))
+        self.assertTrue(not is_valid_ip('www.google.com'))
+        self.assertTrue(not is_valid_ip('localhost'))
+        self.assertTrue(not is_valid_ip('4.4.4.4<'))
+        self.assertTrue(not is_valid_ip(' 127.0.0.1'))

Shared/lib/python2.7/site-packages/tornado/test/options_test.cfg

@@ -0,0 +1,2 @@
+port=443
+port=443

Shared/lib/python2.7/site-packages/tornado/test/options_test.py

@@ -0,0 +1,220 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import datetime
+import os
+import sys
+
+from tornado.options import OptionParser, Error
+from tornado.util import basestring_type
+from tornado.test.util import unittest
+
+try:
+    from cStringIO import StringIO  # python 2
+except ImportError:
+    from io import StringIO  # python 3
+
+try:
+    from unittest import mock  # python 3.3
+except ImportError:
+    try:
+        import mock  # third-party mock package
+    except ImportError:
+        mock = None
+
+
+class OptionsTest(unittest.TestCase):
+    def test_parse_command_line(self):
+        options = OptionParser()
+        options.define("port", default=80)
+        options.parse_command_line(["main.py", "--port=443"])
+        self.assertEqual(options.port, 443)
+
+    def test_parse_config_file(self):
+        options = OptionParser()
+        options.define("port", default=80)
+        options.parse_config_file(os.path.join(os.path.dirname(__file__),
+                                               "options_test.cfg"))
+        self.assertEquals(options.port, 443)
+
+    def test_parse_callbacks(self):
+        options = OptionParser()
+        self.called = False
+
+        def callback():
+            self.called = True
+        options.add_parse_callback(callback)
+
+        # non-final parse doesn't run callbacks
+        options.parse_command_line(["main.py"], final=False)
+        self.assertFalse(self.called)
+
+        # final parse does
+        options.parse_command_line(["main.py"])
+        self.assertTrue(self.called)
+
+        # callbacks can be run more than once on the same options
+        # object if there are multiple final parses
+        self.called = False
+        options.parse_command_line(["main.py"])
+        self.assertTrue(self.called)
+
+    def test_help(self):
+        options = OptionParser()
+        try:
+            orig_stderr = sys.stderr
+            sys.stderr = StringIO()
+            with self.assertRaises(SystemExit):
+                options.parse_command_line(["main.py", "--help"])
+            usage = sys.stderr.getvalue()
+        finally:
+            sys.stderr = orig_stderr
+        self.assertIn("Usage:", usage)
+
+    def test_subcommand(self):
+        base_options = OptionParser()
+        base_options.define("verbose", default=False)
+        sub_options = OptionParser()
+        sub_options.define("foo", type=str)
+        rest = base_options.parse_command_line(
+            ["main.py", "--verbose", "subcommand", "--foo=bar"])
+        self.assertEqual(rest, ["subcommand", "--foo=bar"])
+        self.assertTrue(base_options.verbose)
+        rest2 = sub_options.parse_command_line(rest)
+        self.assertEqual(rest2, [])
+        self.assertEqual(sub_options.foo, "bar")
+
+        # the two option sets are distinct
+        try:
+            orig_stderr = sys.stderr
+            sys.stderr = StringIO()
+            with self.assertRaises(Error):
+                sub_options.parse_command_line(["subcommand", "--verbose"])
+        finally:
+            sys.stderr = orig_stderr
+
+    def test_setattr(self):
+        options = OptionParser()
+        options.define('foo', default=1, type=int)
+        options.foo = 2
+        self.assertEqual(options.foo, 2)
+
+    def test_setattr_type_check(self):
+        # setattr requires that options be the right type and doesn't
+        # parse from string formats.
+        options = OptionParser()
+        options.define('foo', default=1, type=int)
+        with self.assertRaises(Error):
+            options.foo = '2'
+
+    def test_setattr_with_callback(self):
+        values = []
+        options = OptionParser()
+        options.define('foo', default=1, type=int, callback=values.append)
+        options.foo = 2
+        self.assertEqual(values, [2])
+
+    def _sample_options(self):
+        options = OptionParser()
+        options.define('a', default=1)
+        options.define('b', default=2)
+        return options
+
+    def test_iter(self):
+        options = self._sample_options()
+        # OptionParsers always define 'help'.
+        self.assertEqual(set(['a', 'b', 'help']), set(iter(options)))
+
+    def test_getitem(self):
+        options = self._sample_options()
+        self.assertEqual(1, options['a'])
+
+    def test_items(self):
+        options = self._sample_options()
+        # OptionParsers always define 'help'.
+        expected = [('a', 1), ('b', 2), ('help', options.help)]
+        actual = sorted(options.items())
+        self.assertEqual(expected, actual)
+
+    def test_as_dict(self):
+        options = self._sample_options()
+        expected = {'a': 1, 'b': 2, 'help': options.help}
+        self.assertEqual(expected, options.as_dict())
+
+    def test_group_dict(self):
+        options = OptionParser()
+        options.define('a', default=1)
+        options.define('b', group='b_group', default=2)
+
+        frame = sys._getframe(0)
+        this_file = frame.f_code.co_filename
+        self.assertEqual(set(['b_group', '', this_file]), options.groups())
+
+        b_group_dict = options.group_dict('b_group')
+        self.assertEqual({'b': 2}, b_group_dict)
+
+        self.assertEqual({}, options.group_dict('nonexistent'))
+
+    @unittest.skipIf(mock is None, 'mock package not present')
+    def test_mock_patch(self):
+        # ensure that our setattr hooks don't interfere with mock.patch
+        options = OptionParser()
+        options.define('foo', default=1)
+        options.parse_command_line(['main.py', '--foo=2'])
+        self.assertEqual(options.foo, 2)
+
+        with mock.patch.object(options.mockable(), 'foo', 3):
+            self.assertEqual(options.foo, 3)
+        self.assertEqual(options.foo, 2)
+
+        # Try nested patches mixed with explicit sets
+        with mock.patch.object(options.mockable(), 'foo', 4):
+            self.assertEqual(options.foo, 4)
+            options.foo = 5
+            self.assertEqual(options.foo, 5)
+            with mock.patch.object(options.mockable(), 'foo', 6):
+                self.assertEqual(options.foo, 6)
+            self.assertEqual(options.foo, 5)
+        self.assertEqual(options.foo, 2)
+
+    def test_types(self):
+        options = OptionParser()
+        options.define('str', type=str)
+        options.define('basestring', type=basestring_type)
+        options.define('int', type=int)
+        options.define('float', type=float)
+        options.define('datetime', type=datetime.datetime)
+        options.define('timedelta', type=datetime.timedelta)
+        options.parse_command_line(['main.py',
+                                    '--str=asdf',
+                                    '--basestring=qwer',
+                                    '--int=42',
+                                    '--float=1.5',
+                                    '--datetime=2013-04-28 05:16',
+                                    '--timedelta=45s'])
+        self.assertEqual(options.str, 'asdf')
+        self.assertEqual(options.basestring, 'qwer')
+        self.assertEqual(options.int, 42)
+        self.assertEqual(options.float, 1.5)
+        self.assertEqual(options.datetime,
+                         datetime.datetime(2013, 4, 28, 5, 16))
+        self.assertEqual(options.timedelta, datetime.timedelta(seconds=45))
+
+    def test_multiple_string(self):
+        options = OptionParser()
+        options.define('foo', type=str, multiple=True)
+        options.parse_command_line(['main.py', '--foo=a,b,c'])
+        self.assertEqual(options.foo, ['a', 'b', 'c'])
+
+    def test_multiple_int(self):
+        options = OptionParser()
+        options.define('foo', type=int, multiple=True)
+        options.parse_command_line(['main.py', '--foo=1,3,5:7'])
+        self.assertEqual(options.foo, [1, 3, 5, 6, 7])
+
+    def test_error_redefine(self):
+        options = OptionParser()
+        options.define('foo')
+        with self.assertRaises(Error) as cm:
+            options.define('foo')
+        self.assertRegexpMatches(str(cm.exception),
+                                 'Option.*foo.*already defined')

Shared/lib/python2.7/site-packages/tornado/test/process_test.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+
+
+from __future__ import absolute_import, division, print_function, with_statement
+import logging
+import os
+import signal
+import subprocess
+import sys
+from tornado.httpclient import HTTPClient, HTTPError
+from tornado.httpserver import HTTPServer
+from tornado.ioloop import IOLoop
+from tornado.log import gen_log
+from tornado.process import fork_processes, task_id, Subprocess
+from tornado.simple_httpclient import SimpleAsyncHTTPClient
+from tornado.testing import bind_unused_port, ExpectLog, AsyncTestCase
+from tornado.test.util import unittest, skipIfNonUnix
+from tornado.web import RequestHandler, Application
+
+
+def skip_if_twisted():
+    if IOLoop.configured_class().__name__.endswith('TwistedIOLoop'):
+        raise unittest.SkipTest("Process tests not compatible with TwistedIOLoop")
+
+# Not using AsyncHTTPTestCase because we need control over the IOLoop.
+
+
+@skipIfNonUnix
+class ProcessTest(unittest.TestCase):
+    def get_app(self):
+        class ProcessHandler(RequestHandler):
+            def get(self):
+                if self.get_argument("exit", None):
+                    # must use os._exit instead of sys.exit so unittest's
+                    # exception handler doesn't catch it
+                    os._exit(int(self.get_argument("exit")))
+                if self.get_argument("signal", None):
+                    os.kill(os.getpid(),
+                            int(self.get_argument("signal")))
+                self.write(str(os.getpid()))
+        return Application([("/", ProcessHandler)])
+
+    def tearDown(self):
+        if task_id() is not None:
+            # We're in a child process, and probably got to this point
+            # via an uncaught exception.  If we return now, both
+            # processes will continue with the rest of the test suite.
+            # Exit now so the parent process will restart the child
+            # (since we don't have a clean way to signal failure to
+            # the parent that won't restart)
+            logging.error("aborting child process from tearDown")
+            logging.shutdown()
+            os._exit(1)
+        # In the surviving process, clear the alarm we set earlier
+        signal.alarm(0)
+        super(ProcessTest, self).tearDown()
+
+    def test_multi_process(self):
+        # This test can't work on twisted because we use the global reactor
+        # and have no way to get it back into a sane state after the fork.
+        skip_if_twisted()
+        with ExpectLog(gen_log, "(Starting .* processes|child .* exited|uncaught exception)"):
+            self.assertFalse(IOLoop.initialized())
+            sock, port = bind_unused_port()
+
+            def get_url(path):
+                return "http://127.0.0.1:%d%s" % (port, path)
+            # ensure that none of these processes live too long
+            signal.alarm(5)  # master process
+            try:
+                id = fork_processes(3, max_restarts=3)
+                self.assertTrue(id is not None)
+                signal.alarm(5)  # child processes
+            except SystemExit as e:
+                # if we exit cleanly from fork_processes, all the child processes
+                # finished with status 0
+                self.assertEqual(e.code, 0)
+                self.assertTrue(task_id() is None)
+                sock.close()
+                return
+            try:
+                if id in (0, 1):
+                    self.assertEqual(id, task_id())
+                    server = HTTPServer(self.get_app())
+                    server.add_sockets([sock])
+                    IOLoop.instance().start()
+                elif id == 2:
+                    self.assertEqual(id, task_id())
+                    sock.close()
+                    # Always use SimpleAsyncHTTPClient here; the curl
+                    # version appears to get confused sometimes if the
+                    # connection gets closed before it's had a chance to
+                    # switch from writing mode to reading mode.
+                    client = HTTPClient(SimpleAsyncHTTPClient)
+
+                    def fetch(url, fail_ok=False):
+                        try:
+                            return client.fetch(get_url(url))
+                        except HTTPError as e:
+                            if not (fail_ok and e.code == 599):
+                                raise
+
+                    # Make two processes exit abnormally
+                    fetch("/?exit=2", fail_ok=True)
+                    fetch("/?exit=3", fail_ok=True)
+
+                    # They've been restarted, so a new fetch will work
+                    int(fetch("/").body)
+
+                    # Now the same with signals
+                    # Disabled because on the mac a process dying with a signal
+                    # can trigger an "Application exited abnormally; send error
+                    # report to Apple?" prompt.
+                    # fetch("/?signal=%d" % signal.SIGTERM, fail_ok=True)
+                    # fetch("/?signal=%d" % signal.SIGABRT, fail_ok=True)
+                    # int(fetch("/").body)
+
+                    # Now kill them normally so they won't be restarted
+                    fetch("/?exit=0", fail_ok=True)
+                    # One process left; watch it's pid change
+                    pid = int(fetch("/").body)
+                    fetch("/?exit=4", fail_ok=True)
+                    pid2 = int(fetch("/").body)
+                    self.assertNotEqual(pid, pid2)
+
+                    # Kill the last one so we shut down cleanly
+                    fetch("/?exit=0", fail_ok=True)
+
+                    os._exit(0)
+            except Exception:
+                logging.error("exception in child process %d", id, exc_info=True)
+                raise
+
+
+@skipIfNonUnix
+class SubprocessTest(AsyncTestCase):
+    def test_subprocess(self):
+        subproc = Subprocess([sys.executable, '-u', '-i'],
+                             stdin=Subprocess.STREAM,
+                             stdout=Subprocess.STREAM, stderr=subprocess.STDOUT,
+                             io_loop=self.io_loop)
+        self.addCleanup(lambda: os.kill(subproc.pid, signal.SIGTERM))
+        subproc.stdout.read_until(b'>>> ', self.stop)
+        self.wait()
+        subproc.stdin.write(b"print('hello')\n")
+        subproc.stdout.read_until(b'\n', self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"hello\n")
+
+        subproc.stdout.read_until(b">>> ", self.stop)
+        self.wait()
+        subproc.stdin.write(b"raise SystemExit\n")
+        subproc.stdout.read_until_close(self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"")
+
+    def test_close_stdin(self):
+        # Close the parent's stdin handle and see that the child recognizes it.
+        subproc = Subprocess([sys.executable, '-u', '-i'],
+                             stdin=Subprocess.STREAM,
+                             stdout=Subprocess.STREAM, stderr=subprocess.STDOUT,
+                             io_loop=self.io_loop)
+        self.addCleanup(lambda: os.kill(subproc.pid, signal.SIGTERM))
+        subproc.stdout.read_until(b'>>> ', self.stop)
+        self.wait()
+        subproc.stdin.close()
+        subproc.stdout.read_until_close(self.stop)
+        data = self.wait()
+        self.assertEqual(data, b"\n")
+
+    def test_stderr(self):
+        subproc = Subprocess([sys.executable, '-u', '-c',
+                              r"import sys; sys.stderr.write('hello\n')"],
+                             stderr=Subprocess.STREAM,
+                             io_loop=self.io_loop)
+        self.addCleanup(lambda: os.kill(subproc.pid, signal.SIGTERM))
+        subproc.stderr.read_until(b'\n', self.stop)
+        data = self.wait()
+        self.assertEqual(data, b'hello\n')
+
+    def test_sigchild(self):
+        # Twisted's SIGCHLD handler and Subprocess's conflict with each other.
+        skip_if_twisted()
+        Subprocess.initialize(io_loop=self.io_loop)
+        self.addCleanup(Subprocess.uninitialize)
+        subproc = Subprocess([sys.executable, '-c', 'pass'],
+                             io_loop=self.io_loop)
+        subproc.set_exit_callback(self.stop)
+        ret = self.wait()
+        self.assertEqual(ret, 0)
+        self.assertEqual(subproc.returncode, ret)
+
+    def test_sigchild_signal(self):
+        skip_if_twisted()
+        Subprocess.initialize(io_loop=self.io_loop)
+        self.addCleanup(Subprocess.uninitialize)
+        subproc = Subprocess([sys.executable, '-c',
+                              'import time; time.sleep(30)'],
+                             io_loop=self.io_loop)
+        subproc.set_exit_callback(self.stop)
+        os.kill(subproc.pid, signal.SIGTERM)
+        ret = self.wait()
+        self.assertEqual(subproc.returncode, ret)
+        self.assertEqual(ret, -signal.SIGTERM)

Shared/lib/python2.7/site-packages/tornado/test/runtests.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+
+from __future__ import absolute_import, division, print_function, with_statement
+import gc
+import locale  # system locale module, not tornado.locale
+import logging
+import operator
+import textwrap
+import sys
+from tornado.httpclient import AsyncHTTPClient
+from tornado.ioloop import IOLoop
+from tornado.netutil import Resolver
+from tornado.options import define, options, add_parse_callback
+from tornado.test.util import unittest
+
+TEST_MODULES = [
+    'tornado.httputil.doctests',
+    'tornado.iostream.doctests',
+    'tornado.util.doctests',
+    'tornado.test.auth_test',
+    'tornado.test.concurrent_test',
+    'tornado.test.curl_httpclient_test',
+    'tornado.test.escape_test',
+    'tornado.test.gen_test',
+    'tornado.test.httpclient_test',
+    'tornado.test.httpserver_test',
+    'tornado.test.httputil_test',
+    'tornado.test.import_test',
+    'tornado.test.ioloop_test',
+    'tornado.test.iostream_test',
+    'tornado.test.locale_test',
+    'tornado.test.netutil_test',
+    'tornado.test.log_test',
+    'tornado.test.options_test',
+    'tornado.test.process_test',
+    'tornado.test.simple_httpclient_test',
+    'tornado.test.stack_context_test',
+    'tornado.test.template_test',
+    'tornado.test.testing_test',
+    'tornado.test.twisted_test',
+    'tornado.test.util_test',
+    'tornado.test.web_test',
+    'tornado.test.websocket_test',
+    'tornado.test.wsgi_test',
+]
+
+
+def all():
+    return unittest.defaultTestLoader.loadTestsFromNames(TEST_MODULES)
+
+
+class TornadoTextTestRunner(unittest.TextTestRunner):
+    def run(self, test):
+        result = super(TornadoTextTestRunner, self).run(test)
+        if result.skipped:
+            skip_reasons = set(reason for (test, reason) in result.skipped)
+            self.stream.write(textwrap.fill(
+                "Some tests were skipped because: %s" %
+                ", ".join(sorted(skip_reasons))))
+            self.stream.write("\n")
+        return result
+
+if __name__ == '__main__':
+    # The -W command-line option does not work in a virtualenv with
+    # python 3 (as of virtualenv 1.7), so configure warnings
+    # programmatically instead.
+    import warnings
+    # Be strict about most warnings.  This also turns on warnings that are
+    # ignored by default, including DeprecationWarnings and
+    # python 3.2's ResourceWarnings.
+    warnings.filterwarnings("error")
+    # setuptools sometimes gives ImportWarnings about things that are on
+    # sys.path even if they're not being used.
+    warnings.filterwarnings("ignore", category=ImportWarning)
+    # Tornado generally shouldn't use anything deprecated, but some of
+    # our dependencies do (last match wins).
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+    warnings.filterwarnings("error", category=DeprecationWarning,
+                            module=r"tornado\..*")
+    # The unittest module is aggressive about deprecating redundant methods,
+    # leaving some without non-deprecated spellings that work on both
+    # 2.7 and 3.2
+    warnings.filterwarnings("ignore", category=DeprecationWarning,
+                            message="Please use assert.* instead")
+
+    logging.getLogger("tornado.access").setLevel(logging.CRITICAL)
+
+    define('httpclient', type=str, default=None,
+           callback=AsyncHTTPClient.configure)
+    define('ioloop', type=str, default=None)
+    define('ioloop_time_monotonic', default=False)
+    define('resolver', type=str, default=None,
+           callback=Resolver.configure)
+    define('debug_gc', type=str, multiple=True,
+           help="A comma-separated list of gc module debug constants, "
+           "e.g. DEBUG_STATS or DEBUG_COLLECTABLE,DEBUG_OBJECTS",
+           callback=lambda values: gc.set_debug(
+               reduce(operator.or_, (getattr(gc, v) for v in values))))
+    define('locale', type=str, default=None,
+           callback=lambda x: locale.setlocale(locale.LC_ALL, x))
+
+    def configure_ioloop():
+        kwargs = {}
+        if options.ioloop_time_monotonic:
+            from tornado.platform.auto import monotonic_time
+            if monotonic_time is None:
+                raise RuntimeError("monotonic clock not found")
+            kwargs['time_func'] = monotonic_time
+        if options.ioloop or kwargs:
+            IOLoop.configure(options.ioloop, **kwargs)
+    add_parse_callback(configure_ioloop)
+
+    import tornado.testing
+    kwargs = {}
+    if sys.version_info >= (3, 2):
+        # HACK:  unittest.main will make its own changes to the warning
+        # configuration, which may conflict with the settings above
+        # or command-line flags like -bb.  Passing warnings=False
+        # suppresses this behavior, although this looks like an implementation
+        # detail.  http://bugs.python.org/issue15626
+        kwargs['warnings'] = False
+    kwargs['testRunner'] = TornadoTextTestRunner
+    tornado.testing.main(**kwargs)

Shared/lib/python2.7/site-packages/tornado/test/simple_httpclient_test.py

@@ -0,0 +1,398 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import collections
+from contextlib import closing
+import errno
+import gzip
+import logging
+import os
+import re
+import socket
+import sys
+
+from tornado.httpclient import AsyncHTTPClient
+from tornado.httputil import HTTPHeaders
+from tornado.ioloop import IOLoop
+from tornado.log import gen_log
+from tornado.simple_httpclient import SimpleAsyncHTTPClient, _DEFAULT_CA_CERTS
+from tornado.test.httpclient_test import ChunkHandler, CountdownHandler, HelloWorldHandler
+from tornado.test import httpclient_test
+from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, bind_unused_port, ExpectLog
+from tornado.test.util import unittest, skipOnTravis
+from tornado.web import RequestHandler, Application, asynchronous, url
+
+
+class SimpleHTTPClientCommonTestCase(httpclient_test.HTTPClientCommonTestCase):
+    def get_http_client(self):
+        client = SimpleAsyncHTTPClient(io_loop=self.io_loop,
+                                       force_instance=True)
+        self.assertTrue(isinstance(client, SimpleAsyncHTTPClient))
+        return client
+
+
+class TriggerHandler(RequestHandler):
+    def initialize(self, queue, wake_callback):
+        self.queue = queue
+        self.wake_callback = wake_callback
+
+    @asynchronous
+    def get(self):
+        logging.debug("queuing trigger")
+        self.queue.append(self.finish)
+        if self.get_argument("wake", "true") == "true":
+            self.wake_callback()
+
+
+class HangHandler(RequestHandler):
+    @asynchronous
+    def get(self):
+        pass
+
+
+class ContentLengthHandler(RequestHandler):
+    def get(self):
+        self.set_header("Content-Length", self.get_argument("value"))
+        self.write("ok")
+
+
+class HeadHandler(RequestHandler):
+    def head(self):
+        self.set_header("Content-Length", "7")
+
+
+class OptionsHandler(RequestHandler):
+    def options(self):
+        self.set_header("Access-Control-Allow-Origin", "*")
+        self.write("ok")
+
+
+class NoContentHandler(RequestHandler):
+    def get(self):
+        if self.get_argument("error", None):
+            self.set_header("Content-Length", "7")
+        self.set_status(204)
+
+
+class SeeOtherPostHandler(RequestHandler):
+    def post(self):
+        redirect_code = int(self.request.body)
+        assert redirect_code in (302, 303), "unexpected body %r" % self.request.body
+        self.set_header("Location", "/see_other_get")
+        self.set_status(redirect_code)
+
+
+class SeeOtherGetHandler(RequestHandler):
+    def get(self):
+        if self.request.body:
+            raise Exception("unexpected body %r" % self.request.body)
+        self.write("ok")
+
+
+class HostEchoHandler(RequestHandler):
+    def get(self):
+        self.write(self.request.headers["Host"])
+
+
+class SimpleHTTPClientTestMixin(object):
+    def get_app(self):
+        # callable objects to finish pending /trigger requests
+        self.triggers = collections.deque()
+        return Application([
+            url("/trigger", TriggerHandler, dict(queue=self.triggers,
+                                                 wake_callback=self.stop)),
+            url("/chunk", ChunkHandler),
+            url("/countdown/([0-9]+)", CountdownHandler, name="countdown"),
+            url("/hang", HangHandler),
+            url("/hello", HelloWorldHandler),
+            url("/content_length", ContentLengthHandler),
+            url("/head", HeadHandler),
+            url("/options", OptionsHandler),
+            url("/no_content", NoContentHandler),
+            url("/see_other_post", SeeOtherPostHandler),
+            url("/see_other_get", SeeOtherGetHandler),
+            url("/host_echo", HostEchoHandler),
+        ], gzip=True)
+
+    def test_singleton(self):
+        # Class "constructor" reuses objects on the same IOLoop
+        self.assertTrue(SimpleAsyncHTTPClient(self.io_loop) is
+                        SimpleAsyncHTTPClient(self.io_loop))
+        # unless force_instance is used
+        self.assertTrue(SimpleAsyncHTTPClient(self.io_loop) is not
+                        SimpleAsyncHTTPClient(self.io_loop,
+                                              force_instance=True))
+        # different IOLoops use different objects
+        io_loop2 = IOLoop()
+        self.assertTrue(SimpleAsyncHTTPClient(self.io_loop) is not
+                        SimpleAsyncHTTPClient(io_loop2))
+
+    def test_connection_limit(self):
+        with closing(self.create_client(max_clients=2)) as client:
+            self.assertEqual(client.max_clients, 2)
+            seen = []
+            # Send 4 requests.  Two can be sent immediately, while the others
+            # will be queued
+            for i in range(4):
+                client.fetch(self.get_url("/trigger"),
+                             lambda response, i=i: (seen.append(i), self.stop()))
+            self.wait(condition=lambda: len(self.triggers) == 2)
+            self.assertEqual(len(client.queue), 2)
+
+            # Finish the first two requests and let the next two through
+            self.triggers.popleft()()
+            self.triggers.popleft()()
+            self.wait(condition=lambda: (len(self.triggers) == 2 and
+                                         len(seen) == 2))
+            self.assertEqual(set(seen), set([0, 1]))
+            self.assertEqual(len(client.queue), 0)
+
+            # Finish all the pending requests
+            self.triggers.popleft()()
+            self.triggers.popleft()()
+            self.wait(condition=lambda: len(seen) == 4)
+            self.assertEqual(set(seen), set([0, 1, 2, 3]))
+            self.assertEqual(len(self.triggers), 0)
+
+    def test_redirect_connection_limit(self):
+        # following redirects should not consume additional connections
+        with closing(self.create_client(max_clients=1)) as client:
+            client.fetch(self.get_url('/countdown/3'), self.stop,
+                         max_redirects=3)
+            response = self.wait()
+            response.rethrow()
+
+    def test_default_certificates_exist(self):
+        open(_DEFAULT_CA_CERTS).close()
+
+    def test_gzip(self):
+        # All the tests in this file should be using gzip, but this test
+        # ensures that it is in fact getting compressed.
+        # Setting Accept-Encoding manually bypasses the client's
+        # decompression so we can see the raw data.
+        response = self.fetch("/chunk", use_gzip=False,
+                              headers={"Accept-Encoding": "gzip"})
+        self.assertEqual(response.headers["Content-Encoding"], "gzip")
+        self.assertNotEqual(response.body, b"asdfqwer")
+        # Our test data gets bigger when gzipped.  Oops.  :)
+        self.assertEqual(len(response.body), 34)
+        f = gzip.GzipFile(mode="r", fileobj=response.buffer)
+        self.assertEqual(f.read(), b"asdfqwer")
+
+    def test_max_redirects(self):
+        response = self.fetch("/countdown/5", max_redirects=3)
+        self.assertEqual(302, response.code)
+        # We requested 5, followed three redirects for 4, 3, 2, then the last
+        # unfollowed redirect is to 1.
+        self.assertTrue(response.request.url.endswith("/countdown/5"))
+        self.assertTrue(response.effective_url.endswith("/countdown/2"))
+        self.assertTrue(response.headers["Location"].endswith("/countdown/1"))
+
+    def test_header_reuse(self):
+        # Apps may reuse a headers object if they are only passing in constant
+        # headers like user-agent.  The header object should not be modified.
+        headers = HTTPHeaders({'User-Agent': 'Foo'})
+        self.fetch("/hello", headers=headers)
+        self.assertEqual(list(headers.get_all()), [('User-Agent', 'Foo')])
+
+    def test_see_other_redirect(self):
+        for code in (302, 303):
+            response = self.fetch("/see_other_post", method="POST", body="%d" % code)
+            self.assertEqual(200, response.code)
+            self.assertTrue(response.request.url.endswith("/see_other_post"))
+            self.assertTrue(response.effective_url.endswith("/see_other_get"))
+            # request is the original request, is a POST still
+            self.assertEqual("POST", response.request.method)
+
+    @skipOnTravis
+    def test_request_timeout(self):
+        response = self.fetch('/trigger?wake=false', request_timeout=0.1)
+        self.assertEqual(response.code, 599)
+        self.assertTrue(0.099 < response.request_time < 0.15, response.request_time)
+        self.assertEqual(str(response.error), "HTTP 599: Timeout")
+        # trigger the hanging request to let it clean up after itself
+        self.triggers.popleft()()
+
+    @unittest.skipIf(not socket.has_ipv6, 'ipv6 support not present')
+    def test_ipv6(self):
+        try:
+            self.http_server.listen(self.get_http_port(), address='::1')
+        except socket.gaierror as e:
+            if e.args[0] == socket.EAI_ADDRFAMILY:
+                # python supports ipv6, but it's not configured on the network
+                # interface, so skip this test.
+                return
+            raise
+        url = self.get_url("/hello").replace("localhost", "[::1]")
+
+        # ipv6 is currently disabled by default and must be explicitly requested
+        self.http_client.fetch(url, self.stop)
+        response = self.wait()
+        self.assertEqual(response.code, 599)
+
+        self.http_client.fetch(url, self.stop, allow_ipv6=True)
+        response = self.wait()
+        self.assertEqual(response.body, b"Hello world!")
+
+    def test_multiple_content_length_accepted(self):
+        response = self.fetch("/content_length?value=2,2")
+        self.assertEqual(response.body, b"ok")
+        response = self.fetch("/content_length?value=2,%202,2")
+        self.assertEqual(response.body, b"ok")
+
+        response = self.fetch("/content_length?value=2,4")
+        self.assertEqual(response.code, 599)
+        response = self.fetch("/content_length?value=2,%202,3")
+        self.assertEqual(response.code, 599)
+
+    def test_head_request(self):
+        response = self.fetch("/head", method="HEAD")
+        self.assertEqual(response.code, 200)
+        self.assertEqual(response.headers["content-length"], "7")
+        self.assertFalse(response.body)
+
+    def test_options_request(self):
+        response = self.fetch("/options", method="OPTIONS")
+        self.assertEqual(response.code, 200)
+        self.assertEqual(response.headers["content-length"], "2")
+        self.assertEqual(response.headers["access-control-allow-origin"], "*")
+        self.assertEqual(response.body, b"ok")
+
+    def test_no_content(self):
+        response = self.fetch("/no_content")
+        self.assertEqual(response.code, 204)
+        # 204 status doesn't need a content-length, but tornado will
+        # add a zero content-length anyway.
+        self.assertEqual(response.headers["Content-length"], "0")
+
+        # 204 status with non-zero content length is malformed
+        response = self.fetch("/no_content?error=1")
+        self.assertEqual(response.code, 599)
+
+    def test_host_header(self):
+        host_re = re.compile(b"^localhost:[0-9]+$")
+        response = self.fetch("/host_echo")
+        self.assertTrue(host_re.match(response.body))
+
+        url = self.get_url("/host_echo").replace("http://", "http://me:secret@")
+        self.http_client.fetch(url, self.stop)
+        response = self.wait()
+        self.assertTrue(host_re.match(response.body), response.body)
+
+    def test_connection_refused(self):
+        server_socket, port = bind_unused_port()
+        server_socket.close()
+        with ExpectLog(gen_log, ".*", required=False):
+            self.http_client.fetch("http://localhost:%d/" % port, self.stop)
+            response = self.wait()
+        self.assertEqual(599, response.code)
+
+        if sys.platform != 'cygwin':
+            # cygwin returns EPERM instead of ECONNREFUSED here
+            self.assertTrue(str(errno.ECONNREFUSED) in str(response.error),
+                            response.error)
+            # This is usually "Connection refused".
+            # On windows, strerror is broken and returns "Unknown error".
+            expected_message = os.strerror(errno.ECONNREFUSED)
+            self.assertTrue(expected_message in str(response.error),
+                            response.error)
+
+
+class SimpleHTTPClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPTestCase):
+    def setUp(self):
+        super(SimpleHTTPClientTestCase, self).setUp()
+        self.http_client = self.create_client()
+
+    def create_client(self, **kwargs):
+        return SimpleAsyncHTTPClient(self.io_loop, force_instance=True,
+                                     **kwargs)
+
+
+class SimpleHTTPSClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPSTestCase):
+    def setUp(self):
+        super(SimpleHTTPSClientTestCase, self).setUp()
+        self.http_client = self.create_client()
+
+    def create_client(self, **kwargs):
+        return SimpleAsyncHTTPClient(self.io_loop, force_instance=True,
+                                     defaults=dict(validate_cert=False),
+                                     **kwargs)
+
+
+class CreateAsyncHTTPClientTestCase(AsyncTestCase):
+    def setUp(self):
+        super(CreateAsyncHTTPClientTestCase, self).setUp()
+        self.saved = AsyncHTTPClient._save_configuration()
+
+    def tearDown(self):
+        AsyncHTTPClient._restore_configuration(self.saved)
+        super(CreateAsyncHTTPClientTestCase, self).tearDown()
+
+    def test_max_clients(self):
+        AsyncHTTPClient.configure(SimpleAsyncHTTPClient)
+        with closing(AsyncHTTPClient(
+                self.io_loop, force_instance=True)) as client:
+            self.assertEqual(client.max_clients, 10)
+        with closing(AsyncHTTPClient(
+                self.io_loop, max_clients=11, force_instance=True)) as client:
+            self.assertEqual(client.max_clients, 11)
+
+        # Now configure max_clients statically and try overriding it
+        # with each way max_clients can be passed
+        AsyncHTTPClient.configure(SimpleAsyncHTTPClient, max_clients=12)
+        with closing(AsyncHTTPClient(
+                self.io_loop, force_instance=True)) as client:
+            self.assertEqual(client.max_clients, 12)
+        with closing(AsyncHTTPClient(
+                self.io_loop, max_clients=13, force_instance=True)) as client:
+            self.assertEqual(client.max_clients, 13)
+        with closing(AsyncHTTPClient(
+                self.io_loop, max_clients=14, force_instance=True)) as client:
+            self.assertEqual(client.max_clients, 14)
+
+
+class HTTP100ContinueTestCase(AsyncHTTPTestCase):
+    def respond_100(self, request):
+        self.request = request
+        self.request.connection.stream.write(
+            b"HTTP/1.1 100 CONTINUE\r\n\r\n",
+            self.respond_200)
+
+    def respond_200(self):
+        self.request.connection.stream.write(
+            b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\nA",
+            self.request.connection.stream.close)
+
+    def get_app(self):
+        # Not a full Application, but works as an HTTPServer callback
+        return self.respond_100
+
+    def test_100_continue(self):
+        res = self.fetch('/')
+        self.assertEqual(res.body, b'A')
+
+
+class HostnameMappingTestCase(AsyncHTTPTestCase):
+    def setUp(self):
+        super(HostnameMappingTestCase, self).setUp()
+        self.http_client = SimpleAsyncHTTPClient(
+            self.io_loop,
+            hostname_mapping={
+                'www.example.com': '127.0.0.1',
+                ('foo.example.com', 8000): ('127.0.0.1', self.get_http_port()),
+            })
+
+    def get_app(self):
+        return Application([url("/hello", HelloWorldHandler), ])
+
+    def test_hostname_mapping(self):
+        self.http_client.fetch(
+            'http://www.example.com:%d/hello' % self.get_http_port(), self.stop)
+        response = self.wait()
+        response.rethrow()
+        self.assertEqual(response.body, b'Hello world!')
+
+    def test_port_mapping(self):
+        self.http_client.fetch('http://foo.example.com:8000/hello', self.stop)
+        response = self.wait()
+        response.rethrow()
+        self.assertEqual(response.body, b'Hello world!')

Shared/lib/python2.7/site-packages/tornado/test/stack_context_test.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python
+from __future__ import absolute_import, division, print_function, with_statement
+
+from tornado import gen
+from tornado.log import app_log
+from tornado.stack_context import (StackContext, wrap, NullContext, StackContextInconsistentError,
+                                   ExceptionStackContext, run_with_stack_context, _state)
+from tornado.testing import AsyncHTTPTestCase, AsyncTestCase, ExpectLog, gen_test
+from tornado.test.util import unittest
+from tornado.web import asynchronous, Application, RequestHandler
+import contextlib
+import functools
+import logging
+
+
+class TestRequestHandler(RequestHandler):
+    def __init__(self, app, request, io_loop):
+        super(TestRequestHandler, self).__init__(app, request)
+        self.io_loop = io_loop
+
+    @asynchronous
+    def get(self):
+        logging.debug('in get()')
+        # call self.part2 without a self.async_callback wrapper.  Its
+        # exception should still get thrown
+        self.io_loop.add_callback(self.part2)
+
+    def part2(self):
+        logging.debug('in part2()')
+        # Go through a third layer to make sure that contexts once restored
+        # are again passed on to future callbacks
+        self.io_loop.add_callback(self.part3)
+
+    def part3(self):
+        logging.debug('in part3()')
+        raise Exception('test exception')
+
+    def get_error_html(self, status_code, **kwargs):
+        if 'exception' in kwargs and str(kwargs['exception']) == 'test exception':
+            return 'got expected exception'
+        else:
+            return 'unexpected failure'
+
+
+class HTTPStackContextTest(AsyncHTTPTestCase):
+    def get_app(self):
+        return Application([('/', TestRequestHandler,
+                             dict(io_loop=self.io_loop))])
+
+    def test_stack_context(self):
+        with ExpectLog(app_log, "Uncaught exception GET /"):
+            self.http_client.fetch(self.get_url('/'), self.handle_response)
+            self.wait()
+        self.assertEqual(self.response.code, 500)
+        self.assertTrue(b'got expected exception' in self.response.body)
+
+    def handle_response(self, response):
+        self.response = response
+        self.stop()
+
+
+class StackContextTest(AsyncTestCase):
+    def setUp(self):
+        super(StackContextTest, self).setUp()
+        self.active_contexts = []
+
+    @contextlib.contextmanager
+    def context(self, name):
+        self.active_contexts.append(name)
+        yield
+        self.assertEqual(self.active_contexts.pop(), name)
+
+    # Simulates the effect of an asynchronous library that uses its own
+    # StackContext internally and then returns control to the application.
+    def test_exit_library_context(self):
+        def library_function(callback):
+            # capture the caller's context before introducing our own
+            callback = wrap(callback)
+            with StackContext(functools.partial(self.context, 'library')):
+                self.io_loop.add_callback(
+                    functools.partial(library_inner_callback, callback))
+
+        def library_inner_callback(callback):
+            self.assertEqual(self.active_contexts[-2:],
+                             ['application', 'library'])
+            callback()
+
+        def final_callback():
+            # implementation detail:  the full context stack at this point
+            # is ['application', 'library', 'application'].  The 'library'
+            # context was not removed, but is no longer innermost so
+            # the application context takes precedence.
+            self.assertEqual(self.active_contexts[-1], 'application')
+            self.stop()
+        with StackContext(functools.partial(self.context, 'application')):
+            library_function(final_callback)
+        self.wait()
+
+    def test_deactivate(self):
+        deactivate_callbacks = []
+
+        def f1():
+            with StackContext(functools.partial(self.context, 'c1')) as c1:
+                deactivate_callbacks.append(c1)
+                self.io_loop.add_callback(f2)
+
+        def f2():
+            with StackContext(functools.partial(self.context, 'c2')) as c2:
+                deactivate_callbacks.append(c2)
+                self.io_loop.add_callback(f3)
+
+        def f3():
+            with StackContext(functools.partial(self.context, 'c3')) as c3:
+                deactivate_callbacks.append(c3)
+                self.io_loop.add_callback(f4)
+
+        def f4():
+            self.assertEqual(self.active_contexts, ['c1', 'c2', 'c3'])
+            deactivate_callbacks[1]()
+            # deactivating a context doesn't remove it immediately,
+            # but it will be missing from the next iteration
+            self.assertEqual(self.active_contexts, ['c1', 'c2', 'c3'])
+            self.io_loop.add_callback(f5)
+
+        def f5():
+            self.assertEqual(self.active_contexts, ['c1', 'c3'])
+            self.stop()
+        self.io_loop.add_callback(f1)
+        self.wait()
+
+    def test_deactivate_order(self):
+        # Stack context deactivation has separate logic for deactivation at
+        # the head and tail of the stack, so make sure it works in any order.
+        def check_contexts():
+            # Make sure that the full-context array and the exception-context
+            # linked lists are consistent with each other.
+            full_contexts, chain = _state.contexts
+            exception_contexts = []
+            while chain is not None:
+                exception_contexts.append(chain)
+                chain = chain.old_contexts[1]
+            self.assertEqual(list(reversed(full_contexts)), exception_contexts)
+            return list(self.active_contexts)
+
+        def make_wrapped_function():
+            """Wraps a function in three stack contexts, and returns
+            the function along with the deactivation functions.
+            """
+            # Remove the test's stack context to make sure we can cover
+            # the case where the last context is deactivated.
+            with NullContext():
+                partial = functools.partial
+                with StackContext(partial(self.context, 'c0')) as c0:
+                    with StackContext(partial(self.context, 'c1')) as c1:
+                        with StackContext(partial(self.context, 'c2')) as c2:
+                            return (wrap(check_contexts), [c0, c1, c2])
+
+        # First make sure the test mechanism works without any deactivations
+        func, deactivate_callbacks = make_wrapped_function()
+        self.assertEqual(func(), ['c0', 'c1', 'c2'])
+
+        # Deactivate the tail
+        func, deactivate_callbacks = make_wrapped_function()
+        deactivate_callbacks[0]()
+        self.assertEqual(func(), ['c1', 'c2'])
+
+        # Deactivate the middle
+        func, deactivate_callbacks = make_wrapped_function()
+        deactivate_callbacks[1]()
+        self.assertEqual(func(), ['c0', 'c2'])
+
+        # Deactivate the head
+        func, deactivate_callbacks = make_wrapped_function()
+        deactivate_callbacks[2]()
+        self.assertEqual(func(), ['c0', 'c1'])
+
+    def test_isolation_nonempty(self):
+        # f2 and f3 are a chain of operations started in context c1.
+        # f2 is incidentally run under context c2, but that context should
+        # not be passed along to f3.
+        def f1():
+            with StackContext(functools.partial(self.context, 'c1')):
+                wrapped = wrap(f2)
+            with StackContext(functools.partial(self.context, 'c2')):
+                wrapped()
+
+        def f2():
+            self.assertIn('c1', self.active_contexts)
+            self.io_loop.add_callback(f3)
+
+        def f3():
+            self.assertIn('c1', self.active_contexts)
+            self.assertNotIn('c2', self.active_contexts)
+            self.stop()
+
+        self.io_loop.add_callback(f1)
+        self.wait()
+
+    def test_isolation_empty(self):
+        # Similar to test_isolation_nonempty, but here the f2/f3 chain
+        # is started without any context.  Behavior should be equivalent
+        # to the nonempty case (although historically it was not)
+        def f1():
+            with NullContext():
+                wrapped = wrap(f2)
+            with StackContext(functools.partial(self.context, 'c2')):
+                wrapped()
+
+        def f2():
+            self.io_loop.add_callback(f3)
+
+        def f3():
+            self.assertNotIn('c2', self.active_contexts)
+            self.stop()
+
+        self.io_loop.add_callback(f1)
+        self.wait()
+
+    def test_yield_in_with(self):
+        @gen.engine
+        def f():
+            with StackContext(functools.partial(self.context, 'c1')):
+                # This yield is a problem: the generator will be suspended
+                # and the StackContext's __exit__ is not called yet, so
+                # the context will be left on _state.contexts for anything
+                # that runs before the yield resolves.
+                yield gen.Task(self.io_loop.add_callback)
+
+        with self.assertRaises(StackContextInconsistentError):
+            f()
+            self.wait()
+
+    @gen_test
+    def test_yield_outside_with(self):
+        # This pattern avoids the problem in the previous test.
+        cb = yield gen.Callback('k1')
+        with StackContext(functools.partial(self.context, 'c1')):
+            self.io_loop.add_callback(cb)
+        yield gen.Wait('k1')
+
+    def test_yield_in_with_exception_stack_context(self):
+        # As above, but with ExceptionStackContext instead of StackContext.
+        @gen.engine
+        def f():
+            with ExceptionStackContext(lambda t, v, tb: False):
+                yield gen.Task(self.io_loop.add_callback)
+
+        with self.assertRaises(StackContextInconsistentError):
+            f()
+            self.wait()
+
+    @gen_test
+    def test_yield_outside_with_exception_stack_context(self):
+        cb = yield gen.Callback('k1')
+        with ExceptionStackContext(lambda t, v, tb: False):
+            self.io_loop.add_callback(cb)
+        yield gen.Wait('k1')
+
+    def test_run_with_stack_context(self):
+        @gen.coroutine
+        def f1():
+            self.assertEqual(self.active_contexts, ['c1'])
+            yield run_with_stack_context(
+                StackContext(functools.partial(self.context, 'c1')),
+                f2)
+            self.assertEqual(self.active_contexts, ['c1'])
+
+        @gen.coroutine
+        def f2():
+            self.assertEqual(self.active_contexts, ['c1', 'c2'])
+            yield gen.Task(self.io_loop.add_callback)
+            self.assertEqual(self.active_contexts, ['c1', 'c2'])
+
+        self.assertEqual(self.active_contexts, [])
+        run_with_stack_context(
+            StackContext(functools.partial(self.context, 'c1')),
+            f1)
+        self.assertEqual(self.active_contexts, [])
+
+if __name__ == '__main__':
+    unittest.main()

Shared/lib/python2.7/site-packages/tornado/test/static/dir/index.html

@@ -0,0 +1 @@
+this is the index

Shared/lib/python2.7/site-packages/tornado/test/static/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

Shared/lib/python2.7/site-packages/tornado/test/template_test.py

@@ -0,0 +1,391 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import os
+import sys
+import traceback
+
+from tornado.escape import utf8, native_str, to_unicode
+from tornado.template import Template, DictLoader, ParseError, Loader
+from tornado.test.util import unittest
+from tornado.util import u, bytes_type, ObjectDict, unicode_type
+
+
+class TemplateTest(unittest.TestCase):
+    def test_simple(self):
+        template = Template("Hello {{ name }}!")
+        self.assertEqual(template.generate(name="Ben"),
+                         b"Hello Ben!")
+
+    def test_bytes(self):
+        template = Template("Hello {{ name }}!")
+        self.assertEqual(template.generate(name=utf8("Ben")),
+                         b"Hello Ben!")
+
+    def test_expressions(self):
+        template = Template("2 + 2 = {{ 2 + 2 }}")
+        self.assertEqual(template.generate(), b"2 + 2 = 4")
+
+    def test_comment(self):
+        template = Template("Hello{# TODO i18n #} {{ name }}!")
+        self.assertEqual(template.generate(name=utf8("Ben")),
+                         b"Hello Ben!")
+
+    def test_include(self):
+        loader = DictLoader({
+            "index.html": '{% include "header.html" %}\nbody text',
+            "header.html": "header text",
+        })
+        self.assertEqual(loader.load("index.html").generate(),
+                         b"header text\nbody text")
+
+    def test_extends(self):
+        loader = DictLoader({
+            "base.html": """\
+<title>{% block title %}default title{% end %}</title>
+<body>{% block body %}default body{% end %}</body>
+""",
+            "page.html": """\
+{% extends "base.html" %}
+{% block title %}page title{% end %}
+{% block body %}page body{% end %}
+""",
+        })
+        self.assertEqual(loader.load("page.html").generate(),
+                         b"<title>page title</title>\n<body>page body</body>\n")
+
+    def test_relative_load(self):
+        loader = DictLoader({
+            "a/1.html": "{% include '2.html' %}",
+            "a/2.html": "{% include '../b/3.html' %}",
+            "b/3.html": "ok",
+        })
+        self.assertEqual(loader.load("a/1.html").generate(),
+                         b"ok")
+
+    def test_escaping(self):
+        self.assertRaises(ParseError, lambda: Template("{{"))
+        self.assertRaises(ParseError, lambda: Template("{%"))
+        self.assertEqual(Template("{{!").generate(), b"{{")
+        self.assertEqual(Template("{%!").generate(), b"{%")
+        self.assertEqual(Template("{{ 'expr' }} {{!jquery expr}}").generate(),
+                         b"expr {{jquery expr}}")
+
+    def test_unicode_template(self):
+        template = Template(utf8(u("\u00e9")))
+        self.assertEqual(template.generate(), utf8(u("\u00e9")))
+
+    def test_unicode_literal_expression(self):
+        # Unicode literals should be usable in templates.  Note that this
+        # test simulates unicode characters appearing directly in the
+        # template file (with utf8 encoding), i.e. \u escapes would not
+        # be used in the template file itself.
+        if str is unicode_type:
+            # python 3 needs a different version of this test since
+            # 2to3 doesn't run on template internals
+            template = Template(utf8(u('{{ "\u00e9" }}')))
+        else:
+            template = Template(utf8(u('{{ u"\u00e9" }}')))
+        self.assertEqual(template.generate(), utf8(u("\u00e9")))
+
+    def test_custom_namespace(self):
+        loader = DictLoader({"test.html": "{{ inc(5) }}"}, namespace={"inc": lambda x: x + 1})
+        self.assertEqual(loader.load("test.html").generate(), b"6")
+
+    def test_apply(self):
+        def upper(s):
+            return s.upper()
+        template = Template(utf8("{% apply upper %}foo{% end %}"))
+        self.assertEqual(template.generate(upper=upper), b"FOO")
+
+    def test_unicode_apply(self):
+        def upper(s):
+            return to_unicode(s).upper()
+        template = Template(utf8(u("{% apply upper %}foo \u00e9{% end %}")))
+        self.assertEqual(template.generate(upper=upper), utf8(u("FOO \u00c9")))
+
+    def test_bytes_apply(self):
+        def upper(s):
+            return utf8(to_unicode(s).upper())
+        template = Template(utf8(u("{% apply upper %}foo \u00e9{% end %}")))
+        self.assertEqual(template.generate(upper=upper), utf8(u("FOO \u00c9")))
+
+    def test_if(self):
+        template = Template(utf8("{% if x > 4 %}yes{% else %}no{% end %}"))
+        self.assertEqual(template.generate(x=5), b"yes")
+        self.assertEqual(template.generate(x=3), b"no")
+
+    def test_if_empty_body(self):
+        template = Template(utf8("{% if True %}{% else %}{% end %}"))
+        self.assertEqual(template.generate(), b"")
+
+    def test_try(self):
+        template = Template(utf8("""{% try %}
+try{% set y = 1/x %}
+{% except %}-except
+{% else %}-else
+{% finally %}-finally
+{% end %}"""))
+        self.assertEqual(template.generate(x=1), b"\ntry\n-else\n-finally\n")
+        self.assertEqual(template.generate(x=0), b"\ntry-except\n-finally\n")
+
+    def test_comment_directive(self):
+        template = Template(utf8("{% comment blah blah %}foo"))
+        self.assertEqual(template.generate(), b"foo")
+
+    def test_break_continue(self):
+        template = Template(utf8("""\
+{% for i in range(10) %}
+    {% if i == 2 %}
+        {% continue %}
+    {% end %}
+    {{ i }}
+    {% if i == 6 %}
+        {% break %}
+    {% end %}
+{% end %}"""))
+        result = template.generate()
+        # remove extraneous whitespace
+        result = b''.join(result.split())
+        self.assertEqual(result, b"013456")
+
+    def test_break_outside_loop(self):
+        try:
+            Template(utf8("{% break %}"))
+            raise Exception("Did not get expected exception")
+        except ParseError:
+            pass
+
+    def test_break_in_apply(self):
+        # This test verifies current behavior, although of course it would
+        # be nice if apply didn't cause seemingly unrelated breakage
+        try:
+            Template(utf8("{% for i in [] %}{% apply foo %}{% break %}{% end %}{% end %}"))
+            raise Exception("Did not get expected exception")
+        except ParseError:
+            pass
+
+    @unittest.skipIf(sys.version_info >= division.getMandatoryRelease(),
+                     'no testable future imports')
+    def test_no_inherit_future(self):
+        # This file has from __future__ import division...
+        self.assertEqual(1 / 2, 0.5)
+        # ...but the template doesn't
+        template = Template('{{ 1 / 2 }}')
+        self.assertEqual(template.generate(), '0')
+
+
+class StackTraceTest(unittest.TestCase):
+    def test_error_line_number_expression(self):
+        loader = DictLoader({"test.html": """one
+two{{1/0}}
+three
+        """})
+        try:
+            loader.load("test.html").generate()
+        except ZeroDivisionError:
+            self.assertTrue("# test.html:2" in traceback.format_exc())
+
+    def test_error_line_number_directive(self):
+        loader = DictLoader({"test.html": """one
+two{%if 1/0%}
+three{%end%}
+        """})
+        try:
+            loader.load("test.html").generate()
+        except ZeroDivisionError:
+            self.assertTrue("# test.html:2" in traceback.format_exc())
+
+    def test_error_line_number_module(self):
+        loader = DictLoader({
+            "base.html": "{% module Template('sub.html') %}",
+            "sub.html": "{{1/0}}",
+        }, namespace={"_tt_modules": ObjectDict({"Template": lambda path, **kwargs: loader.load(path).generate(**kwargs)})})
+        try:
+            loader.load("base.html").generate()
+        except ZeroDivisionError:
+            exc_stack = traceback.format_exc()
+            self.assertTrue('# base.html:1' in exc_stack)
+            self.assertTrue('# sub.html:1' in exc_stack)
+
+    def test_error_line_number_include(self):
+        loader = DictLoader({
+            "base.html": "{% include 'sub.html' %}",
+            "sub.html": "{{1/0}}",
+        })
+        try:
+            loader.load("base.html").generate()
+        except ZeroDivisionError:
+            self.assertTrue("# sub.html:1 (via base.html:1)" in
+                            traceback.format_exc())
+
+    def test_error_line_number_extends_base_error(self):
+        loader = DictLoader({
+            "base.html": "{{1/0}}",
+            "sub.html": "{% extends 'base.html' %}",
+        })
+        try:
+            loader.load("sub.html").generate()
+        except ZeroDivisionError:
+            exc_stack = traceback.format_exc()
+        self.assertTrue("# base.html:1" in exc_stack)
+
+    def test_error_line_number_extends_sub_error(self):
+        loader = DictLoader({
+            "base.html": "{% block 'block' %}{% end %}",
+            "sub.html": """
+{% extends 'base.html' %}
+{% block 'block' %}
+{{1/0}}
+{% end %}
+            """})
+        try:
+            loader.load("sub.html").generate()
+        except ZeroDivisionError:
+            self.assertTrue("# sub.html:4 (via base.html:1)" in
+                            traceback.format_exc())
+
+    def test_multi_includes(self):
+        loader = DictLoader({
+            "a.html": "{% include 'b.html' %}",
+            "b.html": "{% include 'c.html' %}",
+            "c.html": "{{1/0}}",
+        })
+        try:
+            loader.load("a.html").generate()
+        except ZeroDivisionError:
+            self.assertTrue("# c.html:1 (via b.html:1, a.html:1)" in
+                            traceback.format_exc())
+
+
+class AutoEscapeTest(unittest.TestCase):
+    def setUp(self):
+        self.templates = {
+            "escaped.html": "{% autoescape xhtml_escape %}{{ name }}",
+            "unescaped.html": "{% autoescape None %}{{ name }}",
+            "default.html": "{{ name }}",
+
+            "include.html": """\
+escaped: {% include 'escaped.html' %}
+unescaped: {% include 'unescaped.html' %}
+default: {% include 'default.html' %}
+""",
+
+            "escaped_block.html": """\
+{% autoescape xhtml_escape %}\
+{% block name %}base: {{ name }}{% end %}""",
+            "unescaped_block.html": """\
+{% autoescape None %}\
+{% block name %}base: {{ name }}{% end %}""",
+
+            # Extend a base template with different autoescape policy,
+            # with and without overriding the base's blocks
+            "escaped_extends_unescaped.html": """\
+{% autoescape xhtml_escape %}\
+{% extends "unescaped_block.html" %}""",
+            "escaped_overrides_unescaped.html": """\
+{% autoescape xhtml_escape %}\
+{% extends "unescaped_block.html" %}\
+{% block name %}extended: {{ name }}{% end %}""",
+            "unescaped_extends_escaped.html": """\
+{% autoescape None %}\
+{% extends "escaped_block.html" %}""",
+            "unescaped_overrides_escaped.html": """\
+{% autoescape None %}\
+{% extends "escaped_block.html" %}\
+{% block name %}extended: {{ name }}{% end %}""",
+
+            "raw_expression.html": """\
+{% autoescape xhtml_escape %}\
+expr: {{ name }}
+raw: {% raw name %}""",
+        }
+
+    def test_default_off(self):
+        loader = DictLoader(self.templates, autoescape=None)
+        name = "Bobby <table>s"
+        self.assertEqual(loader.load("escaped.html").generate(name=name),
+                         b"Bobby &lt;table&gt;s")
+        self.assertEqual(loader.load("unescaped.html").generate(name=name),
+                         b"Bobby <table>s")
+        self.assertEqual(loader.load("default.html").generate(name=name),
+                         b"Bobby <table>s")
+
+        self.assertEqual(loader.load("include.html").generate(name=name),
+                         b"escaped: Bobby &lt;table&gt;s\n"
+                         b"unescaped: Bobby <table>s\n"
+                         b"default: Bobby <table>s\n")
+
+    def test_default_on(self):
+        loader = DictLoader(self.templates, autoescape="xhtml_escape")
+        name = "Bobby <table>s"
+        self.assertEqual(loader.load("escaped.html").generate(name=name),
+                         b"Bobby &lt;table&gt;s")
+        self.assertEqual(loader.load("unescaped.html").generate(name=name),
+                         b"Bobby <table>s")
+        self.assertEqual(loader.load("default.html").generate(name=name),
+                         b"Bobby &lt;table&gt;s")
+
+        self.assertEqual(loader.load("include.html").generate(name=name),
+                         b"escaped: Bobby &lt;table&gt;s\n"
+                         b"unescaped: Bobby <table>s\n"
+                         b"default: Bobby &lt;table&gt;s\n")
+
+    def test_unextended_block(self):
+        loader = DictLoader(self.templates)
+        name = "<script>"
+        self.assertEqual(loader.load("escaped_block.html").generate(name=name),
+                         b"base: &lt;script&gt;")
+        self.assertEqual(loader.load("unescaped_block.html").generate(name=name),
+                         b"base: <script>")
+
+    def test_extended_block(self):
+        loader = DictLoader(self.templates)
+
+        def render(name):
+            return loader.load(name).generate(name="<script>")
+        self.assertEqual(render("escaped_extends_unescaped.html"),
+                         b"base: <script>")
+        self.assertEqual(render("escaped_overrides_unescaped.html"),
+                         b"extended: &lt;script&gt;")
+
+        self.assertEqual(render("unescaped_extends_escaped.html"),
+                         b"base: &lt;script&gt;")
+        self.assertEqual(render("unescaped_overrides_escaped.html"),
+                         b"extended: <script>")
+
+    def test_raw_expression(self):
+        loader = DictLoader(self.templates)
+
+        def render(name):
+            return loader.load(name).generate(name='<>&"')
+        self.assertEqual(render("raw_expression.html"),
+                         b"expr: &lt;&gt;&amp;&quot;\n"
+                         b"raw: <>&\"")
+
+    def test_custom_escape(self):
+        loader = DictLoader({"foo.py":
+                             "{% autoescape py_escape %}s = {{ name }}\n"})
+
+        def py_escape(s):
+            self.assertEqual(type(s), bytes_type)
+            return repr(native_str(s))
+
+        def render(template, name):
+            return loader.load(template).generate(py_escape=py_escape,
+                                                  name=name)
+        self.assertEqual(render("foo.py", "<html>"),
+                         b"s = '<html>'\n")
+        self.assertEqual(render("foo.py", "';sys.exit()"),
+                         b"""s = "';sys.exit()"\n""")
+        self.assertEqual(render("foo.py", ["not a string"]),
+                         b"""s = "['not a string']"\n""")
+
+
+class TemplateLoaderTest(unittest.TestCase):
+    def setUp(self):
+        self.loader = Loader(os.path.join(os.path.dirname(__file__), "templates"))
+
+    def test_utf8_in_file(self):
+        tmpl = self.loader.load("utf8.html")
+        result = tmpl.generate()
+        self.assertEqual(to_unicode(result).strip(), u("H\u00e9llo"))

Shared/lib/python2.7/site-packages/tornado/test/templates/utf8.html

@@ -0,0 +1 @@
+Héllo

Shared/lib/python2.7/site-packages/tornado/test/test.crt

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICSDCCAbGgAwIBAgIJAN1oTowzMbkzMA0GCSqGSIb3DQEBBQUAMD0xCzAJBgNV
+BAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRkwFwYDVQQKDBBUb3JuYWRvIFdl
+YiBUZXN0MB4XDTEwMDgyNTE4MjQ0NFoXDTIwMDgyMjE4MjQ0NFowPTELMAkGA1UE
+BhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExGTAXBgNVBAoMEFRvcm5hZG8gV2Vi
+IFRlc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALirW3mX4jbdFse2aZwW
+zszCJ1IsRDrzALpbvMYLLbIZqo+Z8v5aERKTRQpXFqGaZyY+tdwYy7X7YXcLtKqv
+jnw/MSeIaqkw5pROKz5aR0nkPLvcTmhJVLVPCLc8dFnIlu8aC9TrDhr90P+PzU39
+UG7zLweA9zXKBuW3Tjo5dMP3AgMBAAGjUDBOMB0GA1UdDgQWBBRhJjMBYrzddCFr
+/0vvPyHMeqgo0TAfBgNVHSMEGDAWgBRhJjMBYrzddCFr/0vvPyHMeqgo0TAMBgNV
+HRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAGP6GaxSfb21bikcqaK3ZKCC1sRJ
+tiCuvJZbBUFUCAzl05dYUfJZim/oWK+GqyUkUB8ciYivUNnn9OtS7DnlTgT2ws2e
+lNgn5cuFXoAGcHXzVlHG3yoywYBf3y0Dn20uzrlLXUWJAzoSLOt2LTaXvwlgm7hF
+W1q8SQ6UBshRw2X0
+-----END CERTIFICATE-----

Shared/lib/python2.7/site-packages/tornado/test/test.key

@@ -0,0 +1,16 @@
+-----BEGIN PRIVATE KEY-----
+MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALirW3mX4jbdFse2
+aZwWzszCJ1IsRDrzALpbvMYLLbIZqo+Z8v5aERKTRQpXFqGaZyY+tdwYy7X7YXcL
+tKqvjnw/MSeIaqkw5pROKz5aR0nkPLvcTmhJVLVPCLc8dFnIlu8aC9TrDhr90P+P
+zU39UG7zLweA9zXKBuW3Tjo5dMP3AgMBAAECgYEAiygNaWYrf95AcUQi9w00zpUr
+nj9fNvCwxr2kVbRMvd2balS/CC4EmXPCXdVcZ3B7dBVjYzSIJV0Fh/iZLtnVysD9
+fcNMZ+Cz71b/T0ItsNYOsJk0qUVyP52uqsqkNppIPJsD19C+ZeMLZj6iEiylZyl8
+2U16c/kVIjER63mUEGkCQQDayQOTGPJrKHqPAkUqzeJkfvHH2yCf+cySU+w6ezyr
+j9yxcq8aZoLusCebDVT+kz7RqnD5JePFvB38cMuepYBLAkEA2BTFdZx30f4moPNv
+JlXlPNJMUTUzsXG7n4vNc+18O5ous0NGQII8jZWrIcTrP8wiP9fF3JwUsKrJhcBn
+xRs3hQJBAIDUgz1YIE+HW3vgi1gkOh6RPdBAsVpiXtr/fggFz3j60qrO7FswaAMj
+SX8c/6KUlBYkNjgP3qruFf4zcUNvEzcCQQCaioCPFVE9ByBpjLG6IUTKsz2R9xL5
+nfYqrbpLZ1aq6iLsYvkjugHE4X57sHLwNfdo4dHJbnf9wqhO2MVe25BhAkBdKYpY
+7OKc/2mmMbJDhVBgoixz/muN/5VjdfbvVY48naZkJF1p1tmogqPC5F1jPCS4rM+S
+FfPJIHRNEn2oktw5
+-----END PRIVATE KEY-----

Shared/lib/python2.7/site-packages/tornado/test/testing_test.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+from __future__ import absolute_import, division, print_function, with_statement
+
+from tornado import gen, ioloop
+from tornado.testing import AsyncTestCase, gen_test
+from tornado.test.util import unittest
+
+import contextlib
+import os
+
+
+@contextlib.contextmanager
+def set_environ(name, value):
+    old_value = os.environ.get('name')
+    os.environ[name] = value
+
+    try:
+        yield
+    finally:
+        if old_value is None:
+            del os.environ[name]
+        else:
+            os.environ[name] = old_value
+
+
+class AsyncTestCaseTest(AsyncTestCase):
+    def test_exception_in_callback(self):
+        self.io_loop.add_callback(lambda: 1 / 0)
+        try:
+            self.wait()
+            self.fail("did not get expected exception")
+        except ZeroDivisionError:
+            pass
+
+    def test_wait_timeout(self):
+        time = self.io_loop.time
+
+        # Accept default 5-second timeout, no error
+        self.io_loop.add_timeout(time() + 0.01, self.stop)
+        self.wait()
+
+        # Timeout passed to wait()
+        self.io_loop.add_timeout(time() + 1, self.stop)
+        with self.assertRaises(self.failureException):
+            self.wait(timeout=0.01)
+
+        # Timeout set with environment variable
+        self.io_loop.add_timeout(time() + 1, self.stop)
+        with set_environ('ASYNC_TEST_TIMEOUT', '0.01'):
+            with self.assertRaises(self.failureException):
+                self.wait()
+
+    def test_subsequent_wait_calls(self):
+        """
+        This test makes sure that a second call to wait()
+        clears the first timeout.
+        """
+        self.io_loop.add_timeout(self.io_loop.time() + 0.01, self.stop)
+        self.wait(timeout=0.02)
+        self.io_loop.add_timeout(self.io_loop.time() + 0.03, self.stop)
+        self.wait(timeout=0.15)
+
+
+class SetUpTearDownTest(unittest.TestCase):
+    def test_set_up_tear_down(self):
+        """
+        This test makes sure that AsyncTestCase calls super methods for
+        setUp and tearDown.
+
+        InheritBoth is a subclass of both AsyncTestCase and
+        SetUpTearDown, with the ordering so that the super of
+        AsyncTestCase will be SetUpTearDown.
+        """
+        events = []
+        result = unittest.TestResult()
+
+        class SetUpTearDown(unittest.TestCase):
+            def setUp(self):
+                events.append('setUp')
+
+            def tearDown(self):
+                events.append('tearDown')
+
+        class InheritBoth(AsyncTestCase, SetUpTearDown):
+            def test(self):
+                events.append('test')
+
+        InheritBoth('test').run(result)
+        expected = ['setUp', 'test', 'tearDown']
+        self.assertEqual(expected, events)
+
+
+class GenTest(AsyncTestCase):
+    def setUp(self):
+        super(GenTest, self).setUp()
+        self.finished = False
+
+    def tearDown(self):
+        self.assertTrue(self.finished)
+        super(GenTest, self).tearDown()
+
+    @gen_test
+    def test_sync(self):
+        self.finished = True
+
+    @gen_test
+    def test_async(self):
+        yield gen.Task(self.io_loop.add_callback)
+        self.finished = True
+
+    def test_timeout(self):
+        # Set a short timeout and exceed it.
+        @gen_test(timeout=0.1)
+        def test(self):
+            yield gen.Task(self.io_loop.add_timeout, self.io_loop.time() + 1)
+
+        with self.assertRaises(ioloop.TimeoutError):
+            test(self)
+
+        self.finished = True
+
+    def test_no_timeout(self):
+        # A test that does not exceed its timeout should succeed.
+        @gen_test(timeout=1)
+        def test(self):
+            time = self.io_loop.time
+            yield gen.Task(self.io_loop.add_timeout, time() + 0.1)
+
+        test(self)
+        self.finished = True
+
+    def test_timeout_environment_variable(self):
+        @gen_test(timeout=0.5)
+        def test_long_timeout(self):
+            time = self.io_loop.time
+            yield gen.Task(self.io_loop.add_timeout, time() + 0.25)
+
+        # Uses provided timeout of 0.5 seconds, doesn't time out.
+        with set_environ('ASYNC_TEST_TIMEOUT', '0.1'):
+            test_long_timeout(self)
+
+        self.finished = True
+
+    def test_no_timeout_environment_variable(self):
+        @gen_test(timeout=0.01)
+        def test_short_timeout(self):
+            time = self.io_loop.time
+            yield gen.Task(self.io_loop.add_timeout, time() + 1)
+
+        # Uses environment-variable timeout of 0.1, times out.
+        with set_environ('ASYNC_TEST_TIMEOUT', '0.1'):
+            with self.assertRaises(ioloop.TimeoutError):
+                test_short_timeout(self)
+
+        self.finished = True
+
+if __name__ == '__main__':
+    unittest.main()

Shared/lib/python2.7/site-packages/tornado/test/twisted_test.py

@@ -0,0 +1,615 @@
+# Author: Ovidiu Predescu
+# Date: July 2011
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Unittest for the twisted-style reactor.
+"""
+
+from __future__ import absolute_import, division, print_function, with_statement
+
+import os
+import shutil
+import signal
+import tempfile
+import threading
+
+try:
+    import fcntl
+    from twisted.internet.defer import Deferred
+    from twisted.internet.interfaces import IReadDescriptor, IWriteDescriptor
+    from twisted.internet.protocol import Protocol
+    from twisted.python import log
+    from tornado.platform.twisted import TornadoReactor, TwistedIOLoop
+    from zope.interface import implementer
+    have_twisted = True
+except ImportError:
+    have_twisted = False
+
+# The core of Twisted 12.3.0 is available on python 3, but twisted.web is not
+# so test for it separately.
+try:
+    from twisted.web.client import Agent
+    from twisted.web.resource import Resource
+    from twisted.web.server import Site
+    have_twisted_web = True
+except ImportError:
+    have_twisted_web = False
+
+try:
+    import thread  # py2
+except ImportError:
+    import _thread as thread  # py3
+
+from tornado.httpclient import AsyncHTTPClient
+from tornado.httpserver import HTTPServer
+from tornado.ioloop import IOLoop
+from tornado.platform.auto import set_close_exec
+from tornado.platform.select import SelectIOLoop
+from tornado.testing import bind_unused_port
+from tornado.test.util import unittest
+from tornado.util import import_object
+from tornado.web import RequestHandler, Application
+
+skipIfNoTwisted = unittest.skipUnless(have_twisted,
+                                      "twisted module not present")
+
+
+def save_signal_handlers():
+    saved = {}
+    for sig in [signal.SIGINT, signal.SIGTERM, signal.SIGCHLD]:
+        saved[sig] = signal.getsignal(sig)
+    if "twisted" in repr(saved):
+        if not issubclass(IOLoop.configured_class(), TwistedIOLoop):
+            # when the global ioloop is twisted, we expect the signal
+            # handlers to be installed.  Otherwise, it means we're not
+            # cleaning up after twisted properly.
+            raise Exception("twisted signal handlers already installed")
+    return saved
+
+
+def restore_signal_handlers(saved):
+    for sig, handler in saved.items():
+        signal.signal(sig, handler)
+
+
+class ReactorTestCase(unittest.TestCase):
+    def setUp(self):
+        self._saved_signals = save_signal_handlers()
+        self._io_loop = IOLoop()
+        self._reactor = TornadoReactor(self._io_loop)
+
+    def tearDown(self):
+        self._io_loop.close(all_fds=True)
+        restore_signal_handlers(self._saved_signals)
+
+
+@skipIfNoTwisted
+class ReactorWhenRunningTest(ReactorTestCase):
+    def test_whenRunning(self):
+        self._whenRunningCalled = False
+        self._anotherWhenRunningCalled = False
+        self._reactor.callWhenRunning(self.whenRunningCallback)
+        self._reactor.run()
+        self.assertTrue(self._whenRunningCalled)
+        self.assertTrue(self._anotherWhenRunningCalled)
+
+    def whenRunningCallback(self):
+        self._whenRunningCalled = True
+        self._reactor.callWhenRunning(self.anotherWhenRunningCallback)
+        self._reactor.stop()
+
+    def anotherWhenRunningCallback(self):
+        self._anotherWhenRunningCalled = True
+
+
+@skipIfNoTwisted
+class ReactorCallLaterTest(ReactorTestCase):
+    def test_callLater(self):
+        self._laterCalled = False
+        self._now = self._reactor.seconds()
+        self._timeout = 0.001
+        dc = self._reactor.callLater(self._timeout, self.callLaterCallback)
+        self.assertEqual(self._reactor.getDelayedCalls(), [dc])
+        self._reactor.run()
+        self.assertTrue(self._laterCalled)
+        self.assertTrue(self._called - self._now > self._timeout)
+        self.assertEqual(self._reactor.getDelayedCalls(), [])
+
+    def callLaterCallback(self):
+        self._laterCalled = True
+        self._called = self._reactor.seconds()
+        self._reactor.stop()
+
+
+@skipIfNoTwisted
+class ReactorTwoCallLaterTest(ReactorTestCase):
+    def test_callLater(self):
+        self._later1Called = False
+        self._later2Called = False
+        self._now = self._reactor.seconds()
+        self._timeout1 = 0.0005
+        dc1 = self._reactor.callLater(self._timeout1, self.callLaterCallback1)
+        self._timeout2 = 0.001
+        dc2 = self._reactor.callLater(self._timeout2, self.callLaterCallback2)
+        self.assertTrue(self._reactor.getDelayedCalls() == [dc1, dc2] or
+                        self._reactor.getDelayedCalls() == [dc2, dc1])
+        self._reactor.run()
+        self.assertTrue(self._later1Called)
+        self.assertTrue(self._later2Called)
+        self.assertTrue(self._called1 - self._now > self._timeout1)
+        self.assertTrue(self._called2 - self._now > self._timeout2)
+        self.assertEqual(self._reactor.getDelayedCalls(), [])
+
+    def callLaterCallback1(self):
+        self._later1Called = True
+        self._called1 = self._reactor.seconds()
+
+    def callLaterCallback2(self):
+        self._later2Called = True
+        self._called2 = self._reactor.seconds()
+        self._reactor.stop()
+
+
+@skipIfNoTwisted
+class ReactorCallFromThreadTest(ReactorTestCase):
+    def setUp(self):
+        super(ReactorCallFromThreadTest, self).setUp()
+        self._mainThread = thread.get_ident()
+
+    def tearDown(self):
+        self._thread.join()
+        super(ReactorCallFromThreadTest, self).tearDown()
+
+    def _newThreadRun(self):
+        self.assertNotEqual(self._mainThread, thread.get_ident())
+        if hasattr(self._thread, 'ident'):  # new in python 2.6
+            self.assertEqual(self._thread.ident, thread.get_ident())
+        self._reactor.callFromThread(self._fnCalledFromThread)
+
+    def _fnCalledFromThread(self):
+        self.assertEqual(self._mainThread, thread.get_ident())
+        self._reactor.stop()
+
+    def _whenRunningCallback(self):
+        self._thread = threading.Thread(target=self._newThreadRun)
+        self._thread.start()
+
+    def testCallFromThread(self):
+        self._reactor.callWhenRunning(self._whenRunningCallback)
+        self._reactor.run()
+
+
+@skipIfNoTwisted
+class ReactorCallInThread(ReactorTestCase):
+    def setUp(self):
+        super(ReactorCallInThread, self).setUp()
+        self._mainThread = thread.get_ident()
+
+    def _fnCalledInThread(self, *args, **kwargs):
+        self.assertNotEqual(thread.get_ident(), self._mainThread)
+        self._reactor.callFromThread(lambda: self._reactor.stop())
+
+    def _whenRunningCallback(self):
+        self._reactor.callInThread(self._fnCalledInThread)
+
+    def testCallInThread(self):
+        self._reactor.callWhenRunning(self._whenRunningCallback)
+        self._reactor.run()
+
+
+class Reader(object):
+    def __init__(self, fd, callback):
+        self._fd = fd
+        self._callback = callback
+
+    def logPrefix(self):
+        return "Reader"
+
+    def close(self):
+        self._fd.close()
+
+    def fileno(self):
+        return self._fd.fileno()
+
+    def readConnectionLost(self, reason):
+        self.close()
+
+    def connectionLost(self, reason):
+        self.close()
+
+    def doRead(self):
+        self._callback(self._fd)
+if have_twisted:
+    Reader = implementer(IReadDescriptor)(Reader)
+
+
+class Writer(object):
+    def __init__(self, fd, callback):
+        self._fd = fd
+        self._callback = callback
+
+    def logPrefix(self):
+        return "Writer"
+
+    def close(self):
+        self._fd.close()
+
+    def fileno(self):
+        return self._fd.fileno()
+
+    def connectionLost(self, reason):
+        self.close()
+
+    def doWrite(self):
+        self._callback(self._fd)
+if have_twisted:
+    Writer = implementer(IWriteDescriptor)(Writer)
+
+
+@skipIfNoTwisted
+class ReactorReaderWriterTest(ReactorTestCase):
+    def _set_nonblocking(self, fd):
+        flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+        fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+    def setUp(self):
+        super(ReactorReaderWriterTest, self).setUp()
+        r, w = os.pipe()
+        self._set_nonblocking(r)
+        self._set_nonblocking(w)
+        set_close_exec(r)
+        set_close_exec(w)
+        self._p1 = os.fdopen(r, "rb", 0)
+        self._p2 = os.fdopen(w, "wb", 0)
+
+    def tearDown(self):
+        super(ReactorReaderWriterTest, self).tearDown()
+        self._p1.close()
+        self._p2.close()
+
+    def _testReadWrite(self):
+        """
+        In this test the writer writes an 'x' to its fd. The reader
+        reads it, check the value and ends the test.
+        """
+        self.shouldWrite = True
+
+        def checkReadInput(fd):
+            self.assertEquals(fd.read(1), b'x')
+            self._reactor.stop()
+
+        def writeOnce(fd):
+            if self.shouldWrite:
+                self.shouldWrite = False
+                fd.write(b'x')
+        self._reader = Reader(self._p1, checkReadInput)
+        self._writer = Writer(self._p2, writeOnce)
+
+        self._reactor.addWriter(self._writer)
+
+        # Test that adding the reader twice adds it only once to
+        # IOLoop.
+        self._reactor.addReader(self._reader)
+        self._reactor.addReader(self._reader)
+
+    def testReadWrite(self):
+        self._reactor.callWhenRunning(self._testReadWrite)
+        self._reactor.run()
+
+    def _testNoWriter(self):
+        """
+        In this test we have no writer. Make sure the reader doesn't
+        read anything.
+        """
+        def checkReadInput(fd):
+            self.fail("Must not be called.")
+
+        def stopTest():
+            # Close the writer here since the IOLoop doesn't know
+            # about it.
+            self._writer.close()
+            self._reactor.stop()
+        self._reader = Reader(self._p1, checkReadInput)
+
+        # We create a writer, but it should never be invoked.
+        self._writer = Writer(self._p2, lambda fd: fd.write('x'))
+
+        # Test that adding and removing the writer leaves us with no writer.
+        self._reactor.addWriter(self._writer)
+        self._reactor.removeWriter(self._writer)
+
+        # Test that adding and removing the reader doesn't cause
+        # unintended effects.
+        self._reactor.addReader(self._reader)
+
+        # Wake up after a moment and stop the test
+        self._reactor.callLater(0.001, stopTest)
+
+    def testNoWriter(self):
+        self._reactor.callWhenRunning(self._testNoWriter)
+        self._reactor.run()
+
+# Test various combinations of twisted and tornado http servers,
+# http clients, and event loop interfaces.
+
+
+@skipIfNoTwisted
+@unittest.skipIf(not have_twisted_web, 'twisted web not present')
+class CompatibilityTests(unittest.TestCase):
+    def setUp(self):
+        self.saved_signals = save_signal_handlers()
+        self.io_loop = IOLoop()
+        self.io_loop.make_current()
+        self.reactor = TornadoReactor(self.io_loop)
+
+    def tearDown(self):
+        self.reactor.disconnectAll()
+        self.io_loop.clear_current()
+        self.io_loop.close(all_fds=True)
+        restore_signal_handlers(self.saved_signals)
+
+    def start_twisted_server(self):
+        class HelloResource(Resource):
+            isLeaf = True
+
+            def render_GET(self, request):
+                return "Hello from twisted!"
+        site = Site(HelloResource())
+        port = self.reactor.listenTCP(0, site, interface='127.0.0.1')
+        self.twisted_port = port.getHost().port
+
+    def start_tornado_server(self):
+        class HelloHandler(RequestHandler):
+            def get(self):
+                self.write("Hello from tornado!")
+        app = Application([('/', HelloHandler)],
+                          log_function=lambda x: None)
+        server = HTTPServer(app, io_loop=self.io_loop)
+        sock, self.tornado_port = bind_unused_port()
+        server.add_sockets([sock])
+
+    def run_ioloop(self):
+        self.stop_loop = self.io_loop.stop
+        self.io_loop.start()
+        self.reactor.fireSystemEvent('shutdown')
+
+    def run_reactor(self):
+        self.stop_loop = self.reactor.stop
+        self.stop = self.reactor.stop
+        self.reactor.run()
+
+    def tornado_fetch(self, url, runner):
+        responses = []
+        client = AsyncHTTPClient(self.io_loop)
+
+        def callback(response):
+            responses.append(response)
+            self.stop_loop()
+        client.fetch(url, callback=callback)
+        runner()
+        self.assertEqual(len(responses), 1)
+        responses[0].rethrow()
+        return responses[0]
+
+    def twisted_fetch(self, url, runner):
+        # http://twistedmatrix.com/documents/current/web/howto/client.html
+        chunks = []
+        client = Agent(self.reactor)
+        d = client.request('GET', url)
+
+        class Accumulator(Protocol):
+            def __init__(self, finished):
+                self.finished = finished
+
+            def dataReceived(self, data):
+                chunks.append(data)
+
+            def connectionLost(self, reason):
+                self.finished.callback(None)
+
+        def callback(response):
+            finished = Deferred()
+            response.deliverBody(Accumulator(finished))
+            return finished
+        d.addCallback(callback)
+
+        def shutdown(ignored):
+            self.stop_loop()
+        d.addBoth(shutdown)
+        runner()
+        self.assertTrue(chunks)
+        return ''.join(chunks)
+
+    def testTwistedServerTornadoClientIOLoop(self):
+        self.start_twisted_server()
+        response = self.tornado_fetch(
+            'http://localhost:%d' % self.twisted_port, self.run_ioloop)
+        self.assertEqual(response.body, 'Hello from twisted!')
+
+    def testTwistedServerTornadoClientReactor(self):
+        self.start_twisted_server()
+        response = self.tornado_fetch(
+            'http://localhost:%d' % self.twisted_port, self.run_reactor)
+        self.assertEqual(response.body, 'Hello from twisted!')
+
+    def testTornadoServerTwistedClientIOLoop(self):
+        self.start_tornado_server()
+        response = self.twisted_fetch(
+            'http://localhost:%d' % self.tornado_port, self.run_ioloop)
+        self.assertEqual(response, 'Hello from tornado!')
+
+    def testTornadoServerTwistedClientReactor(self):
+        self.start_tornado_server()
+        response = self.twisted_fetch(
+            'http://localhost:%d' % self.tornado_port, self.run_reactor)
+        self.assertEqual(response, 'Hello from tornado!')
+
+
+if have_twisted:
+    # Import and run as much of twisted's test suite as possible.
+    # This is unfortunately rather dependent on implementation details,
+    # but there doesn't appear to be a clean all-in-one conformance test
+    # suite for reactors.
+    #
+    # This is a list of all test suites using the ReactorBuilder
+    # available in Twisted 11.0.0 and 11.1.0 (and a blacklist of
+    # specific test methods to be disabled).
+    twisted_tests = {
+        'twisted.internet.test.test_core.ObjectModelIntegrationTest': [],
+        'twisted.internet.test.test_core.SystemEventTestsBuilder': [
+            'test_iterate',  # deliberately not supported
+            'test_runAfterCrash',  # fails because TwistedIOLoop uses the global reactor
+        ] if issubclass(IOLoop.configured_class(), TwistedIOLoop) else [
+            'test_iterate',  # deliberately not supported
+        ],
+        'twisted.internet.test.test_fdset.ReactorFDSetTestsBuilder': [
+            "test_lostFileDescriptor",  # incompatible with epoll and kqueue
+        ],
+        'twisted.internet.test.test_process.ProcessTestsBuilder': [
+        ],
+        # Process tests appear to work on OSX 10.7, but not 10.6
+        #'twisted.internet.test.test_process.PTYProcessTestsBuilder': [
+        #    'test_systemCallUninterruptedByChildExit',
+        #    ],
+        'twisted.internet.test.test_tcp.TCPClientTestsBuilder': [
+            'test_badContext',  # ssl-related; see also SSLClientTestsMixin
+        ],
+        'twisted.internet.test.test_tcp.TCPPortTestsBuilder': [
+            # These use link-local addresses and cause firewall prompts on mac
+            'test_buildProtocolIPv6AddressScopeID',
+            'test_portGetHostOnIPv6ScopeID',
+            'test_serverGetHostOnIPv6ScopeID',
+            'test_serverGetPeerOnIPv6ScopeID',
+        ],
+        'twisted.internet.test.test_tcp.TCPConnectionTestsBuilder': [],
+        'twisted.internet.test.test_tcp.WriteSequenceTests': [],
+        'twisted.internet.test.test_tcp.AbortConnectionTestCase': [],
+        'twisted.internet.test.test_threads.ThreadTestsBuilder': [],
+        'twisted.internet.test.test_time.TimeTestsBuilder': [],
+        # Extra third-party dependencies (pyOpenSSL)
+        #'twisted.internet.test.test_tls.SSLClientTestsMixin': [],
+        'twisted.internet.test.test_udp.UDPServerTestsBuilder': [],
+        'twisted.internet.test.test_unix.UNIXTestsBuilder': [
+            # Platform-specific.  These tests would be skipped automatically
+            # if we were running twisted's own test runner.
+            'test_connectToLinuxAbstractNamespace',
+            'test_listenOnLinuxAbstractNamespace',
+            # These tests use twisted's sendmsg.c extension and sometimes
+            # fail with what looks like uninitialized memory errors
+            # (more common on pypy than cpython, but I've seen it on both)
+            'test_sendFileDescriptor',
+            'test_sendFileDescriptorTriggersPauseProducing',
+            'test_descriptorDeliveredBeforeBytes',
+            'test_avoidLeakingFileDescriptors',
+        ],
+        'twisted.internet.test.test_unix.UNIXDatagramTestsBuilder': [
+            'test_listenOnLinuxAbstractNamespace',
+        ],
+        'twisted.internet.test.test_unix.UNIXPortTestsBuilder': [],
+    }
+    for test_name, blacklist in twisted_tests.items():
+        try:
+            test_class = import_object(test_name)
+        except (ImportError, AttributeError):
+            continue
+        for test_func in blacklist:
+            if hasattr(test_class, test_func):
+                # The test_func may be defined in a mixin, so clobber
+                # it instead of delattr()
+                setattr(test_class, test_func, lambda self: None)
+
+        def make_test_subclass(test_class):
+            class TornadoTest(test_class):
+                _reactors = ["tornado.platform.twisted._TestReactor"]
+
+                def setUp(self):
+                    # Twisted's tests expect to be run from a temporary
+                    # directory; they create files in their working directory
+                    # and don't always clean up after themselves.
+                    self.__curdir = os.getcwd()
+                    self.__tempdir = tempfile.mkdtemp()
+                    os.chdir(self.__tempdir)
+                    super(TornadoTest, self).setUp()
+
+                def tearDown(self):
+                    super(TornadoTest, self).tearDown()
+                    os.chdir(self.__curdir)
+                    shutil.rmtree(self.__tempdir)
+
+                def buildReactor(self):
+                    self.__saved_signals = save_signal_handlers()
+                    return test_class.buildReactor(self)
+
+                def unbuildReactor(self, reactor):
+                    test_class.unbuildReactor(self, reactor)
+                    # Clean up file descriptors (especially epoll/kqueue
+                    # objects) eagerly instead of leaving them for the
+                    # GC.  Unfortunately we can't do this in reactor.stop
+                    # since twisted expects to be able to unregister
+                    # connections in a post-shutdown hook.
+                    reactor._io_loop.close(all_fds=True)
+                    restore_signal_handlers(self.__saved_signals)
+
+            TornadoTest.__name__ = test_class.__name__
+            return TornadoTest
+        test_subclass = make_test_subclass(test_class)
+        globals().update(test_subclass.makeTestCaseClasses())
+
+    # Since we're not using twisted's test runner, it's tricky to get
+    # logging set up well.  Most of the time it's easiest to just
+    # leave it turned off, but while working on these tests you may want
+    # to uncomment one of the other lines instead.
+    log.defaultObserver.stop()
+    # import sys; log.startLogging(sys.stderr, setStdout=0)
+    # log.startLoggingWithObserver(log.PythonLoggingObserver().emit, setStdout=0)
+    # import logging; logging.getLogger('twisted').setLevel(logging.WARNING)
+
+if have_twisted:
+    class LayeredTwistedIOLoop(TwistedIOLoop):
+        """Layers a TwistedIOLoop on top of a TornadoReactor on a SelectIOLoop.
+
+        This is of course silly, but is useful for testing purposes to make
+        sure we're implementing both sides of the various interfaces
+        correctly.  In some tests another TornadoReactor is layered on top
+        of the whole stack.
+        """
+        def initialize(self):
+            # When configured to use LayeredTwistedIOLoop we can't easily
+            # get the next-best IOLoop implementation, so use the lowest common
+            # denominator.
+            self.real_io_loop = SelectIOLoop()
+            reactor = TornadoReactor(io_loop=self.real_io_loop)
+            super(LayeredTwistedIOLoop, self).initialize(reactor=reactor)
+            self.add_callback(self.make_current)
+
+        def close(self, all_fds=False):
+            super(LayeredTwistedIOLoop, self).close(all_fds=all_fds)
+            # HACK: This is the same thing that test_class.unbuildReactor does.
+            for reader in self.reactor._internalReaders:
+                self.reactor.removeReader(reader)
+                reader.connectionLost(None)
+            self.real_io_loop.close(all_fds=all_fds)
+
+        def stop(self):
+            # One of twisted's tests fails if I don't delay crash()
+            # until the reactor has started, but if I move this to
+            # TwistedIOLoop then the tests fail when I'm *not* running
+            # tornado-on-twisted-on-tornado.  I'm clearly missing something
+            # about the startup/crash semantics, but since stop and crash
+            # are really only used in tests it doesn't really matter.
+            self.reactor.callWhenRunning(self.reactor.crash)
+
+if __name__ == "__main__":
+    unittest.main()

Shared/lib/python2.7/site-packages/tornado/test/util.py

@@ -0,0 +1,19 @@
+from __future__ import absolute_import, division, print_function, with_statement
+
+import os
+import sys
+
+# Encapsulate the choice of unittest or unittest2 here.
+# To be used as 'from tornado.test.util import unittest'.
+if sys.version_info >= (2, 7):
+    import unittest
+else:
+    import unittest2 as unittest
+
+skipIfNonUnix = unittest.skipIf(os.name != 'posix' or sys.platform == 'cygwin',
+                                "non-unix platform")
+
+# travis-ci.org runs our tests in an overworked virtual machine, which makes
+# timing-related tests unreliable.
+skipOnTravis = unittest.skipIf('TRAVIS' in os.environ,
+                               'timing tests unreliable on travis')

Shared/lib/python2.7/site-packages/tornado/test/util_test.py

@@ -0,0 +1,164 @@
+# coding: utf-8
+from __future__ import absolute_import, division, print_function, with_statement
+import sys
+
+from tornado.escape import utf8
+from tornado.util import raise_exc_info, Configurable, u, exec_in, ArgReplacer
+from tornado.test.util import unittest
+
+try:
+    from cStringIO import StringIO  # py2
+except ImportError:
+    from io import StringIO  # py3
+
+
+class RaiseExcInfoTest(unittest.TestCase):
+    def test_two_arg_exception(self):
+        # This test would fail on python 3 if raise_exc_info were simply
+        # a three-argument raise statement, because TwoArgException
+        # doesn't have a "copy constructor"
+        class TwoArgException(Exception):
+            def __init__(self, a, b):
+                super(TwoArgException, self).__init__()
+                self.a, self.b = a, b
+
+        try:
+            raise TwoArgException(1, 2)
+        except TwoArgException:
+            exc_info = sys.exc_info()
+        try:
+            raise_exc_info(exc_info)
+            self.fail("didn't get expected exception")
+        except TwoArgException as e:
+            self.assertIs(e, exc_info[1])
+
+
+class TestConfigurable(Configurable):
+    @classmethod
+    def configurable_base(cls):
+        return TestConfigurable
+
+    @classmethod
+    def configurable_default(cls):
+        return TestConfig1
+
+
+class TestConfig1(TestConfigurable):
+    def initialize(self, a=None):
+        self.a = a
+
+
+class TestConfig2(TestConfigurable):
+    def initialize(self, b=None):
+        self.b = b
+
+
+class ConfigurableTest(unittest.TestCase):
+    def setUp(self):
+        self.saved = TestConfigurable._save_configuration()
+
+    def tearDown(self):
+        TestConfigurable._restore_configuration(self.saved)
+
+    def checkSubclasses(self):
+        # no matter how the class is configured, it should always be
+        # possible to instantiate the subclasses directly
+        self.assertIsInstance(TestConfig1(), TestConfig1)
+        self.assertIsInstance(TestConfig2(), TestConfig2)
+
+        obj = TestConfig1(a=1)
+        self.assertEqual(obj.a, 1)
+        obj = TestConfig2(b=2)
+        self.assertEqual(obj.b, 2)
+
+    def test_default(self):
+        obj = TestConfigurable()
+        self.assertIsInstance(obj, TestConfig1)
+        self.assertIs(obj.a, None)
+
+        obj = TestConfigurable(a=1)
+        self.assertIsInstance(obj, TestConfig1)
+        self.assertEqual(obj.a, 1)
+
+        self.checkSubclasses()
+
+    def test_config_class(self):
+        TestConfigurable.configure(TestConfig2)
+        obj = TestConfigurable()
+        self.assertIsInstance(obj, TestConfig2)
+        self.assertIs(obj.b, None)
+
+        obj = TestConfigurable(b=2)
+        self.assertIsInstance(obj, TestConfig2)
+        self.assertEqual(obj.b, 2)
+
+        self.checkSubclasses()
+
+    def test_config_args(self):
+        TestConfigurable.configure(None, a=3)
+        obj = TestConfigurable()
+        self.assertIsInstance(obj, TestConfig1)
+        self.assertEqual(obj.a, 3)
+
+        obj = TestConfigurable(a=4)
+        self.assertIsInstance(obj, TestConfig1)
+        self.assertEqual(obj.a, 4)
+
+        self.checkSubclasses()
+        # args bound in configure don't apply when using the subclass directly
+        obj = TestConfig1()
+        self.assertIs(obj.a, None)
+
+    def test_config_class_args(self):
+        TestConfigurable.configure(TestConfig2, b=5)
+        obj = TestConfigurable()
+        self.assertIsInstance(obj, TestConfig2)
+        self.assertEqual(obj.b, 5)
+
+        obj = TestConfigurable(b=6)
+        self.assertIsInstance(obj, TestConfig2)
+        self.assertEqual(obj.b, 6)
+
+        self.checkSubclasses()
+        # args bound in configure don't apply when using the subclass directly
+        obj = TestConfig2()
+        self.assertIs(obj.b, None)
+
+
+class UnicodeLiteralTest(unittest.TestCase):
+    def test_unicode_escapes(self):
+        self.assertEqual(utf8(u('\u00e9')), b'\xc3\xa9')
+
+
+class ExecInTest(unittest.TestCase):
+    # This test is python 2 only because there are no new future imports
+    # defined in python 3 yet.
+    @unittest.skipIf(sys.version_info >= print_function.getMandatoryRelease(),
+                     'no testable future imports')
+    def test_no_inherit_future(self):
+        # This file has from __future__ import print_function...
+        f = StringIO()
+        print('hello', file=f)
+        # ...but the template doesn't
+        exec_in('print >> f, "world"', dict(f=f))
+        self.assertEqual(f.getvalue(), 'hello\nworld\n')
+
+
+class ArgReplacerTest(unittest.TestCase):
+    def setUp(self):
+        def function(x, y, callback=None, z=None):
+            pass
+        self.replacer = ArgReplacer(function, 'callback')
+
+    def test_omitted(self):
+        self.assertEqual(self.replacer.replace('new', (1, 2), dict()),
+                         (None, (1, 2), dict(callback='new')))
+
+    def test_position(self):
+        self.assertEqual(self.replacer.replace('new', (1, 2, 'old', 3), dict()),
+                         ('old', [1, 2, 'new', 3], dict()))
+
+    def test_keyword(self):
+        self.assertEqual(self.replacer.replace('new', (1,),
+                                               dict(y=2, callback='old', z=3)),
+                         ('old', (1,), dict(y=2, callback='new', z=3)))

Shared/lib/python2.7/site-packages/tornado/test/websocket_test.py

@@ -0,0 +1,87 @@
+from tornado.concurrent import Future
+from tornado import gen
+from tornado.httpclient import HTTPError
+from tornado.log import gen_log
+from tornado.testing import AsyncHTTPTestCase, gen_test, bind_unused_port, ExpectLog
+from tornado.web import Application, RequestHandler
+from tornado.websocket import WebSocketHandler, websocket_connect, WebSocketError
+
+
+class EchoHandler(WebSocketHandler):
+    def initialize(self, close_future):
+        self.close_future = close_future
+
+    def on_message(self, message):
+        self.write_message(message, isinstance(message, bytes))
+
+    def on_close(self):
+        self.close_future.set_result(None)
+
+
+class NonWebSocketHandler(RequestHandler):
+    def get(self):
+        self.write('ok')
+
+
+class WebSocketTest(AsyncHTTPTestCase):
+    def get_app(self):
+        self.close_future = Future()
+        return Application([
+            ('/echo', EchoHandler, dict(close_future=self.close_future)),
+            ('/non_ws', NonWebSocketHandler),
+        ])
+
+    @gen_test
+    def test_websocket_gen(self):
+        ws = yield websocket_connect(
+            'ws://localhost:%d/echo' % self.get_http_port(),
+            io_loop=self.io_loop)
+        ws.write_message('hello')
+        response = yield ws.read_message()
+        self.assertEqual(response, 'hello')
+
+    def test_websocket_callbacks(self):
+        websocket_connect(
+            'ws://localhost:%d/echo' % self.get_http_port(),
+            io_loop=self.io_loop, callback=self.stop)
+        ws = self.wait().result()
+        ws.write_message('hello')
+        ws.read_message(self.stop)
+        response = self.wait().result()
+        self.assertEqual(response, 'hello')
+
+    @gen_test
+    def test_websocket_http_fail(self):
+        with self.assertRaises(HTTPError) as cm:
+            yield websocket_connect(
+                'ws://localhost:%d/notfound' % self.get_http_port(),
+                io_loop=self.io_loop)
+        self.assertEqual(cm.exception.code, 404)
+
+    @gen_test
+    def test_websocket_http_success(self):
+        with self.assertRaises(WebSocketError):
+            yield websocket_connect(
+                'ws://localhost:%d/non_ws' % self.get_http_port(),
+                io_loop=self.io_loop)
+
+    @gen_test
+    def test_websocket_network_fail(self):
+        sock, port = bind_unused_port()
+        sock.close()
+        with self.assertRaises(HTTPError) as cm:
+            with ExpectLog(gen_log, ".*"):
+                yield websocket_connect(
+                    'ws://localhost:%d/' % port,
+                    io_loop=self.io_loop,
+                    connect_timeout=0.01)
+        self.assertEqual(cm.exception.code, 599)
+
+    @gen_test
+    def test_websocket_close_buffered_data(self):
+        ws = yield websocket_connect(
+            'ws://localhost:%d/echo' % self.get_http_port())
+        ws.write_message('hello')
+        ws.write_message('world')
+        ws.stream.close()
+        yield self.close_future

Shared/lib/python2.7/site-packages/tornado/test/wsgi_test.py

@@ -0,0 +1,87 @@
+from __future__ import absolute_import, division, print_function, with_statement
+from wsgiref.validate import validator
+
+from tornado.escape import json_decode
+from tornado.test.httpserver_test import TypeCheckHandler
+from tornado.testing import AsyncHTTPTestCase
+from tornado.util import u
+from tornado.web import RequestHandler
+from tornado.wsgi import WSGIApplication, WSGIContainer
+
+
+class WSGIContainerTest(AsyncHTTPTestCase):
+    def wsgi_app(self, environ, start_response):
+        status = "200 OK"
+        response_headers = [("Content-Type", "text/plain")]
+        start_response(status, response_headers)
+        return [b"Hello world!"]
+
+    def get_app(self):
+        return WSGIContainer(validator(self.wsgi_app))
+
+    def test_simple(self):
+        response = self.fetch("/")
+        self.assertEqual(response.body, b"Hello world!")
+
+
+class WSGIApplicationTest(AsyncHTTPTestCase):
+    def get_app(self):
+        class HelloHandler(RequestHandler):
+            def get(self):
+                self.write("Hello world!")
+
+        class PathQuotingHandler(RequestHandler):
+            def get(self, path):
+                self.write(path)
+
+        # It would be better to run the wsgiref server implementation in
+        # another thread instead of using our own WSGIContainer, but this
+        # fits better in our async testing framework and the wsgiref
+        # validator should keep us honest
+        return WSGIContainer(validator(WSGIApplication([
+            ("/", HelloHandler),
+            ("/path/(.*)", PathQuotingHandler),
+            ("/typecheck", TypeCheckHandler),
+        ])))
+
+    def test_simple(self):
+        response = self.fetch("/")
+        self.assertEqual(response.body, b"Hello world!")
+
+    def test_path_quoting(self):
+        response = self.fetch("/path/foo%20bar%C3%A9")
+        self.assertEqual(response.body, u("foo bar\u00e9").encode("utf-8"))
+
+    def test_types(self):
+        headers = {"Cookie": "foo=bar"}
+        response = self.fetch("/typecheck?foo=bar", headers=headers)
+        data = json_decode(response.body)
+        self.assertEqual(data, {})
+
+        response = self.fetch("/typecheck", method="POST", body="foo=bar", headers=headers)
+        data = json_decode(response.body)
+        self.assertEqual(data, {})
+
+# This is kind of hacky, but run some of the HTTPServer tests through
+# WSGIContainer and WSGIApplication to make sure everything survives
+# repeated disassembly and reassembly.
+from tornado.test import httpserver_test
+from tornado.test import web_test
+
+
+class WSGIConnectionTest(httpserver_test.HTTPConnectionTest):
+    def get_app(self):
+        return WSGIContainer(validator(WSGIApplication(self.get_handlers())))
+
+
+def wrap_web_tests():
+    result = {}
+    for cls in web_test.wsgi_safe_tests:
+        class WSGIWrappedTest(cls):
+            def get_app(self):
+                self.app = WSGIApplication(self.get_handlers(),
+                                           **self.get_app_kwargs())
+                return WSGIContainer(validator(self.app))
+        result["WSGIWrapped_" + cls.__name__] = WSGIWrappedTest
+    return result
+globals().update(wrap_web_tests())