"""
import getopt
-import itertools
import json
import os
import random
if use_mp:
from threading import Thread
- from queue import Queue, Empty
- from subprocess import Popen, PIPE, STDOUT
+ from queue import Queue
+ from subprocess import Popen, PIPE
from collections import deque
debug_output_pat = re.compile(r"\[\d+ refs\]$")
pending = deque()
-from test.support import verbose, run_unittest
+from test.support import run_unittest
from _locale import (setlocale, LC_ALL, LC_CTYPE, LC_NUMERIC, localeconv, Error)
try:
from _locale import (RADIXCHAR, THOUSEP, nl_langinfo)
import operator
import unittest
from numbers import Complex, Real, Rational, Integral
-from numbers import Number
from test import support
class TestNumbers(unittest.TestCase):
# Python test set -- built-in functions
import platform
-import test.support, unittest
-from test.support import fcmp, TESTFN, unlink, run_unittest, \
- run_with_locale
+import unittest
+from test.support import fcmp, TESTFN, unlink, run_unittest
from operator import neg
-import sys, warnings, random, collections, io, fractions
+import sys, warnings, random, collections, io
+
warnings.filterwarnings("ignore", "hex../oct.. of negative int",
FutureWarning, __name__)
warnings.filterwarnings("ignore", "integer argument expected",
from test.support import run_unittest
from test.test_math import parse_testfile, test_file
import unittest
-import os, sys
import cmath, math
from cmath import phase, polar, rect, pi
# All tests are executed with environment variables ignored
# See test_cmd_line_script.py for testing of script execution
-import os
import test.support, unittest
import os
import sys
import unittest
import os
import os.path
-import sys
import test.support
-from test.script_helper import (spawn_python, kill_python, run_python,
+from test.script_helper import (run_python,
temp_dir, make_script, compile_script,
make_pkg, make_zip_script, make_zip_pkg)
from test import mapping_tests
import pickle, copy
from random import randrange, shuffle
-import operator
import keyword
import re
import sys
import py_compile
import shutil
import struct
-import sys
import tempfile
-import time
from test import support
import unittest
"""Unit tests for contextlib.py, and other context managers."""
-import sys
import os
-import decimal
import sys
import tempfile
import unittest
with the corresponding argument.
"""
-import glob
import math
import os, sys
import pickle, copy
import pickle
from io import StringIO
import random
-import os
BIG = 100000
def test_module_subclasses(self):
# Testing Python subclass of module...
log = []
- import types, sys
MT = type(sys)
class MM(MT):
def __init__(self, name):
# Test cyclical leaks [SF bug 519621]
class F(object):
__slots__ = ['a', 'b']
- log = []
s = F()
s.a = [Counted(), s]
self.assertEqual(Counted.counter, 1)
self.assertEqual(Counted.counter, 0)
# Test lookup leaks [SF bug 572567]
- import sys,gc
+ import gc
if hasattr(gc, 'get_objects'):
class G(object):
def __eq__(self, other):
## self.assertIn('__self__', dir(a.Amethod))
# Try a module subclass.
- import sys
class M(type(sys)):
pass
minstance = M("m")
self.fail("d.foo should be undefined now")
# Test a nasty bug in recurse_down_subclasses()
- import gc
class A(object):
pass
class B(A):
def test_file_fault(self):
# Testing sys.stdout is changed in getattr...
- import sys
test_stdout = sys.stdout
class StdoutGuard:
def __getattr__(self, attr):
def test_not_implemented(self):
# Testing NotImplemented...
# all binary methods should be able to return a NotImplemented
- import sys
- import types
import operator
def specialmethod(self, other):
"""
Tests for epoll wrapper.
"""
-import os
import socket
import errno
import time
import select
-import tempfile
import unittest
from test import support
import io
import _pyio as pyio
-from test.support import TESTFN, findfile, run_unittest
+from test.support import TESTFN, run_unittest
from collections import UserList
class AutoFileTests(unittest.TestCase):
-import os, filecmp, shutil, tempfile, shutil
+import os, filecmp, shutil, tempfile
import unittest
from test import support
from weakref import proxy
from functools import wraps
-from test.support import (TESTFN, findfile, check_warnings, run_unittest,
- make_bad_fd)
-from collections import UserList
+from test.support import TESTFN, check_warnings, run_unittest, make_bad_fd
from _io import FileIO as _FileIO
if float.__getformat__("double").startswith("IEEE"):
def test_negative_zero(self):
- import math
def pos_pos():
return 0.0, math.atan2(0.0, -1)
def pos_neg():
"""This test checks for correct fork() behavior.
"""
-import errno
import imp
import os
import signal
from test.support import captured_stdout, run_unittest
import unittest
-import sys, os
+import sys
class FrozenTests(unittest.TestCase):
def test_frozen(self):
import unittest
import getopt
-import os
sentinel = object()
import array
import hashlib
-from io import StringIO
import itertools
import sys
try:
def test_main(verbose=None):
- from types import BuiltinFunctionType
-
test_classes = [TestHeapPython, TestHeapC, TestErrorHandling]
support.run_unittest(*test_classes)
from contextlib import contextmanager
import imaplib
import os.path
-import select
-import socket
import socketserver
-import sys
import time
from test.support import reap_threads, verbose
import collections
from os.path import normcase
-from test.support import TESTFN, run_unittest
+from test.support import run_unittest
from test import inspect_fodder as mod
from test import inspect_fodder2 as mod2
import unittest
import warnings
import weakref
-import gc
import abc
-from itertools import chain, cycle, count
+from itertools import cycle, count
from collections import deque
from test import support
self.assertEqual(int(float(x)), y)
def test_float_overflow(self):
- import math
-
for x in -2.0, -1.0, 0.0, 1.0, 2.0:
self.assertEqual(float(int(x)), x)
"float(shuge) should not equal int(shuge)")
def test_logs(self):
- import math
-
LOG10E = math.log10(math.e)
for exp in list(range(10)) + [100, 1000, 10000]:
def test_mixed_compares(self):
eq = self.assertEqual
- import math
# We're mostly concerned with that mixing floats and longs does the
# right stuff, even when longs are too large to fit in a float.
import io
import _pyio as pyio
-import sys
import pickle
class MemorySeekTestMixin:
#
from test import support
-from test import test_multibytecodec_support
from test.support import TESTFN
import unittest, io, codecs, sys, os
import _multibytecodec
import ntpath
import os
-from test.support import verbose, TestFailed
+from test.support import TestFailed
from test import support, test_genericpath
import unittest
from test import support
-from optparse import make_option, Option, IndentedHelpFormatter, \
- TitledHelpFormatter, OptionParser, OptionContainer, OptionGroup, \
- SUPPRESS_HELP, SUPPRESS_USAGE, OptionError, OptionConflictError, \
+from optparse import make_option, Option, \
+ TitledHelpFormatter, OptionParser, OptionGroup, \
+ SUPPRESS_USAGE, OptionError, OptionConflictError, \
BadOptionError, OptionValueError, Values
from optparse import _match_abbrev
from optparse import _parse_num
def variable_args(self, option, opt, value, parser):
self.assertTrue(value is None)
- done = 0
value = []
rargs = parser.rargs
while rargs:
self.assertTrue(s == "foobar")
def test_tmpnam(self):
- import sys
if not hasattr(os, "tmpnam"):
return
warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning,
self.assertEquals(result[stat.ST_SIZE], 3)
self.assertEquals(result.st_size, 3)
- import sys
-
# Make sure all the attributes are there
members = dir(result)
for name in dir(stat):
import parser
-import os
import unittest
import sys
import operator
# specified test modules (RFE #5142).
import imp
-import os
import sys
-import doctest
-import tempfile
from test import support
# This little helper class is essential for testing pdb under doctest.
import unittest
from test import support
-import sys
try:
# 3.x
from io import StringIO
"""Test suite for the profile module."""
-import os
import sys
import pstats
import unittest
import sys
import unittest
-import pyexpat
from xml.parsers import expat
from test.support import sortdict, run_unittest
# Some simple queue module tests, plus some failure conditions
# to ensure the Queue locks remain stable.
import queue
-import sys
import threading
import time
import unittest
import time
import pickle
import warnings
-from math import log, exp, sqrt, pi, fsum, sin
+from math import log, exp, pi, fsum, sin
from test import support
class TestBasicOps(unittest.TestCase):
from test.support import verbose, run_unittest
import re
from re import Scanner
-import sys, os, traceback
+import sys, traceback
from weakref import proxy
# Misc tests from Tim Peters' re.doc
self.assertRaises(TypeError, _sre.compile, {}, 0, [])
def run_re_tests():
- from test.re_tests import benchmarks, tests, SUCCEED, FAIL, SYNTAX_ERROR
+ from test.re_tests import tests, SUCCEED, FAIL, SYNTAX_ERROR
if verbose:
print('Running re_tests test suite')
else:
import operator
import copy
import pickle
-import os
from random import randrange, shuffle
import sys
import warnings
"""
import contextlib
-import errno
import imp
import os
import select
import socket
import tempfile
import threading
-import time
import unittest
import socketserver
import test.support
from test.support import reap_children, reap_threads, verbose
-from test.support import TESTFN as TEST_FILE
test.support.requires("network")
-import unittest
from test.support import run_unittest, import_module
# Skip test if _sqlite3 module not installed
from test import support
import socket
import select
-import errno
-import subprocess
import time
import os
import pprint
import urllib.parse, urllib.request
-import shutil
import traceback
import asyncore
import calendar
import sys
-import os
import re
from test import support
import time
LLONG_MAX, LLONG_MIN, ULLONG_MAX, \
PY_SSIZE_T_MAX, PY_SSIZE_T_MIN
-import warnings, unittest, sys
+import unittest
from test import support
ts=test_structmembersType(False, # T_BOOL
sys._clear_type_cache()
def test_ioencoding(self):
- import subprocess,os
+ import subprocess
env = dict(os.environ)
# Test character: cent sign, encoded as 0x4A (ASCII J) in CP424,
"""
import unittest
import sys
-import test
import os
import subprocess
import shutil
import os
import io
import shutil
-import tempfile
import io
from hashlib import md5
import errno
import os
import sys
import re
-import errno
import warnings
import unittest
import os
-import sys
import unittest
from test import support
import os
-import sys
from test import support
# Skip this test if _tkinter does not exist.
if not {'x': 1}: self.fail('{\'x\': 1} is false instead of true')
def f(): pass
class C: pass
- import sys
x = C()
if not f: self.fail('f is false instead of true')
if not C: self.fail('C is false instead of true')
import os
import socket
-import sys
import urllib.error
import urllib.request
class CloseSocketTest(unittest.TestCase):
def test_close(self):
- import socket, http.client, gc
-
# calling .close() on urllib2's response objects should close the
# underlying socket
## self._test_urls(urls, self._extra_handlers()+[bauth, dauth])
def _test_urls(self, urls, handlers, retry=True):
- import socket
import time
import logging
debug = logging.getLogger("test_urllib2").debug
# for working with modules located inside zipfiles
# The tests are centralised in this fashion to make it easy to drop them
# if a platform doesn't support zipimport
-import unittest
import test.support
import os
import os.path
import linecache
import pdb
from test.script_helper import (spawn_python, kill_python, run_python,
- temp_dir, make_script, compile_script,
- make_pkg, make_zip_script, make_zip_pkg)
+ temp_dir, make_script, make_zip_script)
verbose = test.support.verbose
projects / python / commitdiff