def setClassLoaderAndCheck(self, orig_jar, prefix, compile_path=''):
# Create a new jar and compile prefer_compiled into it
orig_jar = test_support.findfile(orig_jar)
jar = os.path.join(self.temp_dir, os.path.basename(orig_jar))
shutil.copy(orig_jar, jar)
code = os.path.join(self.temp_dir, 'prefer_compiled.py')
fp = open(code, 'w')
fp.write('compiled = True')
fp.close()
py_compile.compile(code)
zip = zipfile.ZipFile(jar, 'a')
zip.write(os.path.join(self.temp_dir, 'prefer_compiled$py.class'),
os.path.join(compile_path, 'jar_pkg',
'prefer_compiled$py.class'))
zip.close()
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
import flat_in_jar
self.assertEquals(flat_in_jar.value, 7)
import jar_pkg
self.assertEquals(prefix + '/jar_pkg/__init__.py', jar_pkg.__file__)
from jar_pkg import prefer_compiled
self.assertEquals(prefix + '/jar_pkg/prefer_compiled$py.class', prefer_compiled.__file__)
self.assert_(prefer_compiled.compiled)
self.assertRaises(NameError, __import__, 'flat_bad')
self.assertRaises(NameError, __import__, 'jar_pkg.bad')
def setClassLoaderAndCheck(self, orig_jar, prefix, compile_path=''):
# Create a new jar and compile prefer_compiled into it
orig_jar = test_support.findfile(orig_jar)
jar = os.path.join(self.temp_dir, os.path.basename(orig_jar))
shutil.copy(orig_jar, jar)
code = os.path.join(self.temp_dir, 'prefer_compiled.py')
fp = open(code, 'w')
fp.write('compiled = True')
fp.close()
py_compile.compile(code)
zip = zipfile.ZipFile(jar, 'a')
zip.write(
os.path.join(self.temp_dir, 'prefer_compiled$py.class'),
os.path.join(compile_path, 'jar_pkg', 'prefer_compiled$py.class'))
zip.close()
Thread.currentThread(
).contextClassLoader = test_support.make_jar_classloader(jar)
import flat_in_jar
self.assertEquals(flat_in_jar.value, 7)
import jar_pkg
self.assertEquals(prefix + '/jar_pkg/__init__.py', jar_pkg.__file__)
from jar_pkg import prefer_compiled
self.assertEquals(prefix + '/jar_pkg/prefer_compiled$py.class',
prefer_compiled.__file__)
self.assert_(prefer_compiled.compiled)
self.assertRaises(NameError, __import__, 'flat_bad')
self.assertRaises(NameError, __import__, 'jar_pkg.bad')
def test_path_in_pyclasspath(self):
jar = self.prepareJar('classimport_Lib.jar')
compiled = self.compileToJar(jar, 'Lib')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
with test_support.DirsOnSysPath():
sys.path = ['__pyclasspath__/Lib']
self.checkImports('__pyclasspath__/Lib', compiled)
def test_path_in_pyclasspath(self):
jar = self.prepareJar('classimport_Lib.jar')
compiled = self.compileToJar(jar, 'Lib')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
with test_support.DirsOnSysPath():
sys.path = ['__pyclasspath__/Lib']
self.checkImports('__pyclasspath__/Lib', compiled)
def test_loader_is_package(self):
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
mod_name = 'flat_in_jar'
loader = pkgutil.get_loader(mod_name)
self.assertFalse(loader.is_package(mod_name))
self.assertTrue(loader.is_package('jar_pkg'))
self.assertFalse(loader.is_package('jar_pkg.prefer_compiled'))
def test_pkgutil_get_data(self):
# Test loader.get_data used via pkgutil
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
data = pkgutil.get_data('jar_pkg', name)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
def test_loader_is_package(self):
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
mod_name = 'flat_in_jar'
loader = pkgutil.get_loader(mod_name)
self.assertFalse(loader.is_package(mod_name))
self.assertTrue(loader.is_package('jar_pkg'))
self.assertFalse(loader.is_package('jar_pkg.prefer_compiled'))
def test_pkgutil_get_data(self):
# Test loader.get_data used via pkgutil
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
data = pkgutil.get_data('jar_pkg', name)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
def test_loading_classes_without_import(self):
cl = test_support.make_jar_classloader("../callbacker_test.jar")
X = cl.loadClass("org.python.tests.Callbacker")
called = []
class Blah(X.Callback):
def call(self, arg=None):
called.append(arg)
X().callNoArg(Blah())
self.assertEquals(None, called[0])
def activity():
# Look for the Callbacker class ONLY in the special JAR
jar = os.path.join(sys.prefix, "callbacker_test.jar")
cldr = test_support.make_jar_classloader(jar, None)
CB = cldr.loadClass("org.python.tests.Callbacker")
cb = CB()
# Save locals as weak references (that we hope will go dead)
for obj in (cb, type(cb), cldr):
zoo.append(weakref.ref(obj))
def test_importer_get_source(self):
# Test loader.get_source used via pkgutil.get_importer
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
importer = pkgutil.get_importer('__pyclasspath__/')
# In package
mod = 'jar_pkg.prefer_compiled'
source = importer.get_source(mod)
self.assertIsInstance(source, bytes)
self.assertEqual(source, 'compiled = False\n')
def test_importer_get_source(self):
# Test loader.get_source used via pkgutil.get_importer
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
importer = pkgutil.get_importer('__pyclasspath__/')
# In package
mod = 'jar_pkg.prefer_compiled'
source = importer.get_source(mod)
self.assertIsInstance(source, bytes)
self.assertEqual(source, 'compiled = False\n')
def test_loader_get_data(self):
# Test loader.get_data used via pkgutil.get_loader
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
loader = pkgutil.get_loader('jar_pkg')
# path is a resource path (not file system path using os.path.sep)
path = 'jar_pkg/' + name
data = loader.get_data(path)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
def test_loading_classes_without_import(self):
# Look for the Callbacker class ONLY in the special JAR
jar = os.path.join(sys.prefix, "callbacker_test.jar")
cl = test_support.make_jar_classloader(jar, None)
X = cl.loadClass("org.python.tests.Callbacker")
called = []
class Blah(X.Callback):
def call(self, arg=None):
called.append(arg)
X().callNoArg(Blah())
self.assertEquals(None, called[0])
def test_loader_get_data(self):
# Test loader.get_data used via pkgutil.get_loader
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
loader = pkgutil.get_loader('jar_pkg')
# path is a resource path (not file system path using os.path.sep)
path = 'jar_pkg/' + name
data = loader.get_data(path)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
def setClassLoaderAndCheck(self, jar, prefix):
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
import flat_in_jar
self.assertEquals(flat_in_jar.value, 7)
import jar_pkg
self.assertEquals(prefix + '/jar_pkg/__init__$py.class', jar_pkg.__file__)
from jar_pkg import prefer_compiled
self.assertEquals(prefix + '/jar_pkg/prefer_compiled$py.class', prefer_compiled.__file__)
self.assert_(prefer_compiled.compiled)
self.assertRaises(NameError, __import__, 'flat_bad')
self.assertRaises(NameError, __import__, 'jar_pkg.bad')
def test_loading_classes_without_import(self):
cl = test_support.make_jar_classloader("../callbacker_test.jar")
X = cl.loadClass("org.python.tests.Callbacker")
called = []
class Blah(X.Callback):
def call(self, arg=None):
called.append(arg)
X().callNoArg(Blah())
self.assertEquals(None, called[0])
def test_loading_classes_without_import(self):
# Look for the Callbacker class ONLY in the special JAR
jar = os.path.join(sys.prefix, "callbacker_test.jar")
cl = test_support.make_jar_classloader(jar, None)
X = cl.loadClass("org.python.tests.Callbacker")
called = []
class Blah(X.Callback):
def call(self, arg=None):
called.append(arg)
X().callNoArg(Blah())
self.assertEquals(None, called[0])
def test_importer_get_data(self):
# Test loader.get_data used via pkgutil.get_importer
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
importer = pkgutil.get_importer('__pyclasspath__/')
# path is a resource path (may be file system path using os.path.sep)
path = os.path.join('jar_pkg', name)
data = importer.get_data(path)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
# Check works a second time (stream use internal to implementation)
data = importer.get_data(path)
self.assertEqual(data, self.RESOURCE_DATA)
def test_importer_get_data(self):
# Test loader.get_data used via pkgutil.get_importer
jar = self.prepareJar('classimport.jar')
name = self.addResourceToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
importer = pkgutil.get_importer('__pyclasspath__/')
# path is a resource path (may be file system path using os.path.sep)
path = os.path.join('jar_pkg', name)
data = importer.get_data(path)
self.assertIsInstance(data, bytes)
self.assertEqual(data, self.RESOURCE_DATA)
# Check works a second time (stream use internal to implementation)
data = importer.get_data(path)
self.assertEqual(data, self.RESOURCE_DATA)
def test_loader_get_code(self):
# Execute Python code out of the JAR
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
loader = pkgutil.get_loader('jar_pkg')
space = { 'value':None, 'compiled':None}
# flat_in_jar contains the assignment value = 7
code = loader.get_code('flat_in_jar')
exec code in space
self.assertEquals(space['value'], 7)
# jar_pkg.prefer_compiled contains the assignment compiled = False
code = loader.get_code('jar_pkg.prefer_compiled')
exec code in space
self.assertEquals(space['compiled'], False)
# Compile a new one containing the assignment compiled = True
self.compileToJar(jar)
code = loader.get_code('jar_pkg.prefer_compiled')
exec code in space
self.assertEquals(space['compiled'], True)
def test_loader_get_code(self):
# Execute Python code out of the JAR
jar = self.prepareJar('classimport.jar')
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
loader = pkgutil.get_loader('jar_pkg')
space = { 'value':None, 'compiled':None}
# flat_in_jar contains the assignment value = 7
code = loader.get_code('flat_in_jar')
exec code in space
self.assertEquals(space['value'], 7)
# jar_pkg.prefer_compiled contains the assignment compiled = False
code = loader.get_code('jar_pkg.prefer_compiled')
exec code in space
self.assertEquals(space['compiled'], False)
# Compile a new one containing the assignment compiled = True
self.compileToJar(jar)
code = loader.get_code('jar_pkg.prefer_compiled')
exec code in space
self.assertEquals(space['compiled'], True)
def test_default_pyclasspath(self):
jar = self.prepareJar('classimport.jar')
compiled = self.compileToJar(jar)
Thread.currentThread(
).contextClassLoader = test_support.make_jar_classloader(jar)
self.checkImports('__pyclasspath__', compiled)
def test_default_pyclasspath(self):
jar = self.prepareJar('classimport.jar')
compiled = self.compileToJar(jar)
Thread.currentThread().contextClassLoader = test_support.make_jar_classloader(jar)
self.checkImports('__pyclasspath__', compiled)
