Exemplo n.º 1
0
class foo: pass

f = foo()
f.a = (1,2,3)

# method 1 -- StreamWriter is an uncompressed StringIO
x = xml_pickle.dumps(f)

# check header (to ensure correct method used) + contents
if x[0:5] == '<?xml':
    print "OK"
else:
    print "ERROR"
    sys.exit(1)

g = xml_pickle.loads(x)
if g.a == (1,2,3):
    print "OK"
else:
    print "ERROR"
    sys.exit(1)
    
# method 2 -- StreamWriter is a compressed StringIO
x = xml_pickle.dumps(f,1)

# check header + contents
if x[0:2] == '\037\213':
    print "OK"
else:
    print "ERROR"
    sys.exit(1) 
Exemplo n.º 2
0
funcs.set_parser()
    
xml = '''<?xml version="1.0"?>
<!DOCTYPE Spam SYSTEM "spam.dtd" >
<Spam>
  <Eggs>Some text about eggs.</Eggs>
  <MoreSpam>Ode to Spam</MoreSpam>
</Spam>
'''

fh = StringIO(xml)
o = xo.make_instance(xml)
s = xp.dumps(o)
#print "---------- xml_objectify'd object, xml_pickle'd ----------"
#print s
o2 = xp.loads(s)
#print "---------- object after the pickle/unpickle cycle --------"
#print xp.dumps(o2)

if o.Eggs.PCDATA != o2.Eggs.PCDATA or \
   o.MoreSpam.PCDATA != o2.MoreSpam.PCDATA:
    raise "ERROR(1)"

print "** OK **"






Exemplo n.º 3
0
foo.ul = UserList.UserList()
foo.ul.append( date.DateTime(2007,8,9,10,11,12.13) )
foo.ul.append( date.DateTime(2008,9,10,11,12,13.14) )

foo.tup = (date.DateTime(2009,10,11,12,13,14.15),
           date.DateTime(2010,11,12,13,14,15.16))

#print "---PRE-PICKLE---"
#printfoo(foo)

x1 = xml_pickle.dumps(foo)
#print x1

#print "---POST-PICKLE---"
bar = xml_pickle.loads(x1)
#printfoo(bar)

testfoo(foo,bar)

x2 = xml_pickle.dumps(bar)

#print "---XML from original---"
#print x1

#print "---XML from copy---"
#print x2

print "** OK **"

Exemplo n.º 4
0
c = {'a':1,'b':2,'c':3,'d':[100,200,300]}
dd = c['d'] # make sure subitems get refchecked
uu = UserList([10,11,12])

u = UserList([[uu,c,b,a],[a,b,c,uu],[c,a,b,uu],dd])
#print u

# allow xml_pickle to read our namespace
setParanoia(0)

# by default, with references
x1 = xml_pickle.dumps(u)
#print x
#del u

g = xml_pickle.loads(x1)
#print g

if u != g:
    raise "ERROR(1)"

# next, using DEEPCOPY
#print "------ DEEP COPY ------"
setDeepCopy(1)
x2 = xml_pickle.dumps(g)
#print x
#del g

z = xml_pickle.loads(x2)

# deepcopy version should be significantly larger
Exemplo n.º 5
0
import gnosis.xml.pickle as xml_pickle
from gnosis.xml.pickle.util import setInBody
from types import *

class Foo:
    def __init__(self,s):
        self.s = s

class WeirdUni(unicode):
    def __init__(self,s):
        unicode.__init__(self,s)

# show that I didn't screw up normal strings
f = Foo('OK')
x = xml_pickle.dumps(f)
o = xml_pickle.loads(x)
print o.s, type(o.s)

f = Foo(u'OK')
x = xml_pickle.dumps(f)
o = xml_pickle.loads(x)
print o.s, type(o.s)

f = Foo(WeirdUni(u'OK'))
x = xml_pickle.dumps(f)
o = xml_pickle.loads(x)
print o.s, type(o.s)

# pickler should catch all these unpickleable cases.
# (to be fixed in gnosis 1.2.x)
Exemplo n.º 6
0
           o1.a != o2.a or o1.a.a != o2.a.a or \
           o1.a.b != o2.a.b or \
           o1.a.zz != o2.a.zz:
        raise "ERROR(1)"
    
#
# test all coredata+attr classes
#
#print "* LCOMBO"
x = top()
x.a = lcombo([4,5,6],1,2)
x.a.zz = 10
#print x.a, x.a.a, x.a.b, x.a.zz
s = xml_pickle.dumps(x)
#print s
g = xml_pickle.loads(s)
#print g.a, g.a.a, g.a.b, g.a.zz
check_combo(x,g)

