def test_connect_using_sslcontext_verified(self):
        with support.transient_internet(self.testServer):
            can_verify = check_ssl_verifiy(self.testServer, self.remotePort)
            if not can_verify:
                self.skipTest("SSL certificate can't be verified")

        support.get_attribute(smtplib, 'SMTP_SSL')
        context = ssl.create_default_context()
        with support.transient_internet(self.testServer):
            server = smtplib.SMTP_SSL(self.testServer, self.remotePort, context=context)
            server.ehlo()
            server.quit()

 def test_redirect_url_withfrag(self):
     redirect_url_with_frag = "http://bitly.com/urllibredirecttest"
     with support.transient_internet(redirect_url_with_frag):
         req = urllib.request.Request(redirect_url_with_frag)
         res = urllib.request.urlopen(req)
         self.assertEqual(res.geturl(),
                 "http://docs.python.org/3.4/glossary.html#term-global-interpreter-lock")

 def test_connect_using_sslcontext(self):
     context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
     support.get_attribute(smtplib, 'SMTP_SSL')
     with support.transient_internet(self.testServer):
         server = smtplib.SMTP_SSL(self.testServer, self.remotePort, context=context)
         server.ehlo()
         server.quit()

 def testPasswordProtectedSite(self):
     support.requires('network')
     with support.transient_internet('mueblesmoraleda.com'):
         url = 'http://mueblesmoraleda.com'
         robots_url = url + "/robots.txt"
         # First check the URL is usable for our purposes, since the
         # test site is a bit flaky.
         try:
             urlopen(robots_url)
         except HTTPError as e:
             if e.code not in {401, 403}:
                 self.skipTest(
                     "%r should return a 401 or 403 HTTP error, not %r"
                     % (robots_url, e.code))
         else:
             self.skipTest(
                 "%r should return a 401 or 403 HTTP error, not succeed"
                 % (robots_url))
         parser = urllib.robotparser.RobotFileParser()
         parser.set_url(url)
         try:
             parser.read()
         except URLError:
             self.skipTest('%s is unavailable' % url)
         self.assertEqual(parser.can_fetch("*", robots_url), False)

    def _test_urls(self, urls, handlers, retry=True):
        import socket
        import time
        import logging
        debug = logging.getLogger("test_urllib2").debug

        urlopen = urllib.request.build_opener(*handlers).open
        if retry:
            urlopen = _wrap_with_retry_thrice(urlopen, urllib.error.URLError)

        for url in urls:
            if isinstance(url, tuple):
                url, req, expected_err = url
            else:
                req = expected_err = None
            debug(url)
            try:
                f = urlopen(url, req)
            except EnvironmentError as err:
                debug(err)
                if expected_err:
                    msg = ("Didn't get expected error(s) %s for %s %s, got %s: %s" %
                           (expected_err, url, req, type(err), err))
                    self.assert_(isinstance(err, expected_err), msg)
            else:
                with support.transient_internet():
                    buf = f.read()
                f.close()
                debug("read %d bytes" % len(buf))
            debug("******** next url coming up...")
            time.sleep(0.1)

 def test_connect_using_sslcontext_verified(self):
     support.get_attribute(smtplib, 'SMTP_SSL')
     context = ssl.create_default_context()
     with support.transient_internet(self.testServer):
         server = smtplib.SMTP_SSL(self.testServer, self.remotePort, context=context)
         server.ehlo()
         server.quit()

 def test_redirect_url_withfrag(self):
     redirect_url_with_frag = "http://bit.ly/1iSHToT"
     with support.transient_internet(redirect_url_with_frag):
         req = request.Request(redirect_url_with_frag)
         res = yield from request.urlopen(req)
         self.assertEqual(res.geturl(),
                 "https://docs.python.org/3.4/glossary.html#term-global-interpreter-lock")

 def test_http_basic(self):
     self.assertIsNone(socket.getdefaulttimeout())
     url = support.TEST_HTTP_URL
     with support.transient_internet(url, timeout=None):
         u = _urlopen_with_retry(url)
         self.addCleanup(u.close)
         self.assertIsNone(u.fp.raw._sock.gettimeout())

 def test_urlwithfrag(self):
     urlwith_frag = "http://www.pythontest.net/index.html#frag"
     with support.transient_internet(urlwith_frag):
         req = urllib.request.Request(urlwith_frag)
         res = urllib.request.urlopen(req)
         self.assertEqual(res.geturl(),
                 "http://www.pythontest.net/index.html#frag")

 def test_networked(self):
     # Default settings: no cert verification is done
     support.requires("network")
     with support.transient_internet("svn.python.org"):
         h = client.HTTPSConnection("svn.python.org", 443)
         h.request("GET", "/")
         resp = h.getresponse()
         self._check_svn_python_org(resp)

