def setUpModule():
    try:
        import signal
        # The default handler for SIGXFSZ is to abort the process.
        # By ignoring it, system calls exceeding the file size resource
        # limit will raise OSError instead of crashing the interpreter.
        signal.signal(signal.SIGXFSZ, signal.SIG_IGN)
    except (ImportError, AttributeError):
        pass

    # On Windows and Mac OSX this test consumes large resources; It
    # takes a long time to build the >2 GiB file and takes >2 GiB of disk
    # space therefore the resource must be enabled to run this test.
    # If not, nothing after this line stanza will be executed.
    if sys.platform[:3] == 'win' or sys.platform == 'darwin':
        requires('largefile',
                 'test requires %s bytes and a long time to run' % str(size))
    else:
        # Only run if the current filesystem supports large files.
        # (Skip this test on Windows, since we now always support
        # large files.)
        f = open(TESTFN, 'wb', buffering=0)
        try:
            # 2**31 == 2147483648
            f.seek(2147483649)
            # Seeking is not enough of a test: you must write and flush, too!
            f.write(b'x')
            f.flush()
        except (OSError, OverflowError):
            raise unittest.SkipTest("filesystem does not have "
                                    "largefile support")
        finally:
            f.close()
            unlink(TESTFN)

 def setUpClass(cls):
     requires('gui')
     cls.root = Tk()
     cls.TV = TV = tv.TextViewer
     TV.transient = Func()
     TV.grab_set = Func()
     TV.wait_window = Func()

def test_main():
    support.requires('network')
    support.run_unittest(
        CreationTestCase,
        TCPTimeoutTestCase,
        UDPTimeoutTestCase,
    )

 def setUpClass(cls):
     requires('gui')
     cls.root = Tk()
     cls.root.withdraw()
     editor = Editor(root=cls.root)
     cls.text = editor.text.text  # Test code does not need the wrapper.
     cls.formatter = pg.FormatParagraph(editor).format_paragraph_event

def test_main():
    support.requires('network')
    with support.check_py3k_warnings(
            ("urllib.urlopen.. has been removed", DeprecationWarning)):
        support.run_unittest(URLTimeoutTest,
                                  urlopenNetworkTests,
                                  urlretrieveNetworkTests)

    def test_bad_address(self):
        # Make sure proper exception is raised when connecting to a bogus
        # address.

        # as indicated by the comment below, this might fail with some ISP,
        # so we run the test only when -unetwork/-uall is specified to
        # mitigate the problem a bit (see #17564)
        support.requires('network')
        self.assertRaises(OSError,
                          # Given that both VeriSign and various ISPs have in
                          # the past or are presently hijacking various invalid
                          # domain name requests in an attempt to boost traffic
                          # to their own sites, finding a domain name to use
                          # for this test is difficult.  RFC2606 leads one to
                          # believe that '.invalid' should work, but experience
                          # seemed to indicate otherwise.  Single character
                          # TLDs are likely to remain invalid, so this seems to
                          # be the best choice. The trailing '.' prevents a
                          # related problem: The normal DNS resolver appends
                          # the domain names from the search path if there is
                          # no '.' the end and, and if one of those domains
                          # implements a '*' rule a result is returned.
                          # However, none of this will prevent the test from
                          # failing if the ISP hijacks all invalid domain
                          # requests.  The real solution would be to be able to
                          # parameterize the framework with a mock resolver.
                          urllib.request.urlopen,
                          "http://sadflkjsasf.i.nvali.d./")

 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_main():
    support.requires("network")
    support.run_unittest(AuthTests,
                              OtherNetworkTests,
                              CloseSocketTest,
                              TimeoutTest,
                              )

 def setUpClass(cls):
     requires('gui')
     cls.root = Tk()
     cls.root.withdraw()
     keylist = [['<Key-F12>'], ['<Control-Key-x>', '<Control-Key-X>']]
     cls.dialog = cls.Validator(
         cls.root, 'Title', '<<Test>>', keylist, _utest=True)

 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 setUpClass(cls):
     requires('gui')
     cls.root = tk.Tk()
     cls.root.withdraw()
     def cmd(tkpath, func):
         assert isinstance(tkpath, str)
         assert isinstance(func, type(cmd))
     cls.root.createcommand = cmd

 def setUpClass(cls):
     if 'tkinter' in str(Text):
         requires('gui')
         cls.tk = Tk()
         cls.text = Text(cls.tk)
     else:
         cls.text = Text()
     cls.auto_expand = AutoExpand(Dummy_Editwin(cls.text))

 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_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)

 def testPasswordProtectedSite(self):
     support.requires('network')
     with support.transient_internet('mueblesmoraleda.com'):
         url = 'http://mueblesmoraleda.com'
         parser = urllib.robotparser.RobotFileParser()
         parser.set_url(url)
         try:
             parser.read()
         except URLError:
             self.skipTest('%s is unavailable' % url)
         self.assertEqual(parser.can_fetch("*", url+"/robots.txt"), False)

 def test_networked_bad_cert(self):
     # We feed a "CA" cert that is unrelated to the server's cert
     import ssl
     support.requires('network')
     with support.transient_internet('svn.python.org'):
         context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
         context.verify_mode = ssl.CERT_REQUIRED
         context.load_verify_locations(CERT_localhost)
         h = client.HTTPSConnection('svn.python.org', 443, context=context)
         with self.assertRaises(ssl.SSLError):
             h.request('GET', '/')

 def test_networked_noverification(self):
     # Switch off cert verification
     import ssl
     support.requires('network')
     with support.transient_internet('self-signed.pythontest.net'):
         context = ssl._create_unverified_context()
         h = client.HTTPSConnection('self-signed.pythontest.net', 443,
                                    context=context)
         h.request('GET', '/')
         resp = h.getresponse()
         self.assertIn('nginx', resp.getheader('server'))

    def setUpClass(cls):
        svs = stackviewer.sys
        try:
            abc
        except NameError:
            svs.last_type, svs.last_value, svs.last_traceback = (
                sys.exc_info())

        requires('gui')
        cls.root = Tk()
        cls.root.withdraw()

 def test_networked_bad_cert(self):
     # We feed a "CA" cert that is unrelated to the server's cert
     import ssl
     support.requires('network')
     with support.transient_internet('self-signed.pythontest.net'):
         context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
         context.verify_mode = ssl.CERT_REQUIRED
         context.load_verify_locations(CERT_localhost)
         h = client.HTTPSConnection('self-signed.pythontest.net', 443, context=context)
         with self.assertRaises(ssl.SSLError) as exc_info:
             h.request('GET', '/')
         self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')