def test_function(self):
module_name = 'foo_test'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f1 = """def foo(): return 0 """
create_module(module_name, f1)
exec "import %s" % module_name
exec "from %s import foo" % module_name
assert (foo() == 0)
f2 = """def foo():
return 1
"""
create_module(module_name, f2)
refresh()
assert (foo() == 1)
# fixme: this is failing with our new reload scheme
self.single_version_check("foo", FunctionType)
finally:
remove_module(module_name)
def test_pickle(self):
# not sure this is really a worth while test. It was added
# based on some errors I (eric) was getting when testing in
# envisage, but I am now not sure that the errors were refresh()
# related. Regardless, I have left the test here since it
# doesn't do any harm, and I may need it in the future.
module_name = 'foo_test'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f1 = """class FooNew(object):
def method1(self):
return 0
def method2(self):
return 0
"""
create_module(module_name, f1)
exec "import %s" % module_name
exec "from %s import FooNew" % module_name
foo = FooNew()
assert (foo.method1() == 0)
f2 = """class FooNew(object):
def method1(self):
return 1
def method2(self):
return 1
"""
create_module(module_name, f2)
refresh()
assert (foo.method1() == 1)
foo2 = pickle.loads(pickle.dumps(foo))
assert (foo2.method1() == 1)
#self.single_version_check("FooNew")
finally:
remove_module(module_name)
def test_traits_instance(self):
module_name = 'foo_test'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f1 = "from enthought.traits.api import HasTraits, Float\n" + \
"""class FooTraits(HasTraits):
bar = Float(1.0)
def method1(self):
return 0
def method2(self):
return 0
"""
create_module(module_name, f1)
exec "import %s" % module_name
exec "from %s import FooTraits" % module_name
foo = FooTraits()
assert (foo.method1() == 0)
f2 = "from enthought.traits.api import HasTraits, Int\n" + \
"""class FooTraits(HasTraits):
bar = Int(2)
def method1(self):
return 1
def method2(self):
return 1
"""
create_module(module_name, f2)
refresh()
assert (foo.method1() == 1)
# classes derived from HasTraits seem to continue to have
# a copy hanging around. This doesn't really cause problems,
# it is just a little untidy.
#self.single_version_check("FooTraits")
finally:
remove_module(module_name)
def test_new_style_class(self):
module_name = 'foo_test'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f1 = """class FooNew(object):
def method1(self):
return 0
def method2(self):
return 0
"""
create_module(module_name, f1)
exec "import %s" % module_name
exec "from %s import FooNew" % module_name
foo = FooNew()
assert (foo.method1() == 0)
f2 = """class FooNew(object):
def method1(self):
return 1
def method2(self):
return 1
"""
create_module(module_name, f2)
refresh()
assert (foo.method1() == 1)
#self.single_version_check("FooNew")
finally:
remove_module(module_name)
def test_inheritance_class2(self):
""" Change the base class definition and make sure that
existing subclasses still behaves like the new
base class.
"""
module_name = 'foo_test2'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f0 = """class Bar:
def method1(self):
return -1
def method2(self):
return -1
"""
create_module('bar_test2', f0)
f1 = "from bar_test2 import Bar\n" + \
"""class FooSub(Bar):
def method1(self):
#print "base", self.__class__.__bases__
#print "Bar", repr(Bar)
#print "method1 im_class", repr(Bar.method1.im_class)
#print 'is instance:', isinstance(self, Bar)
result = Bar.method1(self)
return result
def method2(self):
return 0
"""
create_module(module_name, f1)
from bar_test2 import Bar
bar = Bar()
assert (bar.method1() == -1)
exec "import %s" % module_name
exec "from %s import FooSub" % module_name
foo = FooSub()
assert (foo.method1() == -1)
f2 = """class Bar:
def method1(self):
return -2
def method2(self):
return -1
"""
create_module('bar_test2', f2)
refresh()
assert (foo.method1() == -2)
assert (bar.method1() == -2)
# classes derived from object seem to continue to have
# a copy hanging around. This doesn't really cause problems,
# it is just a little untidy.
#self.single_class_check()
finally:
remove_module(module_name)
remove_module('bar_test2')
def test_inheritance_class(self):
module_name = 'foo_test'
try:
# clean out any existing versions of foo_test in memory
try:
del sys.modules[module_name]
except:
pass
f0 = """class Bar:
def method1(self):
return -1
def method2(self):
return -1
"""
create_module('bar_test', f0)
f1 = "import bar_test\n" + \
"""class FooSub(bar_test.Bar):
def method1(self):
return 0
def method2(self):
return 0
"""
create_module(module_name, f1)
from bar_test import Bar
bar = Bar()
assert (bar.method1() == -1)
exec "import %s" % module_name
exec "from %s import FooSub" % module_name
foo = FooSub()
assert (foo.method1() == 0)
f2 = """class FooSub:
def method1(self):
return 1
def method2(self):
return 1
"""
create_module(module_name, f2)
refresh()
# test method calls
assert (foo.method1() == 1)
assert (bar.method1() == -1)
# isinstance
assert (isinstance(foo, Bar))
assert (isinstance(foo, FooSub))
assert (isinstance(bar, Bar))
# classes derived from object seem to continue to have
# a copy hanging around. This doesn't really cause problems,
# it is just a little untidy.
#self.single_class_check()
finally:
remove_module(module_name)
remove_module('bar_test')