def test_file_coding(self):
try:
import os
f = file('test_coding_mod.py', 'wb+')
f.write("# coding: utf-8\nx = '\xe6ble'\n")
f.close()
with path_modifier('.'):
import test_coding_mod
self.assertEqual(test_coding_mod.x[0], '\xe6')
finally:
os.unlink('test_coding_mod.py')
try:
f = file('test_coding_2.py', 'wb+')
f.write("\xef\xbb\xbf# -*- coding: utf-8 -*-\n")
f.write("x = u'ABCDE'\n")
f.close()
with path_modifier('.'):
import test_coding_2
self.assertEqual(test_coding_2.x, 'ABCDE')
finally:
os.unlink('test_coding_2.py')
try:
f = file('test_coding_3.py', 'wb+')
f.write("# -*- coding: utf-8 -*-\n")
f.write("raise Exception()")
f.close()
try:
with path_modifier('.'):
import test_coding_3
except Exception as e:
self.assertEqual(sys.exc_info()[2].tb_next.tb_lineno, 2)
finally:
os.unlink('test_coding_3.py')
def test_modified_module(self):
import clr
test_name = "test_modified_module.py"
try:
#create the file
with open(test_name, "w") as f:
f.writelines('''A=1; print "First Run"''')
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run checks
self.assertEqual(output.messages, ["First Run"])
self.assertEqual(new_module.A, 1)
#--Do everything again with different values...
#recreate the file
with open(test_name, "w") as f:
f.writelines('''A=2; print "Second Run"''')
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run checks
self.assertEqual(output.messages, [])
self.assertEqual(new_module.A, 1)
finally:
#cleanup
try:
os.remove(test_name)
except: pass
def test_modified_module(self):
import clr
test_name = "test_modified_module.py"
try:
#create the file
with open(test_name, "w") as f:
f.writelines('''A=1; print "First Run"''')
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run checks
self.assertEqual(output.messages, ["First Run"])
self.assertEqual(new_module.A, 1)
#--Do everything again with different values...
#recreate the file
with open(test_name, "w") as f:
f.writelines('''A=2; print "Second Run"''')
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run checks
self.assertEqual(output.messages, [])
self.assertEqual(new_module.A, 1)
finally:
#cleanup
try:
os.remove(test_name)
except: pass
def test_cp13686(self):
with path_modifier(self.test_dir) as p:
import toimport
import sys
mod_list = [toimport, sys]
if is_posix:
import posix
mod_list.append(posix)
else:
import nt
mod_list.append(nt)
mod_names = {}
for mod in mod_list:
mod_names[mod] = mod.__name__
for mod in mod_list:
self.assertRaises(AttributeError, getattr, mod, "name")
setattr(mod, "name", "xyz")
self.assertEqual(getattr(mod, "name"), "xyz")
self.assertEqual(getattr(mod, "__name__"), mod_names[mod])
setattr(mod, "__name__", "badname")
self.assertEqual(getattr(mod, "__name__"), "badname")
if is_cli:
import System
self.assertRaises(AttributeError, setattr, System, "name", "xyz")
def test_cp24381(self):
import sys
orig_sys_trace_func = sys.gettrace()
def f(*args):
global CP24381_MESSAGES
CP24381_MESSAGES += args[1:]
return f
cp24381_file_name = "cp24381.py"
cp24381_contents = """
print 'a'
print 'b'
print 'c'
def f():
print 'hi'
f()
"""
try:
self.write_to_file(cp24381_file_name, cp24381_contents)
sys.settrace(f)
with path_modifier('.'):
import cp24381
finally:
sys.settrace(orig_sys_trace_func)
os.unlink(cp24381_file_name)
self.assertEqual(CP24381_MESSAGES,
['call', None, 'line', None, 'line', None, 'line', None, 'line',
None, 'line', None, 'call', None, 'line', None, 'return', None,
'return', None])
def test_cp13686(self):
with path_modifier(self.test_dir) as p:
import toimport
import sys
mod_list = [toimport, sys]
if is_posix:
import posix
mod_list.append(posix)
else:
import nt
mod_list.append(nt)
mod_names = {}
for mod in mod_list:
mod_names[mod] = mod.__name__
for mod in mod_list:
self.assertRaises(AttributeError, getattr, mod, "name")
setattr(mod, "name", "xyz")
self.assertEqual(getattr(mod, "name"), "xyz")
self.assertEqual(getattr(mod, "__name__"), mod_names[mod])
setattr(mod, "__name__", "badname")
self.assertEqual(getattr(mod, "__name__"), "badname")
if is_cli:
import System
self.assertRaises(AttributeError, setattr, System, "name",
"xyz")
def test_cp7007(self):
file_contents = '''
called = 3.14
'''
strange_module_names = [ "+",
"+a",
"a+",
"++",
"+++",
"-",
"=",
"$",
"^",
]
strange_file_names = [ os.path.join(self.test_dir, "cp7007", x + ".py") for x in strange_module_names ]
for x in strange_file_names: self.write_to_file(x, file_contents)
try:
with path_modifier(os.path.join(self.test_dir, 'cp7007')) as p:
for x in strange_module_names:
temp_mod = __import__(x)
self.assertEqual(temp_mod.called, 3.14)
finally:
self.clean_directory(os.path.join(self.test_dir, "cp7007"))
def test_cli_subclasses(self):
import clr
self.assertTrue(issubclass(int, int))
self.assertTrue(not issubclass(str, int))
self.assertTrue(not issubclass(int, (str, str)))
self.assertTrue(issubclass(int, (str, int)))
self.assertTrue(issubclass(bytes, basestring))
self.assertTrue(issubclass(str, basestring))
self.assertTrue(issubclass(unicode, basestring))
self.assertTrue(issubclass(basestring, basestring))
class basestring_subclass(basestring):
pass
self.assertTrue(issubclass(basestring_subclass, basestring))
self.assertTrue(str(None) == "None")
self.assertTrue(issubclass(type(None), type(None)))
self.assertTrue(str(type(None)) == "<type 'NoneType'>")
self.assertTrue(str(1) == "1")
self.assertTrue('__str__' in dir(None))
def tryAssignToNoneAttr():
None.__doc__ = "Nothing!"
def tryAssignToNoneNotAttr():
None.notanattribute = ""
self.assertRaises(AttributeError, tryAssignToNoneAttr)
self.assertRaises(AttributeError, tryAssignToNoneNotAttr)
v = None.__doc__
v = None.__new__
v = None.__hash__
self.assertEqual("<type 'NoneType'>", str(type(None)))
import sys
self.assertEqual(str(sys), "<module 'sys' (built-in)>")
import time
with path_modifier(self.test_dir):
import toimport
m = [type(sys), type(time), type(toimport)]
for i in m:
for j in m:
self.assertTrue(issubclass(i, j))
self.assertRaises(TypeError, type, None, None,
None) # arg 1 must be string
self.assertRaises(TypeError, type, "NewType", None,
None) # arg 2 must be tuple
self.assertRaises(TypeError, type, "NewType", (),
None) # arg 3 must be dict
def splitTest():
"string".split('')
self.assertRaises(ValueError, splitTest)
def test_cp7007(self):
file_contents = '''
called = 3.14
'''
strange_module_names = [ "+",
"+a",
"a+",
"++",
"+++",
"-",
"=",
"$",
"^",
]
strange_file_names = [ os.path.join(self.test_dir, "cp7007", x + ".py") for x in strange_module_names ]
for x in strange_file_names: self.write_to_file(x, file_contents)
try:
with path_modifier(os.path.join(self.test_dir, 'cp7007')) as p:
for x in strange_module_names:
temp_mod = __import__(x)
self.assertEqual(temp_mod.called, 3.14)
finally:
self.clean_directory(os.path.join(self.test_dir, "cp7007"))
def test_encoded_module(self):
"""https://github.com/IronLanguages/ironpython2/issues/129"""
with path_modifier(os.path.join(self.test_dir, 'gh129.zip')):
import something
self.assertEqual(
something.test(),
u'\u041f\u0440\u0438\u0432\u0435\u0442 \u043c\u0438\u0440!')
def test_cp24381(self):
import sys
orig_sys_trace_func = sys.gettrace()
def f(*args):
global CP24381_MESSAGES
CP24381_MESSAGES += args[1:]
return f
cp24381_file_name = "cp24381.py"
cp24381_contents = """
print 'a'
print 'b'
print 'c'
def f():
print 'hi'
f()
"""
try:
self.write_to_file(cp24381_file_name, cp24381_contents)
sys.settrace(f)
with path_modifier('.'):
import cp24381
finally:
sys.settrace(orig_sys_trace_func)
os.unlink(cp24381_file_name)
self.assertEqual(CP24381_MESSAGES,
['call', None, 'line', None, 'line', None, 'line', None, 'line',
None, 'line', None, 'call', None, 'line', None, 'return', None,
'return', None])
def test_always_true(self):
always_true(self)
try:
import sys
with path_modifier(self.temporary_dir):
for code in (code1, code2) :
self.write_to_file(self.tempfile, code)
f1(self.tempfile)
always_true(self)
f2(code, self.tempfile)
always_true(self)
f3(code)
always_true(self)
## test import from file
for code in (code0, code2):
self.write_to_file(self.tempfile, code)
import temp_future
always_true(self)
reloaded_temp_future = reload(temp_future)
always_true(self)
finally:
self.delete_files(self.tempfile)
def test_module_doc_cp21360(self):
temp_filename_empty = "cp21360_empty.py"
temp_filename = "cp21360.py"
try:
with path_modifier('.'):
self.write_to_file(temp_filename_empty, "")
import cp21360_empty
self.assertEqual(cp21360_empty.__doc__, None)
with path_modifier('.'):
self.write_to_file(temp_filename, "x = 3.14")
import cp21360
self.assertEqual(cp21360.__doc__, None)
self.assertEqual(cp21360.x, 3.14)
finally:
self.delete_files(temp_filename, temp_filename_empty)
def test_module_doc_cp21360(self):
temp_filename_empty = "cp21360_empty.py"
temp_filename = "cp21360.py"
try:
with path_modifier('.'):
self.write_to_file(temp_filename_empty, "")
import cp21360_empty
self.assertEqual(cp21360_empty.__doc__, None)
with path_modifier('.'):
self.write_to_file(temp_filename, "x = 3.14")
import cp21360
self.assertEqual(cp21360.__doc__, None)
self.assertEqual(cp21360.x, 3.14)
finally:
self.delete_files(temp_filename, temp_filename_empty)
def f():
import os
with open('temptest.py', 'w+') as f:
f.write('foo = 42')
try:
with path_modifier('.'):
from temptest import foo
finally:
os.unlink('temptest.py')
return foo
def f():
import os
with open('temptest.py', 'w+') as f:
f.write('foo = 42')
try:
with path_modifier('.'):
from temptest import foo
finally:
os.unlink('temptest.py')
return foo
def test_cli_subclasses(self):
import clr
self.assertTrue(issubclass(int, int))
self.assertTrue(not issubclass(str, int))
self.assertTrue(not issubclass(int, (str, str)))
self.assertTrue(issubclass(int, (str, int)))
self.assertTrue(issubclass(bytes, basestring))
self.assertTrue(issubclass(str, basestring))
self.assertTrue(issubclass(unicode, basestring))
self.assertTrue(issubclass(basestring, basestring))
class basestring_subclass(basestring):
pass
self.assertTrue(issubclass(basestring_subclass, basestring))
self.assertTrue(str(None) == "None")
self.assertTrue(issubclass(type(None),type(None)))
self.assertTrue(str(type(None)) == "<type 'NoneType'>")
self.assertTrue(str(1) == "1")
self.assertTrue('__str__' in dir(None))
def tryAssignToNoneAttr():
None.__doc__ = "Nothing!"
def tryAssignToNoneNotAttr():
None.notanattribute = "";
self.assertRaises(AttributeError, tryAssignToNoneAttr)
self.assertRaises(AttributeError, tryAssignToNoneNotAttr)
v = None.__doc__
v = None.__new__
v = None.__hash__
self.assertEqual("<type 'NoneType'>", str(type(None)))
import sys
self.assertEqual(str(sys), "<module 'sys' (built-in)>")
import time
with path_modifier(self.test_dir):
import toimport
m = [type(sys), type(time), type(toimport)]
for i in m:
for j in m:
self.assertTrue(issubclass(i,j))
self.assertRaises(TypeError, type, None, None, None) # arg 1 must be string
self.assertRaises(TypeError, type, "NewType", None, None) # arg 2 must be tuple
self.assertRaises(TypeError, type, "NewType", (), None) # arg 3 must be dict
def splitTest():
"string".split('')
self.assertRaises(ValueError, splitTest)
def simpleTester(self, a, b, c):
global SIMPLE_TEST_COUNT
import clr
test_name = "clrusetest{}.py".format(SIMPLE_TEST_COUNT)
SIMPLE_TEST_COUNT += 1
expected_stdout = '''OK...'''
#create the file
test_text = SIMPLE_TEST % (str(a), str(c))
with open(test_name, "w") as f:
f.writelines(test_text)
try:
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run a few easy checks
self.assertEqual(len(output.messages), 3)
self.assertEqual(output.messages[0], expected_stdout)
self.assertEqual(output.messages[2], "b= 42")
self.assertEqual(new_module.A, a)
self.assertEqual(new_module.aFunc(None), c)
self.assertTrue(isinstance(new_module.K, new_module.Klass))
self.assertEqual(new_module.K.Member, 72)
new_module.K.Member = "foo"
self.assertEqual(new_module.K.Member, "foo")
new_module.K.NewMember = 33
self.assertEqual(new_module.K.NewMember, 33)
new_module.K = None
self.assertEqual(new_module.K, None)
#negative checks
self.assertRaises(TypeError, new_module.aFunc)
self.assertRaises(TypeError, new_module.aFunc, 1, 2)
self.assertRaises(TypeError, new_module.aFunc, 1, 2, 3)
self.assertTrue(not hasattr(new_module, "a"))
self.assertTrue(not hasattr(new_module, "simpleTester"))
try:
aFunc(7)
self.fail("Should never get this far")
except:
pass
#hard test
real_module = __import__(test_name.split(".py")[0])
#for key in dir(real_module): self.assertEqual(real_module.__dict__[key], new_module.__dict__[key])
finally:
#cleanup
try:
os.remove(test_name)
except:
pass
def f():
import os
module_name = 'temptest_%d' % os.getpid()
fname = module_name + '.py'
with open(fname, 'w+') as f:
f.write('foo = 42')
try:
with path_modifier('.'):
foo = __import__(module_name).foo
finally:
os.unlink(fname)
return foo
def simpleTester(self, a, b, c):
global SIMPLE_TEST_COUNT
import clr
test_name = "clrusetest{}.py".format(SIMPLE_TEST_COUNT)
SIMPLE_TEST_COUNT += 1
expected_stdout = '''OK...'''
#create the file
test_text = SIMPLE_TEST % (str(a), str(c))
with open(test_name, "w") as f:
f.writelines(test_text)
try:
with path_modifier('.') as p:
with stdout_trapper() as output:
new_module = clr.Use(test_name.split(".py")[0])
#run a few easy checks
self.assertEqual(len(output.messages), 3)
self.assertEqual(output.messages[0], expected_stdout)
self.assertEqual(output.messages[2], "b= 42")
self.assertEqual(new_module.A, a)
self.assertEqual(new_module.aFunc(None), c)
self.assertTrue(isinstance(new_module.K, new_module.Klass))
self.assertEqual(new_module.K.Member, 72)
new_module.K.Member = "foo"
self.assertEqual(new_module.K.Member, "foo")
new_module.K.NewMember = 33
self.assertEqual(new_module.K.NewMember, 33)
new_module.K = None
self.assertEqual(new_module.K, None)
#negative checks
self.assertRaises(TypeError, new_module.aFunc)
self.assertRaises(TypeError, new_module.aFunc, 1, 2)
self.assertRaises(TypeError, new_module.aFunc, 1, 2, 3)
self.assertTrue(not hasattr(new_module, "a"))
self.assertTrue(not hasattr(new_module, "simpleTester"))
try:
aFunc(7)
self.fail("Should never get this far")
except:
pass
#hard test
real_module = __import__(test_name.split(".py")[0])
#for key in dir(real_module): self.assertEqual(real_module.__dict__[key], new_module.__dict__[key])
finally:
pass
def test_file_coding(self):
try:
import os
with open('test_coding_mod.py', 'wb+') as f:
f.write(b"# coding: utf-8\nx = '\xc3\xa6ble'\n")
with path_modifier('.'):
import test_coding_mod
self.assertEqual(test_coding_mod.x[0], '\xe6')
finally:
os.unlink('test_coding_mod.py')
try:
with open('test_coding_2.py', 'wb+') as f:
f.write(b"\xef\xbb\xbf# -*- coding: utf-8 -*-\n")
f.write(b"x = u'ABCDE'\n")
with path_modifier('.'):
import test_coding_2
self.assertEqual(test_coding_2.x, 'ABCDE')
finally:
os.unlink('test_coding_2.py')
try:
with open('test_coding_3.py', 'wb+') as f:
f.write(b"# -*- coding: utf-8 -*-\n")
f.write(b"raise Exception()")
f.close()
try:
with path_modifier('.'):
import test_coding_3
except Exception as e:
tb = sys.exc_info()[2].tb_next
if is_cli:
while tb.tb_next is not None:
tb = tb.tb_next # importlib has a longer traceback
self.assertEqual(tb.tb_lineno, 2)
finally:
os.unlink('test_coding_3.py')
def test_file_coding(self):
try:
import os
f = file('test_coding_mod.py', 'wb+')
f.write("# coding: utf-8\nx = '\xe6ble'\n")
f.close()
with path_modifier('.'):
import test_coding_mod
self.assertEqual(test_coding_mod.x[0], '\xe6')
finally:
os.unlink('test_coding_mod.py')
try:
f = file('test_coding_2.py', 'wb+')
f.write("\xef\xbb\xbf# -*- coding: utf-8 -*-\n")
f.write("x = u'ABCDE'\n")
f.close()
with path_modifier('.'):
import test_coding_2
self.assertEqual(test_coding_2.x, 'ABCDE')
finally:
os.unlink('test_coding_2.py')
try:
f = file('test_coding_3.py', 'wb+')
f.write("# -*- coding: utf-8 -*-\n")
f.write("raise Exception()")
f.close()
try:
with path_modifier('.'):
import test_coding_3
except Exception, e:
self.assertEqual(sys.exc_info()[2].tb_next.tb_lineno, 2)
finally:
os.unlink('test_coding_3.py')
def test_cp16519(self):
__main__ = __import__(__name__)
__main__.Dict = {"1": "a"}
self.assertEqual(__main__.Dict["1"], "a")
del __main__.Dict
import sys
sys.Dict = {"1": "b"}
self.assertEqual(sys.Dict["1"], "b")
del sys.Dict
with path_modifier(os.path.join(source_root(), 'Tests')):
import testpkg1
testpkg1.Dict = {"1": "c"}
self.assertEqual(testpkg1.Dict["1"], "c")
del testpkg1.Dict
def test_cp16519(self):
__main__ = __import__(__name__)
__main__.Dict = {"1": "a"}
self.assertEqual(__main__.Dict["1"], "a")
del __main__.Dict
import sys
sys.Dict = {"1": "b"}
self.assertEqual(sys.Dict["1"], "b")
del sys.Dict
with path_modifier(os.path.join(source_root(), 'Tests')):
import testpkg1
testpkg1.Dict = {"1": "c"}
self.assertEqual(testpkg1.Dict["1"], "c")
del testpkg1.Dict
def test_simple(self):
always_true(self)
try:
import sys
with path_modifier(self.temporary_dir):
for code in (code1, code2):
self.write_to_file(self.tempfile, code)
f1(self.tempfile)
always_true(self)
f2(code, self.tempfile)
always_true(self)
f3(code)
always_true(self)
finally:
self.delete_files(self.tempfile)
def test_simple(self):
always_true(self)
try:
import sys
with path_modifier(self.temporary_dir):
for code in (code1, code2) :
self.write_to_file(self.tempfile, code)
f1(self.tempfile)
always_true(self)
f2(code, self.tempfile)
always_true(self)
f3(code)
always_true(self)
finally:
self.delete_files(self.tempfile)
def test_imp_module(self):
self.write_to_file(self._f_module, "value = 'imp test module'")
pf, pp, (px, pm, pt) = imp.find_module("imptestmod", [self._imptestdir])
self.assertEqual(pt, imp.PY_SOURCE)
self.assertTrue(pf is not None)
module = imp.load_module("imptestmod", pf, pp, (px, pm, pt))
self.assertEqual(module.value, 'imp test module')
pf.close()
with path_modifier(self._imptestdir) as p:
fm = imp.find_module("imptestmod")
# unpack the result obtained above
pf, pp, (px, pm, pt) = fm
self.assertEqual(pt, imp.PY_SOURCE)
self.assertTrue(pf != None)
self.assertEqual(px, ".py")
self.assertEqual(pm, "r")
module = imp.load_module("imptestmod", pf, pp, (px, pm, pt))
self.assertEqual(module.value, 'imp test module')
pf.close()
def test_imp_package(self):
self.write_to_file(self._f_init, "my_name = 'imp package test'")
pf, pp, (px, pm, pt) = imp.find_module(self._testdir, [self.test_dir])
self.assertEqual(pt, imp.PKG_DIRECTORY)
self.assertEqual(pf, None)
self.assertEqual(px, "")
self.assertEqual(pm, "")
module = imp.load_module(self._testdir, pf, pp, (px, pm, pt))
self.assertTrue(self._testdir in sys.modules)
self.assertEqual(module.my_name, 'imp package test')
with path_modifier(self.test_dir):
fm = imp.find_module(self._testdir)
# unpack the result obtained above
pf, pp, (px, pm, pt) = fm
self.assertEqual(pt, imp.PKG_DIRECTORY)
self.assertEqual(pf, None)
self.assertEqual(px, "")
self.assertEqual(pm, "")
module = imp.load_module(self._testdir, pf, pp, (px, pm, pt))
self.assertEqual(module.my_name, 'imp package test')
def test_imp_package(self):
self.write_to_file(self._f_init, "my_name = 'imp package test'")
pf, pp, (px, pm, pt) = imp.find_module(self._testdir, [self.test_dir])
self.assertEqual(pt, imp.PKG_DIRECTORY)
self.assertEqual(pf, None)
self.assertEqual(px, "")
self.assertEqual(pm, "")
module = imp.load_module(self._testdir, pf, pp, (px, pm, pt))
self.assertTrue(self._testdir in sys.modules)
self.assertEqual(module.my_name, 'imp package test')
with path_modifier(self.test_dir):
fm = imp.find_module(self._testdir)
# unpack the result obtained above
pf, pp, (px, pm, pt) = fm
self.assertEqual(pt, imp.PKG_DIRECTORY)
self.assertEqual(pf, None)
self.assertEqual(px, "")
self.assertEqual(pm, "")
module = imp.load_module(self._testdir, pf, pp, (px, pm, pt))
self.assertEqual(module.my_name, 'imp package test')
def test_imp_module(self):
self.write_to_file(self._f_module, "value = 'imp test module'")
pf, pp, (px, pm, pt) = imp.find_module("imptestmod", [self._imptestdir])
self.assertEqual(pt, imp.PY_SOURCE)
self.assertTrue(pf != None)
self.assertTrue(isinstance(pf, file))
module = imp.load_module("imptestmod", pf, pp, (px, pm, pt))
self.assertEqual(module.value, 'imp test module')
pf.close()
with path_modifier(self._imptestdir) as p:
fm = imp.find_module("imptestmod")
# unpack the result obtained above
pf, pp, (px, pm, pt) = fm
self.assertEqual(pt, imp.PY_SOURCE)
self.assertTrue(pf != None)
self.assertTrue(isinstance(pf, file))
self.assertEqual(px, ".py")
self.assertEqual(pm, "U")
module = imp.load_module("imptestmod", pf, pp, (px, pm, pt))
self.assertEqual(module.value, 'imp test module')
pf.close()
def test_cp24381(self):
CP24381_MESSAGES = []
import sys
orig_sys_trace_func = sys.gettrace()
def f(*args):
CP24381_MESSAGES.extend(args[1:])
return f
cp24381_module = "cp24381_%d" % os.getpid()
cp24381_file_name = cp24381_module + ".py"
cp24381_contents = """
print('a')
print('b')
print('c')
def f():
print('hi')
f()
"""
try:
self.write_to_file(cp24381_file_name, cp24381_contents)
sys.settrace(f)
with path_modifier('.'):
__import__(cp24381_module)
finally:
sys.settrace(orig_sys_trace_func)
os.unlink(cp24381_file_name)
self.assertEqual(CP24381_MESSAGES, [
'call', None, 'line', None, 'line', None, 'line', None, 'line',
None, 'line', None, 'call', None, 'line', None, 'return', None,
'return', None
])
def test_cp15803(self):
_testdir = 'cp15803'
pickle_file = os.path.join(self.test_dir,
"cp15803_%d.pickle" % os.getpid())
module_txt = """
class K%s(object):
static_member = 1
def __init__(self):
self.member = 2
%s = K%s()
"""
_testdir_init = os.path.join(self.test_dir, _testdir, '__init__.py')
self.write_to_file(_testdir_init, module_txt % ("", "FROM_INIT", ""))
_testdir_mod = os.path.join(self.test_dir, _testdir, 'mod.py')
self.write_to_file(
_testdir_mod, module_txt % ("Mod", "FROM_MOD", "Mod") + """
from cp15803 import K
FROM_INIT_IN_MOD = K()
""")
_testdir_sub = os.path.join(self.test_dir, _testdir, 'sub')
_testdir_sub_init = os.path.join(_testdir_sub, '__init__.py')
self.write_to_file(_testdir_sub_init)
_testdir_sub_submod = os.path.join(_testdir_sub, 'submod.py')
self.write_to_file(
_testdir_sub_submod,
module_txt % ("SubMod", "FROM_SUB_MOD", "SubMod") + """
from cp15803 import mod
FROM_MOD_IN_SUBMOD = mod.KMod()
""")
try:
with path_modifier(self.test_dir) as p:
import cp15803
import cp15803.mod
import cp15803.sub.submod
import cp15803.sub.submod as newname
for x in [
cp15803.K(),
cp15803.FROM_INIT,
cp15803.mod.KMod(),
cp15803.mod.FROM_MOD,
cp15803.mod.K(),
cp15803.mod.FROM_INIT_IN_MOD,
cp15803.sub.submod.KSubMod(),
cp15803.sub.submod.FROM_SUB_MOD,
cp15803.sub.submod.FROM_MOD_IN_SUBMOD,
cp15803.sub.submod.mod.KMod(),
cp15803.sub.submod.mod.FROM_MOD,
cp15803.sub.submod.mod.K(),
cp15803.sub.submod.mod.FROM_INIT_IN_MOD,
newname.KSubMod(),
newname.FROM_SUB_MOD,
newname.FROM_MOD_IN_SUBMOD,
newname.mod.KMod(),
newname.mod.FROM_MOD,
newname.mod.K(),
newname.mod.FROM_INIT_IN_MOD,
]:
with open(pickle_file, "wb") as f:
cPickle.dump(x, f)
with open(pickle_file, "rb") as f:
x_unpickled = cPickle.load(f)
self.assertEqual(x.__class__.__name__,
x_unpickled.__class__.__name__)
self.assertEqual(x.static_member,
x_unpickled.static_member)
self.assertEqual(x.member, x_unpickled.member)
finally:
try:
os.unlink(pickle_file)
self.clean_directory(os.path.join(self.test_dir, _testdir))
except:
pass
def test_cp15803(self):
import os
_testdir = 'cp15803'
pickle_file = os.path.join(self.test_dir, "cp15803.pickle")
module_txt = """
class K%s(object):
static_member = 1
def __init__(self):
self.member = 2
%s = K%s()
"""
_testdir_init = os.path.join(self.test_dir, _testdir, '__init__.py')
self.write_to_file(_testdir_init, module_txt % ("", "FROM_INIT", ""))
_testdir_mod = os.path.join(self.test_dir, _testdir, 'mod.py')
self.write_to_file(_testdir_mod, module_txt % ("Mod", "FROM_MOD", "Mod") + """
from cp15803 import K
FROM_INIT_IN_MOD = K()
"""
)
_testdir_sub = os.path.join(self.test_dir, _testdir, 'sub')
_testdir_sub_init = os.path.join(_testdir_sub, '__init__.py')
self.write_to_file(_testdir_sub_init)
_testdir_sub_submod = os.path.join(_testdir_sub, 'submod.py')
self.write_to_file(_testdir_sub_submod, module_txt % ("SubMod", "FROM_SUB_MOD", "SubMod") + """
from cp15803 import mod
FROM_MOD_IN_SUBMOD = mod.KMod()
"""
)
with path_modifier(self.test_dir) as p:
import cp15803
import cp15803.mod
import cp15803.sub.submod
import cp15803.sub.submod as newname
try:
for x in [
cp15803.K(), cp15803.FROM_INIT,
cp15803.mod.KMod(), cp15803.mod.FROM_MOD, cp15803.mod.K(), cp15803.mod.FROM_INIT_IN_MOD,
cp15803.sub.submod.KSubMod(), cp15803.sub.submod.FROM_SUB_MOD, cp15803.sub.submod.FROM_MOD_IN_SUBMOD,
cp15803.sub.submod.mod.KMod(), cp15803.sub.submod.mod.FROM_MOD, cp15803.sub.submod.mod.K(), cp15803.sub.submod.mod.FROM_INIT_IN_MOD,
newname.KSubMod(), newname.FROM_SUB_MOD, newname.FROM_MOD_IN_SUBMOD,
newname.mod.KMod(), newname.mod.FROM_MOD, newname.mod.K(), newname.mod.FROM_INIT_IN_MOD,
]:
with open(pickle_file, "w") as f:
cPickle.dump(x, f)
with open(pickle_file, "r") as f:
x_unpickled = cPickle.load(f)
self.assertEqual(x.__class__.__name__, x_unpickled.__class__.__name__)
self.assertEqual(x.static_member, x_unpickled.static_member)
self.assertEqual(x.member, x_unpickled.member)
finally:
import os
try:
os.unlink(pickle_file)
self.clean_directory(os.path.join(self.test_dir, _testdir))
except:
pass
import unittest
from iptest import path_modifier, run_test, skipUnlessIronPython, source_root
def gen_testcase(exc_name):
def test(self):
import IronPython.Runtime.Exceptions as IRE
e0 = eval("IRE.%s()" % exc_name)
e2 = eval("IRE.%s('msg', e0)" % exc_name)
self.assertEqual(e0.Message, e2.InnerException.Message)
self.assertEqual("msg", e2.Message)
return test
@skipUnlessIronPython()
class ExceptionsGeneratedTest(unittest.TestCase):
def setUp(self):
super(ExceptionsGeneratedTest, self).setUp()
import clr
clr.AddReference("IronPython")
with path_modifier(os.path.join(source_root(), 'Src', 'Scripts')):
from generate_exceptions import pythonExcs as test_cases
test_cases = [x.replace('Error', '') + 'Exception' for x in test_cases]
for exc_name in test_cases:
test_name = 'test_%s' % exc_name
test = gen_testcase(exc_name)
setattr(ExceptionsGeneratedTest, test_name, test)
run_test(__name__)
import sys
import unittest
from iptest import path_modifier, run_test, skipUnlessIronPython, source_root
def gen_testcase(exc_name):
def test(self):
import IronPython.Runtime.Exceptions as IRE
e0 = eval("IRE.%s()" % exc_name)
e2 = eval("IRE.%s('msg', e0)" % exc_name)
self.assertEqual(e0.Message, e2.InnerException.Message)
self.assertEqual("msg", e2.Message)
return test
@skipUnlessIronPython()
class ExceptionsGeneratedTest(unittest.TestCase):
def setUp(self):
super(ExceptionsGeneratedTest, self).setUp()
import clr
clr.AddReference("IronPython")
with path_modifier(os.path.join(source_root(), 'Src', 'Scripts')):
from generate_exceptions import pythonExcs as test_cases
test_cases = [x.replace('Error', '') + 'Exception' for x in test_cases]
for exc_name in test_cases:
test_name = 'test_%s' % exc_name
test = gen_testcase(exc_name)
setattr(ExceptionsGeneratedTest, test_name, test)
run_test(__name__)
def test_encoded_module(self):
"""https://github.com/IronLanguages/ironpython2/issues/129"""
with path_modifier(os.path.join(self.test_dir, 'gh129.zip')):
import something
self.assertEqual(something.test(), u'\u041f\u0440\u0438\u0432\u0435\u0442 \u043c\u0438\u0440!')