#print "* DCOMBO"
x = top()
x.a = dcombo({'a':1,'b':2,'c':3},1,2)
x.a.zz = 10
#print x.a, x.a.a, x.a.b, x.a.zz
s = xml_pickle.dumps(x)
#print s
g = xml_pickle.loads(s)
#print g.a, g.a.a, g.a.b, g.a.zz
check_combo(x,g)

#print "* TCOMBO"
Exemplo n.º 7
0
import funcs

funcs.set_parser()
    
class foo: pass

# so we can unpickle foo
xml_pickle.setParanoia(0)

# test the obvious self-refs
l = [1,2]
l.append(l)
#print l
x = xml_pickle.dumps(l)
#print x
g = xml_pickle.loads(x)
#print g
# check values & ref
if g[0] != l[0] or g[1] != l[1] or id(g[2]) != id(g):
    raise "ERROR(1)"

d = {'a':1}
d['b'] = d
#print d
x = xml_pickle.dumps(d)
#print x
g = xml_pickle.loads(x)
#print g
# check values & ref
if g['a'] != 1 or id(g['b']) != id(g):
    raise "ERROR(2)"
Exemplo n.º 8
0
# test binary pickling

import gnosis.xml.pickle as xml_pickle
import gzip
from StringIO import StringIO

# --- Make an object to play with ---
class C: pass
o = C()
o.lst, o.dct = [1,2], {'spam':'eggs'}

x = xml_pickle.dumps(o,1)

# make sure xml_pickle really gzipped it
sio = StringIO(x)
gz = gzip.GzipFile('dummy','rb',9,sio)
if gz.read(5) != '<?xml':
    raise "ERROR(1)"

# reload object
o2 = xml_pickle.loads(x)

# check it
if o.lst != o2.lst or o.dct != o2.dct:
    raise "ERROR(2)"

print "** OK **"

Exemplo n.º 9
0
foo.ul.append( date.DateTime(2007,8,9,10,11,12.13) )
foo.ul.append( date.DateTime(2008,9,10,11,12,13.14) )

foo.tup = (date.DateTime(2009,10,11,12,13,14.15),
           date.DateTime(2010,11,12,13,14,15.16))

#print "---PRE-PICKLE---"
#printfoo(foo)

__disable_extensions()

x1 = xml_pickle.dumps(foo)
#print x1

#print "---POST-PICKLE---"
bar = xml_pickle.loads(x1)
#printfoo(bar)
#bar.hi()

checkfoo(foo,bar)

# same thing on copy

x2 = xml_pickle.dumps(bar)
baz = xml_pickle.loads(x2)

checkfoo(bar,baz)

#print "---XML from original---"
#print x1
Exemplo n.º 10
0
funcs.set_parser()

# handcoded object to load Foo (i.e. without the pickler having
# seen it before)
ud_xml = """<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject module="__main__" class="Foo">
</PyObject>
"""

class myfoo: pass
class Foo: pass

# print "On-the-fly -- SHOULD *NOT* SEE MODULE NAME IN XML"
p = xml_pickle.loads(ud_xml)
# print it so we can see the modname
#print "Fullname = "+str(p)
if str(p.__class__) != 'gnosis.xml.pickle.util._util.Foo':
    raise "ERROR(1)"

# dump and make sure modname doesn't stick
s = xml_pickle.dumps(p)
#print s
if re.search(s,'module'):
    raise "ERROR(2)"

#print "From (old) xml_pickle namespace -- SHOULD *NOT* SEE MODULE NAME IN XML"
# put Foo into xml_pickle namespace
xml_pickle.Foo = myfoo
p = xml_pickle.loads(ud_xml)
Exemplo n.º 11
0
class Test: pass

o1 = Test()
o1.s = "o1"

o2 = Test()
o2.s = "o2"

o1.obj1 = o2
o1.obj2 = o2
o2.obj3 = o1
o2.obj4 = o1

xml = xml_pickle.dumps(o1)
#print xml

z = xml_pickle.loads(xml)

# check it
if z.s != o1.s or z.obj1.s != o1.obj1.s or \
   z.obj2.s != o1.obj2.s or z.obj1.obj3.s != o1.obj1.obj3.s or \
   z.obj2.obj4.s != o1.obj2.obj4.s:
    raise "ERROR(1)"

print "** OK **"




Exemplo n.º 12
0
        self.f = a_test_function
        self.k = a_test_class


# always show the family tag so I can make sure it's right
setVerbose(1)
setParanoia(0)

f = foo()

# dump an object containing bools
s = xmp.dumps(f)
if SHOW_XML:
    print s

