Lib.test.test_import_jy.py Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-standalone Show documentation
Show all versions of jython-standalone Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
# -*- coding: utf-8 -*-
"""Misc. import tests
Made for Jython.
"""
from __future__ import with_statement
import imp
import os
import shutil
import sys
import tempfile
import unittest
import subprocess
import zipfile
from test import test_support
from test_chdir import read, safe_mktemp, COMPILED_SUFFIX
class MislabeledImportTestCase(unittest.TestCase):
def setUp(self):
self.dir = tempfile.mkdtemp()
self.orig_cwd = os.getcwd()
os.chdir(self.dir)
self.orig_syspath = sys.path
sys.path.append('')
def tearDown(self):
shutil.rmtree(self.dir)
os.chdir(self.orig_cwd)
sys.path = self.orig_syspath
def test_renamed_bytecode(self):
source = safe_mktemp(dir=self.dir, suffix='.py')
fp = open(source, 'w')
fp.write("test = 'imported'")
fp.close()
module = os.path.basename(source)[:-3]
compiled = module + COMPILED_SUFFIX
# Compile to bytecode
module_obj = __import__(module)
self.assertEquals(module_obj.test, 'imported')
self.assert_(os.path.exists(compiled))
# Rename the bytecode
compiled_moved = safe_mktemp(dir=self.dir, suffix=COMPILED_SUFFIX)
os.rename(compiled, compiled_moved)
# Ensure we can still import the renamed bytecode
moved_module = os.path.basename(compiled_moved)[:-len(COMPILED_SUFFIX)]
module_obj = __import__(moved_module)
self.assertEquals(module_obj.__file__, os.path.basename(compiled_moved))
self.assertEquals(module_obj.test, 'imported')
def test_dunder_init(self):
os.mkdir('dunder_init_test')
# typical import: dunder_init_test.__init__$py.class is actually
# compiled with a class name of dunder_init_test
init = os.path.join('dunder_init_test', '__init__.py')
fp = open(init, 'w')
fp.write("bar = 'test'")
fp.close()
module_obj = __import__('dunder_init_test')
self.assertEquals(module_obj.__file__, init)
self.assertEquals(module_obj.bar, 'test')
init_compiled = init[:-3] + COMPILED_SUFFIX
self.assert_(os.path.exists(init_compiled))
bytecode = read(init_compiled)
# trigger an abnormal import of dunder_init_test.__init__; ask for it
# by the mismatched __init__ name
fp = open(os.path.join('dunder_init_test', 'test.py'), 'w')
fp.write("import __init__; baz = __init__.bar + 'test'; "
"init_file = __init__.__file__")
fp.close()
module_obj = __import__('dunder_init_test.test')
self.assertEquals(module_obj.test.baz, 'testtest')
self.assertEqual(module_obj.test.init_file,
os.path.join('dunder_init_test',
'__init__' + COMPILED_SUFFIX))
# Ensure a recompile of __init__$py.class wasn't triggered to
# satisfy the abnormal import
self.assertEquals(bytecode, read(init_compiled),
'bytecode was recompiled')
# Ensure load_module can still load it as dunder_init_test (doesn't
# recompile)
module_obj = imp.load_module('dunder_init_test',
*imp.find_module('dunder_init_test'))
self.assertEquals(module_obj.bar, 'test')
# Again ensure we didn't recompile
self.assertEquals(bytecode, read(init_compiled),
'bytecode was recompiled')
def test_corrupt_bytecode(self):
f = open("empty$py.class", "w")
f.close()
self.assertRaises(ImportError, __import__, "empty")
class OverrideBuiltinsImportTestCase(unittest.TestCase):
def test_override(self):
modname = os.path.__name__
tests = [
("import os.path" , "('os.path', None, -1, 'os')"),
("import os.path as path2", "('os.path', None, -1, 'os')"),
("from os.path import *" ,
"('os.path', ('*',), -1, '%s')" % modname),
("from os.path import join",
"('os.path', ('join',), -1, '%s')" % modname),
("from os.path import join as join2",
"('os.path', ('join',), -1, '%s')" % modname),
("from os.path import join as join2, split as split2",
"('os.path', ('join', 'split'), -1, '%s')" % modname),
]
import sys
# Replace __builtin__.__import__ to trace the calls
import __builtin__
oldimp = __builtin__.__import__
try:
def __import__(name, globs, locs, fromlist, level=-1):
mod = oldimp(name, globs, locs, fromlist, level)
globs["result"] = str((name, fromlist, level, mod.__name__))
raise ImportError
__builtin__.__import__ = __import__
failed = 0
for statement, expected in tests:
try:
c = compile(statement, "", "exec")
exec c in locals(), globals()
raise Exception("ImportError expected.")
except ImportError:
pass
self.assertEquals(expected, result)
finally:
__builtin__.__import__ = oldimp
class ImpTestCase(unittest.TestCase):
def test_imp_find_module_builtins(self):
self.assertEqual(imp.find_module('sys'), (None, 'sys', ('', '', 6)))
self.assertEqual(imp.find_module('__builtin__'),
(None, '__builtin__', ('', '', 6)))
def test_imp_is_builtin(self):
self.assertTrue(all(imp.is_builtin(mod)
for mod in ['sys', '__builtin__']))
self.assertFalse(imp.is_builtin('os'))
def test_load_compiled(self):
compiled = os.__file__
if compiled.endswith('.py'):
compiled = compiled[:-3] + COMPILED_SUFFIX
os.__doc__ = 'foo'
self.assertEqual(os, imp.load_compiled("os", compiled))
self.assertFalse(os.__doc__ == 'foo')
with open(compiled, 'rb') as fp:
os.__doc__ = 'foo'
self.assertEqual(os, imp.load_compiled("os", compiled, fp))
self.assertFalse(os.__doc__ == 'foo')
def test_getattr_module(self):
'''Replacing __getattr__ in a class shouldn't lead to calls to __getitem__
http://bugs.jython.org/issue438108'''
from test import anygui
# causes a stack overflow if the bug occurs
self.assertRaises(Exception, getattr, anygui, 'abc')
def test_import_star(self):
self.assertEquals(0, subprocess.call(
[sys.executable, test_support.findfile("import_star_from_java.py")]))
def test_selfreferential_classes(self):
from org.python.tests.inbred import Metis
from org.python.tests.inbred import Zeus
self.assertEquals(Metis, Zeus.Athena.__bases__[0])
self.assertEquals(Zeus, Metis.__bases__[0])
def test_sys_modules_deletion(self):
self.assertRaises(ZeroDivisionError, __import__, 'test.module_deleter')
#XXX: this is probably a good test to push upstream to CPython.
if hasattr(os, "symlink"):
def test_symlinks(self):
# Ensure imports work over symlinks. Did not work in Jython from
# 2.1 to 2.5.0, fixed in 2.5.1 See
# http://bugs.jython.org/issue645615.
sym = test_support.TESTFN+"1"
try:
os.mkdir(test_support.TESTFN)
init = os.path.join(test_support.TESTFN, "__init__.py")
with open(init, 'w') as fp:
fp.write("test = 'imported'")
os.symlink(test_support.TESTFN, sym)
module = os.path.basename(sym)
module_obj = __import__(module)
self.assertEquals(module_obj.test, 'imported')
finally:
shutil.rmtree(test_support.TESTFN)
test_support.unlink(sym)
def test_issue1811(self):
# Previously this blew out the stack
from test.issue1811 import foo
self.assertTrue(foo.issue1811.foo is foo)
def test_issue1952(self):
# CPython 2.x ignores non-dict's in second arg to __import__
# The following threw an exception in Jython previously.
__import__("os", [], level=-1)
class UnicodeNamesTestCase(unittest.TestCase):
def test_import_non_ascii_module(self):
module = "mødülé"
with self.assertRaises(ImportError) as cm:
__import__(module)
def test_import_unicode_module(self):
module = u"mødülé"
with self.assertRaises(UnicodeEncodeError) as cm:
__import__(module)
self.assertEqual(cm.exception.encoding, "ascii")
self.assertEqual(cm.exception.object, module)
self.assertEqual(cm.exception.reason, "ordinal not in range(128)")
class MixedImportTestCase(unittest.TestCase):
#
# This test case depends on material in a file structure unpacked
# from an associated ZIP archive. The test depends on Python source
# and Java class files. The archive also contains the Java source
# from which the class files may be regenerated if necessary.
#
# To regenerate the class files, explode the archive in a
# convenient spot on the file system and compile them with javac at
# the lowest supported code standard (currently Java 7), e.g. (posh)
# PS jython-trunk> cd mylib
# PS mylib> javac $(get-childitem -Recurse -Name -Include "*.java")
# or the equivalent Unix command using find.
ZIP = test_support.findfile("test_import_jy.zip")
@classmethod
def setUpClass(cls):
td = tempfile.mkdtemp()
cls.source = os.path.join(td, "test.py")
cls.setpath = "import sys; sys.modules[0] = r'" + td + "'"
zip = zipfile.ZipFile(cls.ZIP, 'r')
zip.extractall(td)
cls.tmpdir = td
@classmethod
def tearDownClass(cls):
td = cls.tmpdir
if td and os.path.isdir(td):
test_support.rmtree(td)
def make_prog(self, *script):
"Write a program to test.py"
with open(self.source, "wt") as f:
print >> f, MixedImportTestCase.setpath
for line in script:
print >> f, line
print >> f, "raise SystemExit"
def run_prog(self):
# Feed lines to interpreter and capture output
process = subprocess.Popen([sys.executable, "-S", MixedImportTestCase.source],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = process.communicate()
retcode = process.poll()
if retcode:
raise subprocess.CalledProcessError(retcode, sys.executable, output=err)
return output
def module_regex(self, module):
"Partial filename from module"
sep = "\\" + os.path.sep
return sep + module.replace('.', sep)
def check_package(self, line, module):
target = "Executed: .*" + self.module_regex(module) + "\\" + os.path.sep \
+ r"__init__(\.py|\$py\.class|\.pyc)"
self.assertRegexpMatches(line, target)
def check_module(self, line, module):
"Check output from loading a module"
target = "Executed: .*" + self.module_regex(module) + r"(\.py|\$py\.class|\.pyc)"
self.assertRegexpMatches(line, target)
def test_import_to_program(self):
# A Python module in a Python program
self.make_prog("import a.b.c.m", "print repr(a.b.c.m)")
out = self.run_prog().splitlines()
self.check_package(out[0], "a")
self.check_package(out[1], "a.b")
self.check_package(out[2], "a.b.c")
self.check_module(out[3], "a.b.c.m")
self.assertRegexpMatches(out[4], r"\")
def test_import_to_program_no_magic(self):
# A Python module in a Python program (issue 2654)
self.make_prog("import a.b, a.b.c", "print repr(a.b.m3)")
try:
out = self.run_prog()
self.fail("reference to a.b.m3 did not raise exception")
except subprocess.CalledProcessError as e:
self.assertRegexpMatches(e.output, r"AttributeError: .* has no attribute 'm3'")
def test_import_relative_implicit(self):
# A Python module by implicit relative import (no dots)
self.make_prog("import a.b.m3")
out = self.run_prog().splitlines()
self.check_package(out[0], "a")
self.check_package(out[1], "a.b")
self.check_module(out[2], "a.b.m3")
self.check_package(out[3], "a.b.c")
self.check_module(out[4], "a.b.c.m")
self.assertRegexpMatches(out[5], r"\")
def test_import_absolute_implicit(self):
# A built-in module by absolute import (but relative must be tried first)
self.make_prog("import a.b.m4")
out = self.run_prog().splitlines()
self.check_package(out[0], "a")
self.check_package(out[1], "a.b")
self.check_module(out[2], "a.b.m4")
self.assertRegexpMatches(out[3], r"\")
def test_import_from_module(self):
# A Python module by from-import
self.make_prog("import a.b.m5")
out = self.run_prog().splitlines()
self.check_package(out[0], "a")
self.check_package(out[1], "a.b")
self.check_module(out[2], "a.b.m5")
self.check_package(out[3], "a.b.c")
self.check_module(out[4], "a.b.c.m")
self.assertRegexpMatches(out[5], r"\")
self.assertRegexpMatches(out[6], r"1 2")
def test_import_from_relative_module(self):
# A Python module by relative from-import
self.make_prog("import a.b.m6")
out = self.run_prog().splitlines()
self.check_package(out[0], "a")
self.check_package(out[1], "a.b")
self.check_module(out[2], "a.b.m6")
self.check_package(out[3], "a.b.c")
self.check_module(out[4], "a.b.c.m")
self.assertRegexpMatches(out[5], r"\")
self.assertRegexpMatches(out[6], r"1 2")
def check_java_package(self, line, module):
target = r"\"
self.assertRegexpMatches(line, target)
def test_import_java_java(self):
# A Java class in a Java package by from-import
self.make_prog("from jpkg.j import K", "print repr(K)")
out = self.run_prog().splitlines()
self.assertRegexpMatches(out[0], r"\")
def test_import_java_java_magic(self):
# A Java class in a Java package
# with implicit sub-module and class import
self.make_prog(
"import jpkg",
"print repr(jpkg)",
"print repr(jpkg.j)",
"print repr(jpkg.j.K)",
"print repr(jpkg.L)")
out = self.run_prog().splitlines()
self.check_java_package(out[0], "jpkg")
self.check_java_package(out[1], "jpkg.j")
self.assertRegexpMatches(out[2], r"\")
self.assertRegexpMatches(out[3], r"\")
def test_import_java_python(self):
# A Java class in a Python package by from-import
self.make_prog("from mix.b import K1", "print repr(K1)")
out = self.run_prog().splitlines()
self.check_package(out[0], "mix")
self.check_package(out[1], "mix.b")
self.assertRegexpMatches(out[2], r"\")
def test_import_java_python_magic(self):
# A Java class in a Python package
# with implicit sub-module and class import
self.make_prog(
"import mix",
"print repr(mix.b)",
"print repr(mix.b.K1)",
"import mix.b",
"print repr(mix.b)",
"print repr(mix.b.K1)",
"print repr(mix.J1)")
out = self.run_prog().splitlines()
self.check_package(out[0], "mix")
self.check_java_package(out[1], "mix.b")
self.assertRegexpMatches(out[2], r"\")
self.check_package(out[3], "mix.b")
self.assertRegexpMatches(out[4], r"\")
self.assertRegexpMatches(out[5], r"\")
self.assertRegexpMatches(out[6], r"\")
def test_import_javapkg_python(self):
# A Java package in a Python package
self.make_prog("import mix.j", "print repr(mix.j)", "print repr(mix.j.K2)")
out = self.run_prog().splitlines()
self.check_package(out[0], "mix")
self.check_java_package(out[1], "mix.j")
self.assertRegexpMatches(out[2], r"\")
def test_import_java_from_javapkg(self):
# A Java class in a Java package in a Python package
self.make_prog("from mix.j import K2", "print repr(K2)")
out = self.run_prog().splitlines()
self.check_package(out[0], "mix")
self.assertRegexpMatches(out[1], r"\")
def test_import_javapkg_magic(self):
# A Java class in a Java package in a Python package
# with implicit sub-module and class import
self.make_prog(
"import mix",
"print repr(mix.J1)",
"print repr(mix.j)",
"print repr(mix.j.K2)",
)
out = self.run_prog().splitlines()
self.check_package(out[0], "mix")
self.assertRegexpMatches(out[1], r"\")
self.check_java_package(out[2], "mix.j")
self.assertRegexpMatches(out[3], r"\")
def test_main():
test_support.run_unittest(
MislabeledImportTestCase,
OverrideBuiltinsImportTestCase,
ImpTestCase,
UnicodeNamesTestCase,
MixedImportTestCase
)
if __name__ == '__main__':
test_main()