Skip to content

C
cpython
Commit 11e065b3 authored by Collin Winter's avatar Collin Winter
Browse files
Options

Convert test_pkg to use unittest.

parent 70e79803
Hide whitespace changes
Inline Side-by-side
Showing with 248 additions and 280 deletions
Lib/test/output/test_pkg deleted 100644 → 0
View file @ 70e79803
test_pkg
running test t1
running test t2
t2 loading
doc for t2
t2.sub.subsub loading
t2 t2.sub t2.sub.subsub
['sub', 't2']
t2.sub t2.sub.subsub
t2.sub.subsub
['spam', 'sub', 'subsub', 't2']
t2 t2.sub t2.sub.subsub
['spam', 'sub', 'subsub', 't2']
running test t3
t3 loading
t3.sub.subsub loading
t3 t3.sub t3.sub.subsub
running test t4
t4 loading
t4.sub.subsub loading
t4.sub.subsub.spam = 1
running test t5
t5.foo loading
t5.string loading
1
['foo', 'string', 't5']
['__doc__', '__file__', '__name__', '__path__', 'foo', 'string', 't5']
['__doc__', '__file__', '__name__', 'string']
['__doc__', '__file__', '__name__', 'spam']
running test t6
['__all__', '__doc__', '__file__', '__name__', '__path__']
t6.spam loading
t6.ham loading
t6.eggs loading
['__all__', '__doc__', '__file__', '__name__', '__path__', 'eggs', 'ham', 'spam']
['eggs', 'ham', 'spam', 't6']
running test t7
t7 loading
['__doc__', '__file__', '__name__', '__path__']
['__doc__', '__file__', '__name__', '__path__']
t7.sub.subsub loading
['__doc__', '__file__', '__name__', '__path__', 'spam']
t7.sub.subsub.spam = 1
Lib/test/test_pkg.py
View file @ 11e065b3
# Test packages (dotted-name import) # Test packages (dotted-name import)
import sys, os, tempfile, traceback import sys
from os import mkdir, rmdir # Can't test if these fail import os
del mkdir, rmdir import tempfile
from test.test_support import verify, verbose, TestFailed import textwrap
import traceback
import unittest
from test import test_support
# Helpers to create and destroy hierarchies.
def mkhier(root, descr): # Helpers to create and destroy hierarchies.
if not os.path.isdir(root):
mkdir(root)
for name, contents in descr:
comps = name.split()
fullname = root
for c in comps:
fullname = os.path.join(fullname, c)
if contents is None:
mkdir(fullname)
else:
if verbose: print("write", fullname)
f = open(fullname, "w")
f.write(contents)
if contents and contents[-1] != '\n':
f.write('\n')
f.close()
def mkdir(x):
if verbose: print("mkdir", x)
os.mkdir(x)
def cleanout(root): def cleanout(root):
names = os.listdir(root) names = os.listdir(root)
...@@ -37,220 +19,249 @@ def cleanout(root): ...@@ -37,220 +19,249 @@ def cleanout(root):
cleanout(fullname) cleanout(fullname)
else: else:
os.remove(fullname) os.remove(fullname)
rmdir(root) os.rmdir(root)
def rmdir(x):
if verbose: print("rmdir", x)
os.rmdir(x)
def fixdir(lst): def fixdir(lst):
try: if "__builtins__" in lst:
lst.remove('__builtins__') lst.remove("__builtins__")
except ValueError:
pass
return lst return lst
# Helper to run a test
def runtest(hier, code): # XXX Things to test
root = tempfile.mkdtemp() #
mkhier(root, hier) # import package without __init__
savepath = sys.path[:] # import package with __init__
fd, fname = tempfile.mkstemp(text=True) # __init__ importing submodule
os.write(fd, code) # __init__ importing global module
os.close(fd) # __init__ defining variables
try: # submodule importing other submodule
# submodule importing global module
# submodule import submodule via global name
# from package import submodule
# from package import subpackage
# from package import variable (defined in __init__)
# from package import * (defined in __init__)
class Test(unittest.TestCase):
def setUp(self):
self.root = None
self.syspath = list(sys.path)
def tearDown(self):
sys.path[:] = self.syspath
cleanout(self.root)
def run_code(self, code):
exec(textwrap.dedent(code), globals(), {"self": self})
def mkhier(self, descr):
root = tempfile.mkdtemp()
sys.path.insert(0, root) sys.path.insert(0, root)
if verbose: print("sys.path =", sys.path) if not os.path.isdir(root):
try: os.mkdir(root)
exec(open(fname).read(), globals(), {}) for name, contents in descr:
except: comps = name.split()
traceback.print_exc(file=sys.stdout) fullname = root
finally: for c in comps:
sys.path[:] = savepath fullname = os.path.join(fullname, c)
os.unlink(fname) if contents is None:
try: os.mkdir(fullname)
cleanout(root) else:
except (os.error, IOError): f = open(fullname, "w")
pass f.write(contents)
if contents and contents[-1] != '\n':
# Test descriptions f.write('\n')
f.close()
tests = [ self.root = root
("t1", [("t1", None), ("t1 __init__.py", "")], "import t1"),
def test_1(self):
("t2", [ hier = [("t1", None), ("t1 __init__.py", "")]
("t2", None), self.mkhier(hier)
("t2 __init__.py", "'doc for t2'; print(__name__, 'loading')"), import t1
("t2 sub", None),
("t2 sub __init__.py", ""), def test_2(self):
("t2 sub subsub", None), hier = [
("t2 sub subsub __init__.py", "print(__name__, 'loading'); spam = 1"), ("t2", None),
], ("t2 __init__.py", "'doc for t2'"),
""" ("t2 sub", None),
import t2 ("t2 sub __init__.py", ""),
print(t2.__doc__) ("t2 sub subsub", None),
import t2.sub ("t2 sub subsub __init__.py", "spam = 1"),
import t2.sub.subsub ]
print(t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__) self.mkhier(hier)
import t2
from t2 import * import t2
print(dir()) self.assertEqual(t2.__doc__, "doc for t2")
from t2 import sub
from t2.sub import subsub import t2.sub
from t2.sub.subsub import spam import t2.sub.subsub
print(sub.__name__, subsub.__name__) self.assertEqual(t2.__name__, "t2")
print(sub.subsub.__name__) self.assertEqual(t2.sub.__name__, "t2.sub")
print(dir()) self.assertEqual(t2.sub.subsub.__name__, "t2.sub.subsub")
import t2.sub
import t2.sub.subsub # This exec crap is needed because Py3k forbids 'import *' outside
print(t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__) # of module-scope and __import__() is insufficient for what we need.
from t2 import * s = """
print(dir()) import t2
"""), from t2 import *
self.assertEqual(dir(), ['self', 'sub', 't2'])
("t3", [ """
("t3", None), self.run_code(s)
("t3 __init__.py", "print(__name__, 'loading')"),
("t3 sub", None), from t2 import sub
("t3 sub __init__.py", ""), from t2.sub import subsub
("t3 sub subsub", None), from t2.sub.subsub import spam
("t3 sub subsub __init__.py", "print(__name__, 'loading'); spam = 1"), self.assertEqual(sub.__name__, "t2.sub")
], self.assertEqual(subsub.__name__, "t2.sub.subsub")
""" self.assertEqual(sub.subsub.__name__, "t2.sub.subsub")
import t3.sub.subsub for name in ['spam', 'sub', 'subsub', 't2']:
print(t3.__name__, t3.sub.__name__, t3.sub.subsub.__name__) self.failUnless(locals()["name"], "Failed to import %s" % name)
"""),
import t2.sub
("t4", [ import t2.sub.subsub
("t4.py", "print('THIS SHOULD NOT BE PRINTED (t4.py)')"), self.assertEqual(t2.__name__, "t2")
("t4", None), self.assertEqual(t2.sub.__name__, "t2.sub")
("t4 __init__.py", "print(__name__, 'loading')"), self.assertEqual(t2.sub.subsub.__name__, "t2.sub.subsub")
("t4 sub.py", "print('THIS SHOULD NOT BE PRINTED (sub.py)')"),
("t4 sub", None), s = """
("t4 sub __init__.py", ""), from t2 import *
("t4 sub subsub.py", "print('THIS SHOULD NOT BE PRINTED (subsub.py)')"), self.failUnless(dir(), ['self', 'sub'])
("t4 sub subsub", None), """
("t4 sub subsub __init__.py", "print(__name__, 'loading'); spam = 1"), self.run_code(s)
],
""" def test_3(self):
from t4.sub.subsub import * hier = [
print("t4.sub.subsub.spam =", spam) ("t3", None),
"""), ("t3 __init__.py", ""),
("t3 sub", None),
("t5", [ ("t3 sub __init__.py", ""),
("t5", None), ("t3 sub subsub", None),
("t5 __init__.py", "import t5.foo"), ("t3 sub subsub __init__.py", "spam = 1"),
("t5 string.py", "print(__name__, 'loading'); spam = 1"), ]
("t5 foo.py", self.mkhier(hier)
"print(__name__, 'loading'); from . import string; print(string.spam)"),
], import t3.sub.subsub
""" self.assertEqual(t3.__name__, "t3")
import t5 self.assertEqual(t3.sub.__name__, "t3.sub")
from t5 import * self.assertEqual(t3.sub.subsub.__name__, "t3.sub.subsub")
print(dir())
import t5 def test_4(self):
print(fixdir(dir(t5))) hier = [
print(fixdir(dir(t5.foo))) ("t4.py", "raise RuntimeError('Shouldnt load t4.py')"),
print(fixdir(dir(t5.string))) ("t4", None),
"""), ("t4 __init__.py", ""),
("t4 sub.py", "raise RuntimeError('Shouldnt load sub.py')"),
("t6", [ ("t4 sub", None),
("t6", None), ("t4 sub __init__.py", ""),
("t6 __init__.py", "__all__ = ['spam', 'ham', 'eggs']"), ("t4 sub subsub.py", "raise RuntimeError('Shouldnt load subsub.py')"),
("t6 spam.py", "print(__name__, 'loading')"), ("t4 sub subsub", None),
("t6 ham.py", "print(__name__, 'loading')"), ("t4 sub subsub __init__.py", "spam = 1"),
("t6 eggs.py", "print(__name__, 'loading')"), ]
], self.mkhier(hier)
"""
import t6 s = """
print(fixdir(dir(t6))) from t4.sub.subsub import *
from t6 import * self.assertEqual(spam, 1)
print(fixdir(dir(t6))) """
print(dir()) self.run_code(s)
"""),
def test_5(self):
("t7", [ hier = [
("t7.py", "print('Importing t7.py')"), ("t5", None),
("t7", None), ("t5 __init__.py", "import t5.foo"),
("t7 __init__.py", "print(__name__, 'loading')"), ("t5 string.py", "spam = 1"),
("t7 sub.py", "print('THIS SHOULD NOT BE PRINTED (sub.py)')"), ("t5 foo.py",
("t7 sub", None), "from . import string; assert string.spam == 1"),
("t7 sub __init__.py", ""), ]
("t7 sub subsub.py", "print('THIS SHOULD NOT BE PRINTED (subsub.py)')"), self.mkhier(hier)
("t7 sub subsub", None),
("t7 sub subsub __init__.py", "print(__name__, 'loading'); spam = 1"), import t5
], s = """
""" from t5 import *
t7, sub, subsub = None, None, None self.assertEqual(dir(), ['foo', 'self', 'string', 't5'])
import t7 as tas """
print(fixdir(dir(tas))) self.run_code(s)
verify(not t7)
from t7 import sub as subpar import t5
print(fixdir(dir(subpar))) self.assertEqual(fixdir(dir(t5)),
verify(not t7 and not sub) ['__doc__', '__file__', '__name__',
from t7.sub import subsub as subsubsub '__path__', 'foo', 'string', 't5'])
print(fixdir(dir(subsubsub))) self.assertEqual(fixdir(dir(t5.foo)),
verify(not t7 and not sub and not subsub) ['__doc__', '__file__', '__name__', 'string'])
from t7.sub.subsub import spam as ham self.assertEqual(fixdir(dir(t5.string)),
print("t7.sub.subsub.spam =", ham) ['__doc__', '__file__', '__name__', 'spam'])
verify(not t7 and not sub and not subsub)
"""), def test_6(self):
hier = [
] ("t6", None),
("t6 __init__.py", "__all__ = ['spam', 'ham', 'eggs']"),
nontests = [ ("t6 spam.py", ""),
("x5", [], ("import a" + ".a"*400)), ("t6 ham.py", ""),
("x6", [], ("import a" + ".a"*499)), ("t6 eggs.py", ""),
("x7", [], ("import a" + ".a"*500)), ]
("x8", [], ("import a" + ".a"*1100)), self.mkhier(hier)
("x9", [], ("import " + "a"*400)),
("x10", [], ("import " + "a"*500)), import t6
("x11", [], ("import " + "a"*998)), self.assertEqual(fixdir(dir(t6)),
("x12", [], ("import " + "a"*999)), ['__all__', '__doc__', '__file__',
("x13", [], ("import " + "a"*999)), '__name__', '__path__'])
("x14", [], ("import " + "a"*2000)), s = """
] import t6
from t6 import *
"""XXX Things to test self.assertEqual(fixdir(dir(t6)),
['__all__', '__doc__', '__file__',
import package without __init__ '__name__', '__path__', 'eggs',
import package with __init__ 'ham', 'spam'])
__init__ importing submodule self.assertEqual(dir(), ['eggs', 'ham', 'self', 'spam', 't6'])
__init__ importing global module """
__init__ defining variables self.run_code(s)
submodule importing other submodule
submodule importing global module def test_7(self):
submodule import submodule via global name hier = [
from package import submodule ("t7.py", ""),
from package import subpackage ("t7", None),
from package import variable (defined in __init__) ("t7 __init__.py", ""),
from package import * (defined in __init__) ("t7 sub.py", "raise RuntimeError('Shouldnt load sub.py')"),
""" ("t7 sub", None),
("t7 sub __init__.py", ""),
# Run the tests ("t7 sub subsub.py",
"raise RuntimeError('Shouldnt load subsub.py')"),
args = [] ("t7 sub subsub", None),
if __name__ == '__main__': ("t7 sub subsub __init__.py",
args = sys.argv[1:] "spam = 1"),
if args and args[0] == '-q': ]
verbose = 0 self.mkhier(hier)
del args[0]
for name, hier, code in tests: t7, sub, subsub = None, None, None
if args and name not in args: import t7 as tas
print("skipping test", name) self.assertEqual(fixdir(dir(tas)),
continue ['__doc__', '__file__', '__name__', '__path__'])
print("running test", name) self.failIf(t7)
runtest(hier, code) from t7 import sub as subpar
self.assertEqual(fixdir(dir(subpar)),
# Test ['__doc__', '__file__', '__name__', '__path__'])
import sys self.failIf(t7)
import imp self.failIf(sub)
try: from t7.sub import subsub as subsubsub
import sys.imp self.assertEqual(fixdir(dir(subsubsub)),
except ImportError: ['__doc__', '__file__', '__name__', '__path__',
# This is what we expect 'spam'])
pass self.failIf(t7)
else: self.failIf(sub)
raise TestFailed, "No ImportError exception on 'import sys.imp'" self.failIf(subsub)
from t7.sub.subsub import spam as ham
self.assertEqual(ham, 1)
self.failIf(t7)
self.failIf(sub)
self.failIf(subsub)
def test_main():
test_support.run_unittest(__name__)
if __name__ == "__main__":
test_main()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7