示例#1
0
    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")
示例#2
0
    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()
示例#3
0
    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()
示例#4
0
 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)
示例#5
0
 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")
示例#7
0
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")
示例#8
0
        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()
示例#9
0
        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()
示例#10
0
文件: test.py 项目: pv/hdf5pickle
    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)
示例#12
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)
示例#13
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)
示例#14
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)
示例#15
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()
示例#16
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()
示例#17
0
    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()
示例#18
0
 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()))
示例#19
0
 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)
示例#21
0
    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)
示例#22
0
 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()))
示例#23
0
    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)
示例#24
0
    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)
示例#25
0
    _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():
示例#27
0
    ("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
示例#28
0
    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):