def test_extension_registry(self):
#test getattr of the attribute and how the value of this attribute affects other method
copy_reg.add_extension('a', 'b', 123)
key = copy_reg._inverted_registry[123]
result = copy_reg._extension_registry
code = result[key]
self.assertTrue(
code == 123,
"The _extension_registry attribute did not return the correct value"
)
copy_reg.add_extension('1', '2', 999)
result = copy_reg._extension_registry
code = result[('1', '2')]
self.assertTrue(
code == 999,
"The _extension_registry attribute did not return the correct value"
)
#general test, try to set the attribute then to get it
myvalue = 3885
copy_reg._extension_registry["key"] = myvalue
result = copy_reg._extension_registry["key"]
self.assertTrue(result == myvalue,
"The set or the get of the attribute failed")
def produce_global_ext(self, extcode, opcode):
e = ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
# Dump using protocol 1 for comparison.
s1 = self.dumps(x, 1)
self.assert_(__name__ in s1)
self.assert_("MyList" in s1)
self.assertEqual(opcode_in_pickle(opcode, s1), False)
y = self.loads(s1)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
# Dump using protocol 2 for test.
s2 = self.dumps(x, 2)
self.assert_(__name__ not in s2)
self.assert_("MyList" not in s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def produce_global_ext(self, extcode, opcode):
e = ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
# Dump using protocol 1 for comparison.
s1 = self.dumps(x, 1)
self.assert_(__name__ in s1)
self.assert_("MyList" in s1)
self.assertEqual(opcode_in_pickle(opcode, s1), False)
y = self.loads(s1)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
# Dump using protocol 2 for test.
s2 = self.dumps(x, 2)
self.assert_(__name__ not in s2)
self.assert_("MyList" not in s2)
self.assertEqual(opcode_in_pickle(opcode, s2), True)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def restore(self):
code = self.code
curpair = copy_reg._inverted_registry.get(code)
if curpair is not None:
copy_reg.remove_extension(curpair[0], curpair[1], code)
pair = self.pair
if pair is not None:
copy_reg.add_extension(pair[0], pair[1], code)
def restore(self):
code = self.code
curpair = copy_reg._inverted_registry.get(code)
if curpair is not None:
copy_reg.remove_extension(curpair[0], curpair[1], code)
pair = self.pair
if pair is not None:
copy_reg.add_extension(pair[0], pair[1], code)
def test_inverted_registry(self):
copy_reg.add_extension('obj1','obj2',64)
#get
result = copy_reg._inverted_registry[64]
self.assertTrue(result == ('obj1','obj2'),
"The _inverted_registry attribute did not return the correct value")
#set
value = ('newmodule','newobj')
copy_reg._inverted_registry[10001] = value
result = copy_reg._inverted_registry[10001]
self.assertTrue(result == value,
"The setattr of _inverted_registry attribute failed")
def test_inverted_registry():
copy_reg.add_extension('obj1','obj2',64)
#get
result = copy_reg._inverted_registry[64]
Assert(result == ('obj1','obj2'),
"The _inverted_registry attribute did not return the correct value")
#set
value = ('newmodule','newobj')
copy_reg._inverted_registry[10001] = value
result = copy_reg._inverted_registry[10001]
Assert(result == value,
"The setattr of _inverted_registry attribute failed")
def produce_global_ext(self, extcode, opcode):
e = test.pickletester.ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
s1 = self.dumps(x, 1)
y = self.loads(s1)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def produce_global_ext(self, extcode, opcode):
e = test.pickletester.ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
s1 = self.dumps(x, 1)
y = self.loads(s1)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def produce_global_ext(self, extcode, opcode):
e = pickletester.ExtensionSaver(extcode)
try:
copy_reg.add_extension("pickletester", "MyList", extcode)
x = pickletester.MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
# Just test, don't examine output
s2 = self.dumps(x, 2)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def test_remove_extension():
#delete extension
copy_reg.remove_extension(_random, obj, 100)
import argu1
copy_reg.remove_extension(argu1, obj, 1)
module = True
copy_reg.remove_extension(module, obj, 6)
#remove extension which has not been registed
AssertError(ValueError, copy_reg.remove_extension, _random, obj, 2)
AssertError(ValueError, copy_reg.remove_extension, _random, object(), 100)
AssertError(ValueError, copy_reg.remove_extension, argu1, obj, 1)
copy_reg.add_extension(argu1, obj, 1)
AssertError(ValueError, copy_reg.remove_extension, argu1, obj, 0)
def test_remove_extension():
#delete extension
copy_reg.remove_extension(_random,obj,100)
import argu1
copy_reg.remove_extension(argu1,obj,1)
module = True
copy_reg.remove_extension(module,obj,6)
#remove extension which has not been registed
AssertError(ValueError,copy_reg.remove_extension,_random,obj,2)
AssertError(ValueError,copy_reg.remove_extension,_random,object(),100)
AssertError(ValueError,copy_reg.remove_extension,argu1,obj,1)
copy_reg.add_extension(argu1,obj,1)
AssertError(ValueError,copy_reg.remove_extension,argu1,obj,0)
def test_remove_extension(self):
#delete extension
copy_reg.remove_extension(random,obj,100)
import argu1
copy_reg.remove_extension(argu1,obj,1)
module = True
copy_reg.remove_extension(module,obj,6)
#remove extension which has not been registed
self.assertRaises(ValueError,copy_reg.remove_extension,random,obj,2)
self.assertRaises(ValueError,copy_reg.remove_extension,random,object(),100)
self.assertRaises(ValueError,copy_reg.remove_extension,argu1,obj,1)
copy_reg.add_extension(argu1,obj,1)
self.assertRaises(ValueError,copy_reg.remove_extension,argu1,obj,0)
def test_remove_extension(self):
#delete extension
copy_reg.remove_extension(random, obj, 100)
import argu1
copy_reg.remove_extension(argu1, obj, 1)
module = True
copy_reg.remove_extension(module, obj, 6)
#remove extension which has not been registed
self.assertRaises(ValueError, copy_reg.remove_extension, random, obj,
2)
self.assertRaises(ValueError, copy_reg.remove_extension, random,
object(), 100)
self.assertRaises(ValueError, copy_reg.remove_extension, argu1, obj, 1)
copy_reg.add_extension(argu1, obj, 1)
self.assertRaises(ValueError, copy_reg.remove_extension, argu1, obj, 0)
def produce_global_ext(self, extcode):
e = ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
s2 = self.dumps(x, 2)
self.assertNotIn(__name__, s2)
self.assertNotIn("MyList", s2)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def produce_global_ext(self, extcode):
e = ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "MyList", extcode)
x = MyList([1, 2, 3])
x.foo = 42
x.bar = "hello"
s2 = self.dumps(x, 2)
self.assertNotIn(__name__, s2)
self.assertNotIn("MyList", s2)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def produce_global_ext(self, extcode, opcode):
e = ExtensionSaver(extcode)
try:
copy_reg.add_extension(__name__, "SomeonesList", extcode)
x = SomeonesList([1, 2, 3])
x.foo = 42
x.bar = "hello"
# Dump using protocol 2 for test.
s2 = self.dumps(x, 2)
self.assertNotIn(__name__, s2)
self.assertNotIn("SomeonesList", s2)
s2_opcodes = [op.code for op, _, _ in pickletools.genops(s2)]
self.assertIn(opcode, s2_opcodes)
y = self.loads(s2)
self.assertEqual(list(x), list(y))
self.assertEqual(x.__dict__, y.__dict__)
finally:
e.restore()
def browse_outfile_clicked(self):
dlg = QFileDialog(self, "Save h3da file", self.outfiledir, \
"dark-hammer anims (*.h3da)")
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setAcceptMode(QFileDialog.AcceptSave)
if dlg.exec_():
relative_path = util.get_rel_path(str(dlg.selectedFiles()[0]), prefs['assetdir'])
if not relative_path:
QMessageBox.warning(self, 'h3dimport', 'Path must be under asset directory tree')
return
self.edit_outfilepath.setText(add_extension(relative_path, "h3da"))
self.outfiledir = os.path.normpath(str(dlg.directory().path()))
def test_extension_registry(self):
#test getattr of the attribute and how the value of this attribute affects other method
copy_reg.add_extension('a','b',123)
key = copy_reg._inverted_registry[123]
result = copy_reg._extension_registry
code = result[key]
self.assertTrue(code == 123,
"The _extension_registry attribute did not return the correct value")
copy_reg.add_extension('1','2',999)
result = copy_reg._extension_registry
code = result[('1','2')]
self.assertTrue(code == 999,
"The _extension_registry attribute did not return the correct value")
#general test, try to set the attribute then to get it
myvalue = 3885
copy_reg._extension_registry["key"] = myvalue
result = copy_reg._extension_registry["key"]
self.assertTrue(result == myvalue,
"The set or the get of the attribute failed")
def test_add_extension():
global obj
obj = object()
#The module is system defined module:_random
copy_reg.add_extension(_random, obj, 100)
#The module is a custom mudole or the module argument is not a type of module
global mod
mod = imp.new_module('module')
sys.modules['argu1'] = mod
import argu1
copy_reg.add_extension(argu1, obj, 1)
module = True
copy_reg.add_extension(module, obj, 6)
# the value is zero or less than zero
module = "module"
AssertError(ValueError, copy_reg.add_extension, module, obj, 0)
AssertError(ValueError, copy_reg.add_extension, module, object(), -987654)
# the key is already registered with code
AssertError(ValueError, copy_reg.add_extension, argu1, object(), 100)
# the code is already in use for key
AssertError(ValueError, copy_reg.add_extension, _random, obj, 100009)
def test_add_extension(self):
global obj
obj = object()
#The module is system defined module:random
copy_reg.add_extension(random,obj,100)
#The module is a custom mudole or the module argument is not a type of module
global mod
mod = imp.new_module('module')
sys.modules['argu1'] = mod
import argu1
copy_reg.add_extension(argu1,obj,1)
module = True
copy_reg.add_extension(module,obj,6)
# the value is zero or less than zero
module = "module"
self.assertRaises(ValueError,copy_reg.add_extension,module,obj,0)
self.assertRaises(ValueError,copy_reg.add_extension,module,object(),-987654)
# the key is already registered with code
self.assertRaises(ValueError,copy_reg.add_extension,argu1,object(),100)
# the code is already in use for key
self.assertRaises(ValueError,copy_reg.add_extension,random,obj,100009)
def browse_outfile_clicked(self, checked):
dlg = QFileDialog(self, "Save h3dm file", self.outfile_dir, \
"dark-hammer models (*.h3dm)")
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setAcceptMode(QFileDialog.AcceptSave)
if dlg.exec_():
relative_path = util.get_rel_path(str(dlg.selectedFiles()[0]),
prefs['assetdir'])
if not relative_path:
QMessageBox.warning(self, 'h3dimport', \
'Path must be under asset directory tree')
return
self.edit_outfilepath.setText(add_extension(relative_path, "h3dm"))
self.outfile_dir = os.path.normpath(str(dlg.directory().path()))
def test_extension_registry(self):
mod, func, code = 'junk1 ', ' junk2', 0xabcd
e = ExtensionSaver(code)
try:
# Shouldn't be in registry now.
self.assertRaises(ValueError, copy_reg.remove_extension, mod, func,
code)
copy_reg.add_extension(mod, func, code)
# Should be in the registry.
self.assert_(copy_reg._extension_registry[mod, func] == code)
self.assert_(copy_reg._inverted_registry[code] == (mod, func))
# Shouldn't be in the cache.
self.assert_(code not in copy_reg._extension_cache)
# Redundant registration should be OK.
copy_reg.add_extension(mod, func, code) # shouldn't blow up
# Conflicting code.
self.assertRaises(ValueError, copy_reg.add_extension, mod, func,
code + 1)
self.assertRaises(ValueError, copy_reg.remove_extension, mod, func,
code + 1)
# Conflicting module name.
self.assertRaises(ValueError, copy_reg.add_extension, mod[1:],
func, code)
self.assertRaises(ValueError, copy_reg.remove_extension, mod[1:],
func, code)
# Conflicting function name.
self.assertRaises(ValueError, copy_reg.add_extension, mod,
func[1:], code)
self.assertRaises(ValueError, copy_reg.remove_extension, mod,
func[1:], code)
# Can't remove one that isn't registered at all.
if code + 1 not in copy_reg._inverted_registry:
self.assertRaises(ValueError, copy_reg.remove_extension,
mod[1:], func[1:], code + 1)
finally:
e.restore()
# Shouldn't be there anymore.
self.assert_((mod, func) not in copy_reg._extension_registry)
# The code *may* be in copy_reg._extension_registry, though, if
# we happened to pick on a registered code. So don't check for
# that.
# Check valid codes at the limits.
for code in 1, 0x7fffffff:
e = ExtensionSaver(code)
try:
copy_reg.add_extension(mod, func, code)
copy_reg.remove_extension(mod, func, code)
finally:
e.restore()
# Ensure invalid codes blow up.
for code in -1, 0, 0x80000000L:
self.assertRaises(ValueError, copy_reg.add_extension, mod, func,
code)
def test_extension_registry(self):
mod, func, code = 'junk1 ', ' junk2', 0xabcd
e = ExtensionSaver(code)
try:
# Shouldn't be in registry now.
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func, code)
copy_reg.add_extension(mod, func, code)
# Should be in the registry.
self.assertTrue(copy_reg._extension_registry[mod, func] == code)
self.assertTrue(copy_reg._inverted_registry[code] == (mod, func))
# Shouldn't be in the cache.
self.assertNotIn(code, copy_reg._extension_cache)
# Redundant registration should be OK.
copy_reg.add_extension(mod, func, code) # shouldn't blow up
# Conflicting code.
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func, code + 1)
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func, code + 1)
# Conflicting module name.
self.assertRaises(ValueError, copy_reg.add_extension,
mod[1:], func, code )
self.assertRaises(ValueError, copy_reg.remove_extension,
mod[1:], func, code )
# Conflicting function name.
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func[1:], code)
self.assertRaises(ValueError, copy_reg.remove_extension,
mod, func[1:], code)
# Can't remove one that isn't registered at all.
if code + 1 not in copy_reg._inverted_registry:
self.assertRaises(ValueError, copy_reg.remove_extension,
mod[1:], func[1:], code + 1)
finally:
e.restore()
# Shouldn't be there anymore.
self.assertNotIn((mod, func), copy_reg._extension_registry)
# The code *may* be in copy_reg._extension_registry, though, if
# we happened to pick on a registered code. So don't check for
# that.
# Check valid codes at the limits.
for code in 1, 0x7fffffff:
e = ExtensionSaver(code)
try:
copy_reg.add_extension(mod, func, code)
copy_reg.remove_extension(mod, func, code)
finally:
e.restore()
# Ensure invalid codes blow up.
for code in -1, 0, 0x80000000L:
self.assertRaises(ValueError, copy_reg.add_extension,
mod, func, code)
_templating
except NameError:
pass
else:
Html = _templating.Html
StrHtml = _templating.StrHtml
StrHtml2 = _templating.StrHtml2
quote = _templating.quote
del _wrap, Wrapper, UnicodeWrapper
start_offset = options.PICKLE_START_OFFSET
if options.PICKLE_HTML_AS_PLAIN_STR:
copy_reg.pickle(Html, lambda x: (unicode, (unicode(x), )))
copy_reg.pickle(StrHtml, lambda x: (str, (str.__str__(x), )))
copy_reg.pickle(StrHtml2, lambda x: (str, (str.__str__(x), )))
copy_reg.add_extension('__builtin__', 'unicode', start_offset)
copy_reg.add_extension('__builtin__', 'str', start_offset + 1)
else:
copy_reg.pickle(Html, lambda x: (Html, (unicode(x), )))
copy_reg.pickle(StrHtml, lambda x: (StrHtml, (str.__str__(x), )))
copy_reg.pickle(StrHtml2, lambda x: (StrHtml, (str.__str__(x), )))
copy_reg.add_extension('pony.templating', 'Html', start_offset)
copy_reg.add_extension('pony.templating', 'StrHtml', start_offset + 1)
htmljoin = Html('').join
def htmltag(_name_, _attrs_=None, **_attrs2_):
attrs = {}
for d in _attrs_, _attrs2_:
if not d: continue
try: _templating
except NameError: pass
else:
Html = _templating.Html
StrHtml = _templating.StrHtml
StrHtml2 = _templating.StrHtml2
quote = _templating.quote
del _wrap, Wrapper, UnicodeWrapper
start_offset = options.PICKLE_START_OFFSET
if options.PICKLE_HTML_AS_PLAIN_STR:
copy_reg.pickle(Html, lambda x: (unicode, (unicode(x),)))
copy_reg.pickle(StrHtml, lambda x: (str, (str.__str__(x),)))
copy_reg.pickle(StrHtml2, lambda x: (str, (str.__str__(x),)))
copy_reg.add_extension('__builtin__', 'unicode', start_offset)
copy_reg.add_extension('__builtin__', 'str', start_offset+1)
else:
copy_reg.pickle(Html, lambda x: (Html, (unicode(x),)))
copy_reg.pickle(StrHtml, lambda x: (StrHtml, (str.__str__(x),)))
copy_reg.pickle(StrHtml2, lambda x: (StrHtml, (str.__str__(x),)))
copy_reg.add_extension('pony.templating', 'Html', start_offset)
copy_reg.add_extension('pony.templating', 'StrHtml', start_offset+1)
htmljoin = Html('').join
def htmltag(_name_, _attrs_=None, **_attrs2_):
attrs = {}
for d in _attrs_, _attrs2_:
if not d: continue
for name, value in d.items():
("Cookie", "Morsel"),
("Cookie", "SimpleCookie"),
#("datetime", "date"),
#("datetime", "datetime"),
#("datetime", "time"),
#("datetime", "timedelta"),
#("datetime", "tzinfo"),
#("decimal", "Decimal"),
#("fractions", "Fractions"),
("os", "_make_stat_result"),
("os", "_make_statvfs_result"),
("time", "struct_time"),
]
for code, (module, name) in enumerate(STDLIB_EXTENSIONS, start=1):
copy_reg.add_extension(module, name, code)
del code
del module
del name
class C:
def __cmp__(self, other):
return cmp(self.__dict__, other.__dict__)
import __main__
__main__.C = C
C.__module__ = "__main__"
# FIXME This changes the global extension registry, ideally each Pickler
def dumps(self, arg, proto=2, fast=0):
from pikl import _pickle
# Ignore fast
return _pickle.dumps(arg, proto)
def loads(self, buf):
from pikl import _pickle
# Ignore fast
return _pickle.loads(buf)
class Node(object):
pass
copy_reg.add_extension(__name__, "Node", extension_codes.next())
class cPickleDeepRecursive(unittest.TestCase):
def test_issue2702(self):
# This should raise a RecursionLimit but in some
# platforms (FreeBSD, win32) sometimes raises KeyError instead,
# or just silently terminates the interpreter (=crashes).
from pikl import _pickle
nodes = [Node() for i in range(500)]
for n in nodes:
n.connections = list(nodes)
n.connections.remove(n)
self.assertRaises((AttributeError, RuntimeError), _pickle.dumps, n)
def test_issue3179(self):