with self.assertRaises(TypeError):
datetime(10, 10, 10, 10, 10, 10, 10.)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
import __future__
GOOD_SERIALS = ("alpha", "beta", "candidate", "final")
".compiler_flag isn't int")
-def test_main():
- support.run_unittest(FutureTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import dis
-from test.support import run_unittest, import_module
+from test.support import import_module
import unittest
_opcode = import_module("_opcode")
self.assertRaises(ValueError, _opcode.stack_effect, dis.opmap['BUILD_SLICE'])
self.assertRaises(ValueError, _opcode.stack_effect, dis.opmap['POP_TOP'], 0)
-def test_main():
- run_unittest(OpcodeTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
result = _osx_support.get_platform_osx(config_vars, ' ', ' ', ' ')
self.assertEqual(('macosx', '10.6', 'fat'), result)
-def test_main():
- if sys.platform == 'darwin':
- test.support.run_unittest(Test_OSXSupport)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(atexit._ncallbacks(), n)
-def test_main():
- support.run_unittest(__name__)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Augmented assignment test.
-from test.support import run_unittest
import unittest
__ilshift__ called
'''.splitlines())
-def test_main():
- run_unittest(AugAssignTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
"""Test the binascii C module."""
-from test import support
import unittest
import binascii
import array
type2test = memoryview
-def test_main():
- support.run_unittest(BinASCIITest,
- ArrayBinASCIITest,
- BytearrayBinASCIITest,
- MemoryviewBinASCIITest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(op_sequence(le, B, C), ['C.__ge__', 'B.__le__'])
self.assertEqual(op_sequence(le, C, B), ['C.__le__', 'B.__ge__'])
-def test_main():
- support.run_unittest(RatTestCase, OperationOrderTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
# The test cases here cover several paths through the function calling
# code. They depend on the METH_XXX flag that is used to define a C
self.assertRaises(TypeError, [].count, x=2, y=2)
-def test_main():
- support.run_unittest(CFunctionCalls)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test.support import run_unittest
from test.script_helper import assert_python_failure, temp_dir
import unittest
import sys
self.assertNotIn('</p>', out)
-def test_main():
- run_unittest(TestCgitb)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
def test_maptoundefined(self):
self.assertRaises(UnicodeError, str, b'abc\001', codecname)
-def test_main():
- test.support.run_unittest(CharmapCodecTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
testmeths = [
a = A(hash(A.f)^(-1))
hash(a.f)
-def test_main():
- support.run_unittest(ClassTests)
-
-if __name__=='__main__':
- test_main()
+if __name__ == '__main__':
+ unittest.main()
-from test.support import run_unittest, requires_IEEE_754
+from test.support import requires_IEEE_754
from test.test_math import parse_testfile, test_file
import unittest
import cmath, math
self.assertComplexIdentical(cmath.atanh(z), z)
-def test_main():
- run_unittest(CMathTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertIn(expected, output)
-def test_main():
- support.run_unittest(TestInteractiveConsole)
-
if __name__ == "__main__":
unittest.main()
(b"ab~{\x79\x79\x41\x44~}cd", "replace", "ab\ufffd\ufffd\u804acd"),
)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
(b"abc\x80\x80\xc1\xc4", "ignore", "abc\u8b10"),
)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
def test_chunkcoding(self):
pass
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
b"\x85Gℜ\x85Q = ⟨ሴ⟩"
)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
(b"\x8CBxy", "replace", "\uFFFDBxy"),
)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
(b"abc\x80\x80\xc1\xc4", "ignore", "abc\u8b10"),
)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
Nick Mathewson
"""
import unittest
-from test.support import run_unittest, is_jython
+from test.support import is_jython
from codeop import compile_command, PyCF_DONT_IMPLY_DEDENT
import io
compile("a = 1\n", "def", 'single').co_filename)
-def test_main():
- run_unittest(CodeopTests)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
class Empty:
def __repr__(self):
self.assertEqual(Anything(), y)
-def test_main():
- support.run_unittest(ComparisonTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
from collections import deque
-from test.support import run_unittest
import unittest
self.assertTrue(container == container)
-def test_main():
- run_unittest(TestContains)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
from operator import le, lt, ge, gt, eq, ne
import unittest
-from test import support
order_comparisons = le, lt, ge, gt
equality_comparisons = eq, ne
def global_foo(x, y): return x+y
-def test_main():
- support.run_unittest(TestCopy)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import copyreg
import unittest
-from test import support
from test.pickletester import ExtensionSaver
class C:
self.assertEqual(result, expected)
-def test_main():
- support.run_unittest(CopyRegTestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
assert_python_failure(fname)
-def test_main():
- test.support.run_unittest(CrasherTest)
+def tearDownModule():
test.support.reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(fileobj.read(), expected)
-def test_main():
- mod = sys.modules[__name__]
- support.run_unittest(
- *[getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
- )
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import unittest
-from test import support
def funcattrs(**kwds):
def decorate(func):
class C(object): pass
self.assertEqual(C.extra, 'second')
-def test_main():
- support.run_unittest(TestDecorators)
- support.run_unittest(TestClassDecorators)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
import pickle
import tempfile
import unittest
-from test import support
from collections import defaultdict
o = pickle.loads(s)
self.assertEqual(d, o)
-def test_main():
- support.run_unittest(TestDefaultDict)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
type2test = Dict
-def test_main():
- support.run_unittest(
- DictTest,
- GeneralMappingTests,
- SubclassMappingTests,
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
class DictSetTest(unittest.TestCase):
self.assertRaises(RuntimeError, repr, d)
-def test_main():
- support.run_unittest(DictSetTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Minimal tests for dis module
-from test.support import run_unittest, captured_stdout
+from test.support import captured_stdout
from test.bytecode_helper import BytecodeTestCase
import difflib
import unittest
response.read())
-def test_main():
- support.run_unittest(DocXMLRPCHTTPGETServer)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
if support.verbose:
print('all tasks done')
-def test_main():
- support.run_unittest(DummyThreadingTestCase)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import contextlib
import unittest
-from test.support import run_unittest, swap_item, swap_attr
+from test.support import swap_item, swap_attr
class RebindBuiltinsTests(unittest.TestCase):
self.assertEqual(foo(), 7)
-def test_main():
- run_unittest(RebindBuiltinsTests)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import abc
import sys
import unittest
-from test.support import run_unittest
from types import DynamicClassAttribute
class PropertyBase(Exception):
-def test_main():
- run_unittest(PropertyTests, PropertySubclassTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
if __name__ == "__main__":
- test.support.run_unittest(__name__)
+ unittest.main()
(sys.maxsize+3,'c')]
-def test_main(verbose=None):
- support.run_unittest(__name__)
-
- # verify reference counting
- if verbose and hasattr(sys, "gettotalrefcount"):
- counts = [None] * 5
- for i in range(len(counts)):
- support.run_unittest(__name__)
- counts[i] = sys.gettotalrefcount()
- print(counts)
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
else:
raise support.TestFailed
-def test_main():
- support.run_unittest(EOFTestCase)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(os.get_inheritable(epoll.fileno()), False)
-def test_main():
- support.run_unittest(TestEPoll)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
"""
import errno
-from test import support
import unittest
std_c_errors = frozenset(['EDOM', 'ERANGE'])
'no %s attr in errno.errorcode' % attribute)
-def test_main():
- support.run_unittest(ErrnoAttributeTests, ErrorcodeTests)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
-from test.support import run_unittest
import unittest
class ExceptionTestCase(unittest.TestCase):
self.assertTrue(hit_finally)
self.assertTrue(hit_except)
-def test_main():
- run_unittest(ExceptionTestCase)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import signal
import subprocess
import sys
-from test.support import run_unittest
import time
import unittest
modname = '_pyio'
-def test_main():
- test_cases = [
- tc for tc in globals().values()
- if isinstance(tc, type) and issubclass(tc, unittest.TestCase)]
- run_unittest(*test_cases)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertIs(wr(), None)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.identical(x, fromHex(toHex(x)))
-def test_main():
- support.run_unittest(
- GeneralFloatCases,
- FormatFunctionsTestCase,
- UnknownFormatTestCase,
- IEEEFormatTestCase,
- FormatTestCase,
- ReprTestCase,
- RoundTestCase,
- InfNanTest,
- HexFloatTestCase,
- )
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
'<FLUFL test>', 'exec')
-def test_main():
- from test.support import run_unittest
- run_unittest(FLUFLTests)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
"""Test cases for the fnmatch module."""
-from test import support
import unittest
from fnmatch import fnmatch, fnmatchcase, translate, filter
self.assertEqual(filter(['a', 'b'], 'a'), ['a'])
-def test_main():
- support.run_unittest(FnmatchTestCase,
- TranslateTestCase,
- FilterTestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import time
from test.fork_wait import ForkWait
-from test.support import (run_unittest, reap_children, get_attribute,
+from test.support import (reap_children, get_attribute,
import_module, verbose)
threading = import_module('threading')
fork_with_import_lock(level)
-def test_main():
- run_unittest(ForkTest)
+def tearDownModule():
reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
"""Tests for Lib/fractions.py."""
from decimal import Decimal
-from test.support import run_unittest, requires_IEEE_754
+from test.support import requires_IEEE_754
import math
import numbers
import operator
r = F(13, 7)
self.assertRaises(AttributeError, setattr, r, 'a', 10)
-def test_main():
- run_unittest(FractionTest, GcdTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertEqual(inner.f_locals, {})
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test import support
import types
import unittest
self.assertEqual({'foo': 'bar'}.pop.__qualname__, 'dict.pop')
-def test_main():
- support.run_unittest(FunctionPropertiesTest, InstancemethodAttrTest,
- ArbitraryFunctionAttrTest, FunctionDictsTest,
- FunctionDocstringTest, CellTest,
- StaticMethodAttrsTest,
- BuiltinFunctionPropertiesTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
functools.WeakKeyDictionary = _orig_wkd
-def test_main(verbose=None):
- test_classes = (
- TestPartialC,
- TestPartialPy,
- TestPartialCSubclass,
- TestPartialMethod,
- TestUpdateWrapper,
- TestTotalOrdering,
- TestCmpToKeyC,
- TestCmpToKeyPy,
- TestWraps,
- TestReduce,
- TestLRU,
- TestSingleDispatch,
- )
- support.run_unittest(*test_classes)
-
- # verify reference counting
- if verbose and hasattr(sys, "gettotalrefcount"):
- import gc
- counts = [None] * 5
- for i in range(len(counts)):
- support.run_unittest(*test_classes)
- gc.collect()
- counts[i] = sys.gettotalrefcount()
- print(counts)
-
if __name__ == '__main__':
- test_main(verbose=True)
+ unittest.main()
# test_getopt.py
# David Goodger <dgoodger@bigfoot.com> 2000-08-19
-from test.support import verbose, run_doctest, run_unittest, EnvironmentVarGuard
+from test.support import verbose, run_doctest, EnvironmentVarGuard
import unittest
import getopt
self.assertEqual(longopts, [('--help', 'x')])
self.assertRaises(getopt.GetoptError, getopt.getopt, ['--help='], '', ['help'])
-def test_main():
- run_unittest(GetoptTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Python test set -- part 1, grammar.
# This just tests whether the parser accepts them all.
-from test.support import run_unittest, check_syntax_error
+from test.support import check_syntax_error
import unittest
import sys
# testing import *
self.assertEqual(m.other, 42)
-def test_main():
- run_unittest(TokenTests, GrammarTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertRaises(KeyError, grp.getgrgid, fakegid)
-def test_main():
- support.run_unittest(GroupDatabaseTestCase)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertFalse(hmac.compare_digest(a, b))
-def test_main():
- support.run_unittest(
- TestVectorsTestCase,
- ConstructorTestCase,
- SanityTestCase,
- CopyTestCase,
- CompareDigestTestCase
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import html
import unittest
-from test.support import run_unittest
class HtmlTests(unittest.TestCase):
check('123\ud800')
check('123\ud800', 10)
-def test_main():
- support.run_unittest(IntTestCases)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
"""
import unittest
-from test import support
class TestHexOctBin(unittest.TestCase):
self.assertEqual(-0b1000000000000000000000000000000000000000000000000000000000000000, -9223372036854775808)
self.assertEqual(-0b1111111111111111111111111111111111111111111111111111111111111111, -18446744073709551615)
-def test_main():
- support.run_unittest(TestHexOctBin)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import array
import unittest
-from test.support import run_unittest, import_module, get_attribute
+from test.support import import_module, get_attribute
import os, struct
fcntl = import_module('fcntl')
termios = import_module('termios')
# testing of error conditions uncovered when using extension types.
import unittest
-from test import support
import sys
fxn(arg, tuple_arg)
\f
-def test_main():
- support.run_unittest(
- TestIsInstanceExceptions,
- TestIsSubclassExceptions,
- TestIsInstanceIsSubclass
- )
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
__email__ = "seojiwon at gmail dot com"
import unittest
-from test.support import run_unittest
def posonly_sum(pos_arg1, *arg, **kwarg):
return pos_arg1 + sum(arg) + sum(kwarg.values())
self.assertEqual(str(err.exception), "name 'b' is not defined")
-def test_main():
- run_unittest(KeywordOnlyArgTestCase)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import time
import unittest
-from test import support
if not hasattr(select, "kqueue"):
raise unittest.SkipTest("test works only on BSD")
self.assertEqual(os.get_inheritable(kqueue.fileno()), False)
-def test_main():
- support.run_unittest(TestKQueue)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
with self.assertRaises(TypeError):
(3,) + L([1,2])
-def test_main(verbose=None):
- support.run_unittest(ListTest)
-
- # verify reference counting
- import sys
- if verbose and hasattr(sys, "gettotalrefcount"):
- import gc
- counts = [None] * 5
- for i in range(len(counts)):
- support.run_unittest(ListTest)
- gc.collect()
- counts[i] = sys.gettotalrefcount()
- print(counts)
-
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
self.assertEqual(type(value >> shift), int)
-def test_main():
- support.run_unittest(LongTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
class LongExpText(unittest.TestCase):
def test_longexp(self):
l = eval("[" + "2," * REPS + "]")
self.assertEqual(len(l), REPS)
-def test_main():
- support.run_unittest(LongExpText)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
self.assertEqual(mailcap.findmatch(*c[0], **c[1]), c[2])
-def test_main():
- test.support.run_unittest(HelperFunctionTest, GetcapsTest, FindmatchTest)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
pass
-def test_main():
- tests = [PyBytesIOTest, PyStringIOTest, CBytesIOTest, CStringIOTest,
- PyStringIOPickleTest, CStringIOPickleTest]
- support.run_unittest(*tests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
pass
-def test_main():
- test.support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
eq(self.db.guess_type("image.jpg"), ("image/jpeg", None))
eq(self.db.guess_type("image.png"), ("image/png", None))
-def test_main():
- support.run_unittest(MimeTypesTestCase,
- Win32MimeTypesTestCase
- )
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# test for xml.dom.minidom
import pickle
-from test.support import run_unittest, findfile
+from test.support import findfile
import unittest
import xml.dom.minidom
pi = doc.createProcessingInstruction("y", "z")
pi.nodeValue = "crash"
-def test_main():
- run_unittest(MinidomTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Test the module type
import unittest
import weakref
-from test.support import run_unittest, gc_collect
+from test.support import gc_collect
from test.script_helper import assert_python_ok
import sys
# frozen and namespace module reprs are tested in importlib.
-def test_main():
- run_unittest(ModuleTests)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
""" Test suite for the code in msilib """
import unittest
import os
-from test.support import run_unittest, import_module
+from test.support import import_module
msilib = import_module('msilib')
class Test_make_id(unittest.TestCase):
msilib.make_id(".s\x82o?*+rt"), "_.s_o___rt")
-def test_main():
- run_unittest(__name__)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
if done:
break
-def test_main():
- support.run_unittest(NisTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
-from test.support import run_unittest, open_urlresource
+from test.support import open_urlresource
import unittest
from http.client import HTTPException
normalize('NFC', '\ud55c\uae00')
-def test_main():
- run_unittest(NormalizationTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import math
import sys
import operator
-from test.support import run_unittest
from decimal import Decimal as D
from fractions import Fraction as F
self.assertRaises(TypeError, op, v, z)
-def test_main():
- run_unittest(HashTest, ComparisonTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
# Python test set -- part 2, opcodes
-from test.support import run_unittest
import unittest
class OpcodeTest(unittest.TestCase):
self.assertEqual(MyString() % 3, 42)
-def test_main():
- run_unittest(OpcodeTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
# Test to see if openpty works. (But don't worry if it isn't available.)
import os, unittest
-from test.support import run_unittest
if not hasattr(os, "openpty"):
raise unittest.SkipTest("os.openpty() not available.")
os.write(slave, b'Ping!')
self.assertEqual(os.read(master, 1024), b'Ping!')
-def test_main():
- run_unittest(OpenptyTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
Test suite for OS X interpreter environment variables.
"""
-from test.support import EnvironmentVarGuard, run_unittest
+from test.support import EnvironmentVarGuard
import subprocess
import sys
import sysconfig
with self.assertRaises(TypeError):
parser.expr("a", "b")
-def test_main():
- support.run_unittest(
- RoundtripLegalSyntaxTestCase,
- IllegalSyntaxTestCase,
- CompileTestCase,
- ParserStackLimitTestCase,
- STObjectTestCase,
- OtherParserCase,
- )
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
f()
-def test_main(verbose=None):
- import sys
- from test import support
- test_classes = (TestTranforms, TestBuglets)
- support.run_unittest(*test_classes)
-
- # verify reference counting
- if verbose and hasattr(sys, 'gettotalrefcount'):
- import gc
- counts = [None] * 5
- for i in range(len(counts)):
- support.run_unittest(*test_classes)
- gc.collect()
- counts[i] = sys.gettotalrefcount()
- print(counts)
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
import hmac
import unittest
from hashlib import md5, sha1, sha224, sha256, sha384, sha512
-from test import support
class Pep247Test(unittest.TestCase):
def test_hmac(self):
self.check_module(hmac, key=b'abc')
-def test_main():
- support.run_unittest(Pep247Test)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
'tim likes to eat a bag of ham worth $100')
-def test_main():
- from test import support
- test_classes = [TestTemplate,]
- support.run_unittest(*test_classes)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
# This file is marked as binary in the CVS, to prevent MacCVS from recoding it.
import unittest
-from test import support
class PEP3120Test(unittest.TestCase):
self.assertEqual('Ç', ns['u'])
-def test_main():
- support.run_unittest(PEP3120Test, BuiltinCompileTests)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
import unittest
import sys
-from test import support
class PEP3131Test(unittest.TestCase):
else:
self.fail("expected exception didn't occur")
-def test_main():
- support.run_unittest(PEP3131Test)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
import errno
from errno import EEXIST
-from test import support
class SubOSError(OSError):
pass
self.assertEqual(str(e), '')
-def test_main():
- support.run_unittest(__name__)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
self.assertEqual(v, (1, 2, 3, 4))
-def test_main():
- from test import support
- test_classes = [TestPEP380Operation]
- support.run_unittest(*test_classes)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import t8
self.assertEqual(t8.__doc__, "doc for t8")
-def test_main():
- support.run_unittest(__name__)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
from importlib.util import cache_from_source
-from test.support import run_unittest, create_empty_file
+from test.support import create_empty_file
class TestImport(unittest.TestCase):
self.assertEqual(getattr(module, var), 1)
-def test_main():
- run_unittest(TestImport)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
with os.popen("echo hello") as f:
self.assertEqual(list(f), ["hello\n"])
-def test_main():
- support.run_unittest(PopenTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
eq(pow(a, -fiveto), expected)
eq(expected, 1.0) # else we didn't push fiveto to evenness
-def test_main():
- test.support.run_unittest(PowTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import sys
import unittest
-from test.support import run_unittest
class PropertyBase(Exception):
pass
-def test_main():
- run_unittest(PropertyTests, PropertySubclassTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
stats.add(self.stats, self.stats)
-def test_main():
- support.run_unittest(
- AddCallersTestCase,
- StatsTestCase,
- )
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test.support import verbose, run_unittest, import_module, reap_children
+from test.support import verbose, import_module, reap_children
# Skip these tests if termios is not available
import_module('termios')
pty._copy(masters[0])
-def test_main(verbose=None):
- try:
- run_unittest(SmallPtyTests, PtyTest)
- finally:
- reap_children()
+def tearDownModule():
+ reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
from xml.sax.xmlreader import AttributesImpl
from xml.dom import pulldom
-from test.support import run_unittest, findfile
+from test.support import findfile
tstfile = findfile("test.xml", subdir="xmltestdata")
doc.unlink()
-def test_main():
- run_unittest(PullDOMTestCase, ThoroughTestCase, SAX2DOMTestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertRaises(KeyError, pwd.getpwuid, 2**128)
self.assertRaises(KeyError, pwd.getpwuid, -2**128)
-def test_main():
- support.run_unittest(PwdTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
Test cases for pyclbr.py
Nick Mathewson
'''
-from test.support import run_unittest
import sys
from types import FunctionType, MethodType, BuiltinFunctionType
import pyclbr
self.assertRaises(ImportError, pyclbr.readmodule_ex, 'asyncore.foo')
-def test_main():
- run_unittest(PyclbrTest)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
from xml.parsers import expat
from xml.parsers.expat import errors
-from test.support import sortdict, run_unittest
+from test.support import sortdict
class SetAttributeTest(unittest.TestCase):
self.assertEqual(handler_call_args, [("bar", "baz")])
-def test_main():
- run_unittest(SetAttributeTest,
- ParseTest,
- NamespaceSeparatorTest,
- InterningTest,
- BufferTextTest,
- HandlerExceptionTest,
- PositionTest,
- sf1296433Test,
- ChardataBufferTest,
- MalformedInputTest,
- ErrorMessageTest,
- ForeignDTDTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.failing_queue_test(q)
-def test_main():
- support.run_unittest(QueueTest, LifoQueueTest, PriorityQueueTest,
- FailingQueueTest)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test import support
import unittest
import sys, os, io, subprocess
p = p.decode('latin-1')
self.assertEqual(cout.splitlines(), p.splitlines())
-def test_main():
- support.run_unittest(QuopriTestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.fail("No exception raised")
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
unittest.main()
with self.assertRaises(AttributeError):
del rangeobj.step
-def test_main():
- test.support.run_unittest(RangeTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import os
import tempfile
import unittest
-from test.support import run_unittest, import_module, unlink
+from test.support import import_module, unlink
from test.script_helper import assert_python_ok
# Skip tests if there is no readline module
self.assertEqual(stdout, b'')
-def test_main():
- run_unittest(TestHistoryManipulation, TestReadline)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertIs(op(x, y), True)
-def test_main():
- support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test import support
import unittest
import builtins
import rlcompleter
['egg.{}('.format(x) for x in dir(str)
if x.startswith('s')])
-def test_main():
- support.run_unittest(TestRlcompleter)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import importlib, importlib.machinery, importlib.util
import py_compile
from test.support import (
- forget, make_legacy_pyc, run_unittest, unload, verbose, no_tracing,
+ forget, make_legacy_pyc, unload, verbose, no_tracing,
create_empty_file)
from test.script_helper import (
make_pkg, make_script, make_zip_pkg, make_zip_script, temp_dir)
import unittest
import weakref
-from test.support import check_syntax_error, cpython_only, run_unittest
+from test.support import check_syntax_error, cpython_only
class ScopeTests(unittest.TestCase):
self.assertIsNone(ref())
-def test_main():
- run_unittest(ScopeTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
a[:] = [F()] * 10
self.assertEqual(select.select([], a, []), ([], a[:5], []))
-def test_main():
- support.run_unittest(SelectTestCase)
+def tearDownModule():
support.reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
import string
import unittest
-from test import support
# The original test data set was from shellwords, by Hartmut Goebel.
if methname.startswith("test") and methname != "testCompat":
delattr(ShlexTest, methname)
-def test_main():
- support.run_unittest(ShlexTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
(exitcode, stdout))
-def test_main():
- try:
- support.run_unittest(GenericTests, PosixTests, InterProcessSignalTests,
- WakeupFDTests, WakeupSignalTests,
- WakeupSocketSignalTests,
- SiginterruptTest, ItimerTest, WindowsSignalTests,
- PendingSignalsTests)
- finally:
- support.reap_children()
-
+def tearDownModule():
+ support.reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
# tests for slice objects; in particular the indices method.
import unittest
-from test import support
from pickle import loads, dumps
import itertools
self.assertEqual(s.indices(15), t.indices(15))
self.assertNotEqual(id(s), id(t))
-def test_main():
- support.run_unittest(SliceTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
server.quit()
-def test_main():
- support.run_unittest(SmtpTest, SmtpSSLTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
#==============================================================================
-def test_main(verbose=None):
- test_classes = (
- TestBase,
- TestDecorateSortUndecorate,
- TestBugs,
- )
-
- support.run_unittest(*test_classes)
-
- # verify reference counting
- if verbose and hasattr(sys, "gettotalrefcount"):
- import gc
- counts = [None] * 5
- for i in range(len(counts)):
- support.run_unittest(*test_classes)
- gc.collect()
- counts[i] = sys.gettotalrefcount()
- print(counts)
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
startfile(empty)
startfile(empty, "open")
-def test_main():
- support.run_unittest(TestCase)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
import unittest, string
-from test import support
class ModuleTest(unittest.TestCase):
self.assertIn("recursion", str(err.exception))
-def test_main():
- support.run_unittest(ModuleTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Since we don't have them, this test checks only a few code points.
import unittest
-from test import support
from stringprep import *
# h.update(data)
# print p, h.hexdigest()
-def test_main():
- support.run_unittest(StringprepTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import shutil
import tempfile
import unittest
-import test.support
TEMPLATE = r"""# coding: %s
self.check_encoding("latin9")
-def test_main():
- test.support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
locale.setlocale(locale.LC_TIME, locale_info)
-def test_main():
- support.run_unittest(
- getlang_Tests,
- LocaleTime_Tests,
- TimeRETests,
- StrptimeTests,
- Strptime12AMPMTests,
- JulianTests,
- CalculationTests,
- CacheTests
- )
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
for s in test_strings:
self.check_strtod(s)
-def test_main():
- test.support.run_unittest(StrtodTests)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertRaises(StopIteration, next, it)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
ts.T_USHORT = USHRT_MAX+1
-def test_main(verbose=None):
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
import os
import time
import unittest
-from test import support
class StructSeqTest(unittest.TestCase):
self.assertEqual(list(t[start:stop:step]),
L[start:stop:step])
-def test_main():
- support.run_unittest(StructSeqTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import sys
import unittest
-from test import support
class A:
self.assertRaises(TypeError, X.meth, c)
-def test_main():
- support.run_unittest(TestSuper)
-
-
if __name__ == "__main__":
unittest.main()
import symtable
import unittest
-from test import support
TEST_CODE = """
symbols = symtable.symtable("def f(x): return x", "?", "exec")
-def test_main():
- support.run_unittest(SymtableTest)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import sys
import unittest
-from test import support
class TestGetProfile(unittest.TestCase):
def setUp(self):
pprint.pprint(capture_events(callable))
-def test_main():
- support.run_unittest(
- TestGetProfile,
- ProfileHookTestCase,
- ProfileSimulatorTestCase
- )
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
syslog.openlog()
syslog.syslog('test message from python test_syslog')
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(data, b''.join(want[:-1]))
-def test_main(verbose=None):
- support.run_unittest(GeneralTests, ReadTests, WriteTests, OptionTests,
- ExpectTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertFalse(os.path.exists(name))
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
pass
-def test_main():
- support.run_unittest(ThreadRunningTests, BarrierTest, LockTests,
- TestForkInThread)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import time
from textwrap import dedent
-from test.support import run_unittest
from test.support import captured_stdout
from test.support import captured_stderr
self.assert_exc_string(error_stringio.getvalue(), 'ZeroDivisionError')
-def test_main():
- run_unittest(TestTimeit)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertLess(a, b)
self.assertLess(b, c)
-def test_main():
- support.run_unittest(TupleTest)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
"""Unit tests for __instancecheck__ and __subclasscheck__."""
import unittest
-from test import support
class ABC(type):
self.assertEqual(isinstance(42, (SubInt,)), False)
-def test_main():
- support.run_unittest(TypeChecksTest)
-
-
if __name__ == "__main__":
unittest.main()
# Python test set -- part 6, built-in types
-from test.support import run_unittest, run_with_locale
+from test.support import run_with_locale
import collections
import pickle
import locale
self.assertEqual(ns, ns_roundtrip, pname)
-def test_main():
- run_unittest(TypesTests, MappingProxyTests, ClassCreationTests,
- SimpleNamespaceTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
)
-def test_main():
- support.run_unittest(UnicodeNamesTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
"""Test compiler changes for unary ops (+, -, ~) introduced in Python 2.2"""
import unittest
-from test.support import run_unittest
class UnaryOpTestCase(unittest.TestCase):
self.assertRaises(TypeError, eval, "~2.0")
-def test_main():
- run_unittest(UnaryOpTestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(len(lines), 1,
r"\u%.4x should not be a linebreak" % i)
-def test_main():
- test.support.run_unittest(
- UnicodeMiscTest,
- UnicodeMethodsTest,
- UnicodeFunctionsTest
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-def test_main():
- support.run_unittest(
- UserDictTest,
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(u, v)
self.assertEqual(type(u), type(v))
-def test_main():
- support.run_unittest(UserListTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import subprocess
import sys
import tempfile
-from test.support import (captured_stdout, captured_stderr, run_unittest,
+from test.support import (captured_stdout, captured_stderr,
can_symlink, EnvironmentVarGuard, rmtree)
import textwrap
import unittest
self.assert_pip_not_installed()
-def test_main():
- run_unittest(BasicTest, EnsurePipTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import time
import unittest
from test.fork_wait import ForkWait
-from test.support import run_unittest, reap_children
+from test.support import reap_children
if not hasattr(os, 'fork'):
raise unittest.SkipTest("os.fork not defined")
self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
self.assertTrue(rusage)
-def test_main():
- run_unittest(Wait3Test)
+def tearDownModule():
reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
import time
import sys
from test.fork_wait import ForkWait
-from test.support import run_unittest, reap_children, get_attribute
+from test.support import reap_children, get_attribute
# If either of these do not exist, skip this test.
get_attribute(os, 'fork')
self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
self.assertTrue(rusage)
-def test_main():
- run_unittest(Wait4Test)
+def tearDownModule():
reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
-from test import support
from weakref import proxy, ref, WeakSet
import operator
import copy
self.assertLessEqual(n2, n1)
-def test_main(verbose=None):
- support.run_unittest(TestWeakSet)
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
return __have_soundcard_cache
-def test_main():
- support.run_unittest(BeepTest, MessageBeepTest, PlaySoundTest)
-
-if __name__=="__main__":
- test_main()
+if __name__ == "__main__":
+ unittest.main()
import unittest
from collections import deque
from contextlib import _GeneratorContextManager, contextmanager
-from test.support import run_unittest
class MockContextManager(_GeneratorContextManager):
self.assertEqual(10, b1)
self.assertEqual(20, b2)
-def test_main():
- run_unittest(FailureTestCase, NonexceptionalTestCase,
- NestedNonexceptionalTestCase, ExceptionalTestCase,
- NonLocalFlowControlTestCase,
- AssignmentTargetTestCase,
- ExitSwallowsExceptionTestCase,
- NestedWith)
-
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertEqual(side_effects['close_called'], True)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
-from test import support
import unittest
import xdrlib
def test_uhyper(self):
self.assertRaisesConversion(self.packer.pack_uhyper, 'string')
-def test_main():
- support.run_unittest(XDRTest)
- support.run_unittest(ConversionErrorTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertIn(os.path.normcase(run_name.encode('utf-8')), data)
-def test_main():
- test.support.run_unittest(ZipSupportTests)
+def tearDownModule():
test.support.reap_children()
if __name__ == '__main__':
- test_main()
+ unittest.main()
"""
-def test_main():
- support.run_unittest(
- VersionTestCase,
- ChecksumTestCase,
- ChecksumBigBufferTestCase,
- ExceptionTestCase,
- CompressTestCase,
- CompressObjectTestCase
- )
-
if __name__ == "__main__":
- unittest.main() # XXX
- ###test_main()
+ unittest.main()
projects / python / commitdiff