x = xmp.loads(s)
# print "Expect False, True, None, func, class: ",x.a,x.b,x.c,x.f,x.k

# check it
for attr in ["a", "b", "c", "f", "k"]:
    if getattr(f, attr) != getattr(x, attr):
        raise "ERROR(1)"

# dump builtin obj containing bools
s = xmp.dumps((True, False))
if SHOW_XML:
    print s

x = xmp.loads(s)
# print "Expect True, False: ",x[0],x[1]
Exemplo n.º 13
0
        self.a = False
        self.b = True
        self.c = None
        self.f = a_test_function
        self.k = a_test_class

# If this Python doesn't have True/False, then the unpickler
# will return 1/0 instead
if not pyconfig.Have_TrueFalse():
    True = 1
    False = 0

# the tests are portable versions of those in test_bools.py

# bools inside an object
x = xmp.loads(x1)

# check it
if x.a != False or x.b != True or x.c != None or \
   x.f != a_test_function or x.k != a_test_class:
    #print x.__dict__
    raise "ERROR(1)"

# bools inside a toplevel bltin
x = xmp.loads(x2)
if x[0] != True or x[1] != False:
    raise "ERROR(2)"

# bool as toplevel
x = xmp.loads(x3)
if x != True:
Exemplo n.º 14
0
ustring = u"Alef: %s, Omega: %s" % (unichr(1488), unichr(969))
pstring = "Only US-ASCII characters"
estring = "Only US-ASCII with line breaks\n\tthat was a tab"
class C:
    def __init__(self, ustring, pstring, estring):
        self.ustring = ustring
        self.pstring = pstring
        self.estring = estring
o = C(ustring, pstring, estring)

#-- Try standard pickling cycle (default setInBody() settings)
#print '\n------------* Pickle with Python and Unicode strings *------------------'
xml = dumps(o)
#print xml,
#print '------------* Restored attributes from different strings *--------------'
o2 = loads(xml)
# check types explicitly, since comparison will coerce types
if not isinstance(o2.ustring,UnicodeType):
    raise "AAGH! Didn't get UnicodeType"
if not isinstance(o2.pstring,StringType):
    raise "AAGH! Didn't get StringType for pstring"
if not isinstance(o2.estring,StringType):
    raise "AAGH! Didn't get StringType for estring"

#print "UNICODE:", `o2.ustring`, type(o2.ustring)
#print "PLAIN:  ", o2.pstring, type(o2.pstring)
#print "ESCAPED:", o2.estring, type(o2.estring)

if o.ustring != o2.ustring or \
   o.pstring != o2.pstring or \
   o.estring != o2.estring:
Exemplo n.º 15
0
print "Size of gzip'd xml_pickle:   ", len(xml_pickle.dumps(o,1))

#-----------------------------------------------------------------------
# Second: look at actual compressed and uncompressed (small) pickles
#-----------------------------------------------------------------------
o = C()
o.lst = [1,2]
o.dct = {'spam':'eggs'}

print "--------------- Uncompressed xml_pickle: ---------------"
print xml_pickle.dumps(o),
print "--------------- Compressed xml_pickle: -----------------"
print `xml_pickle.dumps(o,1)`

#-----------------------------------------------------------------------
# Third: make sure compressed pickle makes it through restore cycle
#-----------------------------------------------------------------------
print "------------------------------------------------------"
try:
    xml_pickle.loads(xml_pickle.dumps(o))
    print "Pickle/restore cycle with compression:  OK"
except:
    print "Pickle/restore cycle with compression:  FAILED!"

try:
    xml_pickle.loads('CORRUPT'+xml_pickle.dumps(o))
    print "Pickle/restore corrupt data with compression:  OK"
except:
    print "Pickle/restore corrupt data with compression:  FAILED!"

Exemplo n.º 16
0
#

s = pickle.dumps(f)
x = xml_pickle.dumps(f)

g = pickle.loads(s)
testfoo(f, g)

# have to do this here, otherwise "m" gets recreated
# with an on-the-fly class that breaks regular pickle
# (as it should --- pickle shouldn't know about xml_pickle.foo)
# we could just not reuse m, but this is kind of a neat
# way to show what's going on, and how PARANOIA works
xml_pickle.setParanoia(0)

m = xml_pickle.loads(x)
testfoo(f, m)

# now test dump/load to/from a file

fh = open('aaa', 'w')
pickle.dump(m, fh)
fh.close()

fh = open('bbb', 'w')
xml_pickle.dump(m, fh)
fh.close()

fh = open('aaa', 'r')
g = pickle.load(fh)
fh.close()