def resolve_address(host, port):
    """Resolve an (host, port) to an address.

    We must perform name resolution before timeout tests, otherwise it will be
    performed by connect().
    """
    with support.transient_internet(host):
        return socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)[0][4]

 def testPythonOrg(self):
     support.requires('network')
     with support.transient_internet('www.python.org'):
         parser = urllib.robotparser.RobotFileParser(
             "http://www.python.org/robots.txt")
         parser.read()
         self.assertTrue(
             parser.can_fetch("*", "http://www.python.org/robots.txt"))

 def test_logincapa(self):
     with transient_internet(self.host):
         for cap in self.server.capabilities:
             self.assertIsInstance(cap, str)
         self.assertTrue('LOGINDISABLED' in self.server.capabilities)
         self.assertTrue('AUTH=ANONYMOUS' in self.server.capabilities)
         rs = self.server.login(self.username, self.password)
         self.assertEqual(rs[0], 'OK')

 def urlopen(self, *args, **kwargs):
     resource = args[0]
     with support.transient_internet(resource):
         r = urllib.request.urlopen(*args, **kwargs)
         try:
             yield r
         finally:
             r.close()

 def urlretrieve(self, *args, **kwargs):
     resource = args[0]
     with support.transient_internet(resource):
         file_location, info = urllib.request.urlretrieve(*args, **kwargs)
         try:
             yield file_location, info
         finally:
             support.unlink(file_location)

    def test_sites_no_connection_close(self):
        # Some sites do not send Connection: close header.
        # Verify that those work properly. (#issue12576)

        URL = 'http://www.imdb.com' # No Connection:close
        with support.transient_internet(URL):
            req = urllib.request.urlopen(URL)
            res = req.read()
            self.assertTrue(res)

 def test_ftp_no_timeout(self):
     self.assertTrue(socket.getdefaulttimeout() is None)
     with support.transient_internet(self.FTP_HOST):
         socket.setdefaulttimeout(60)
         try:
             u = _urlopen_with_retry(self.FTP_HOST, timeout=None)
         finally:
             socket.setdefaulttimeout(None)
         self.assertTrue(u.fp.fp.raw._sock.gettimeout() is None)

 def test_ftp_timeout(self):
     with support.transient_internet(self.FTP_HOST):
         u = _urlopen_with_retry(self.FTP_HOST, timeout=60)
         self.addCleanup(u.close)
         if utils.PY2:
             sock = u.fp.fp._sock
         else:
             sock = u.fp.fp.raw._sock
         self.assertEqual(sock.gettimeout(), 60)

 def test_networked(self):
     # Default settings: requires a valid cert from a trusted CA
     import ssl
     support.requires('network')
     with support.transient_internet('self-signed.pythontest.net'):
         h = client.HTTPSConnection('self-signed.pythontest.net', 443)
         with self.assertRaises(ssl.SSLError) as exc_info:
             h.request('GET', '/')
         self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')

 def test_networked_trusted_by_default_cert(self):
     # Default settings: requires a valid cert from a trusted CA
     support.requires('network')
     with support.transient_internet('www.python.org'):
         h = client.HTTPSConnection('www.python.org', 443)
         h.request('GET', '/')
         resp = h.getresponse()
         content_type = resp.getheader('content-type')
         self.assertIn('text/html', content_type)