def testStaticDynamicObj(self):
self.class_mapper.mapClass(
class_def.DynamicClassDef(self.Spam, 'alias.spam', ('spam', )))
test = self.Spam()
test.ham = 'foo'
encoded = '\x0A\x1B\x15alias.spam' # obj header
encoded += '\x09spam' # static attr definition
encoded += '\x06\x09eggs' # static attrs
encoded += '\x07ham\x06\x07foo\x01' #dynamic attrs
result = decode.decode(
DecoderContext(encoded,
class_def_mapper=self.class_mapper,
amf3=True))
self.assertEquals('eggs', result.spam)
self.assertEquals('foo', result.ham)
result = decode.decode(
DecoderContext(StringIO(encoded),
class_def_mapper=self.class_mapper,
amf3=True))
self.assertEquals('eggs', result.spam)
self.assertEquals('foo', result.ham)
self.class_mapper.unmapClass(self.Spam)
def testAnonObj(self):
encoded = '\x03' #header
encoded += '\x00\x04spam\x02\x00\x04eggs' #values
encoded += '\x00\x00\t' # terminator
result = decode.decode(DecoderContext(encoded))
self.assertEquals('eggs', result['spam'])
result = decode.decode(DecoderContext(StringIO(encoded)))
self.assertEquals('eggs', result['spam'])
def testAnonObj(self):
encoded = '\x03' #header
encoded += '\x00\x04spam\x02\x00\x04eggs' #values
encoded += '\x00\x00\t' # terminator
result = decode.decode(DecoderContext(encoded))
self.assertEquals('eggs', result['spam'])
result = decode.decode(DecoderContext(StringIO(encoded)))
self.assertEquals('eggs', result['spam'])
def testMixedArray(self):
encoded = '\x08\x00\x00\x00\x00' # mixed array header
encoded += '\x00\x04spam\x02\x00\x04eggs' #values
encoded += '\x00\x00\t' # terminator
result = decode.decode(DecoderContext(encoded))
self.assertEquals('eggs', result['spam'])
result = decode.decode(DecoderContext(StringIO(encoded)))
self.assertEquals('eggs', result['spam'])
def testMixedArray(self):
encoded = '\x08\x00\x00\x00\x00' # mixed array header
encoded += '\x00\x04spam\x02\x00\x04eggs' #values
encoded += '\x00\x00\t' # terminator
result = decode.decode(DecoderContext(encoded))
self.assertEquals('eggs', result['spam'])
result = decode.decode(DecoderContext(StringIO(encoded)))
self.assertEquals('eggs', result['spam'])
def testArray(self):
decoded = [0, 1, 1.23456789]
encoded = '\x0A\x00\x00\x00\x03' # 3 element array header
encoded += '\x00\x00\x00\x00\x00\x00\x00\x00\x00' # element 1
encoded += '\x00\x3f\xf0\x00\x00\x00\x00\x00\x00' #element 2
encoded += '\x00\x3f\xf3\xc0\xca\x42\x83\xde\x1b' #element 3
result = decode.decode(DecoderContext(encoded))
for i, obj in enumerate(decoded):
self.assertEquals(obj, result[i])
result = decode.decode(DecoderContext(StringIO(encoded)))
for i, obj in enumerate(decoded):
self.assertEquals(obj, result[i])
def testArray(self):
decoded = [0, 1, 1.23456789]
encoded = '\x0A\x00\x00\x00\x03' # 3 element array header
encoded += '\x00\x00\x00\x00\x00\x00\x00\x00\x00' # element 1
encoded += '\x00\x3f\xf0\x00\x00\x00\x00\x00\x00' #element 2
encoded += '\x00\x3f\xf3\xc0\xca\x42\x83\xde\x1b' #element 3
result = decode.decode(DecoderContext(encoded))
for i, obj in enumerate(decoded):
self.assertEquals(obj, result[i])
result = decode.decode(DecoderContext(StringIO(encoded)))
for i, obj in enumerate(decoded):
self.assertEquals(obj, result[i])
def readExternal(self, obj, context):
flags = self._readFlags(context)
for i, flag in enumerate(flags):
if i == 0:
if flag & self.BODY_FLAG:
obj.body = decode(context)
else:
obj.body = None
if flag & self.CLIENT_ID_FLAG:
obj.clientId = decode(context)
else:
obj.clientId = None
if flag & self.DESTINATION_FLAG:
obj.destination = decode(context)
else:
obj.destination = None
if flag & self.HEADERS_FLAG:
obj.headers = decode(context)
else:
obj.headers = None
if flag & self.MESSAGE_ID_FLAG:
obj.messageId = decode(context)
else:
obj.messageId = None
if flag & self.TIMESTAMP_FLAG:
obj.timestamp = decode(context)
else:
obj.timestamp = None
if flag & self.TIME_TO_LIVE_FLAG:
obj.timeToLive = decode(context)
else:
obj.timeToLive = None
if i == 1:
if flag & self.CLIENT_ID_BYTES_FLAG:
clientIdBytes = decode(context)
obj.clientId = self._readUid(clientIdBytes)
else:
if not hasattr(obj, 'clientId'):
obj.clientId = None
if flag & self.MESSAGE_ID_BYTES_FLAG:
messageIdBytes = decode(context)
obj.messageId = self._readUid(messageIdBytes)
else:
if not hasattr(obj, 'messageId'):
obj.messageId = None
def testDynamicObj(self):
self.class_mapper.mapClass(class_def.DynamicClassDef(self.Spam, 'alias.spam', ()))
encoded = '\x0A\x0B\x15alias.spam'
encoded += '\x09spam\x06\x09eggs\x01' # dynamic attrs
result = decode.decode(DecoderContext(encoded,
class_def_mapper=self.class_mapper, amf3=True))
self.assertEquals('eggs', result.spam)
result = decode.decode(DecoderContext(StringIO(encoded),
class_def_mapper=self.class_mapper, amf3=True))
self.assertEquals('eggs', result.spam)
self.class_mapper.unmapClass(self.Spam)
def testArrayCollection(self):
encoded = '\x0A\x07\x43flex.messaging.io.ArrayCollection' # Object header
encoded += '\x09\x09\x01' #array header
encoded += '\x04\x00' #array element 1
encoded += '\x04\x01' #array element 2
encoded += '\x04\x02' #array element 3
encoded += '\x04\x03' #array element 4
result = decode.decode(DecoderContext(encoded, amf3=True))
for i in range(4):
self.assertEquals(i, result[i])
result = decode.decode(DecoderContext(StringIO(encoded), amf3=True))
for i in range(4):
self.assertEquals(i, result[i])
def testArrayCollection(self):
encoded = '\x0A\x07\x43flex.messaging.io.ArrayCollection' # Object header
encoded += '\x09\x09\x01' #array header
encoded += '\x04\x00' #array element 1
encoded += '\x04\x01' #array element 2
encoded += '\x04\x02' #array element 3
encoded += '\x04\x03' #array element 4
result = decode.decode(DecoderContext(encoded, amf3=True))
for i in range(4):
self.assertEquals(i, result[i])
result = decode.decode(DecoderContext(StringIO(encoded), amf3=True))
for i in range(4):
self.assertEquals(i, result[i])
def testDate(self):
import datetime
encoded = '\x08\x01Bp+6!\x15\x80\x00'
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(2005, result.year)
self.assertEquals(3, result.month)
self.assertEquals(18, result.day)
self.assertEquals(1, result.hour)
self.assertEquals(58, result.minute)
self.assertEquals(31, result.second)
encoded = '\x08\x01Bo%\xe2\xb2\x80\x00\x00'
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(2003, result.year)
self.assertEquals(12, result.month)
self.assertEquals(1, result.day)
def testDate(self):
import datetime
encoded = '\x08\x01Bp+6!\x15\x80\x00'
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(2005, result.year)
self.assertEquals(3, result.month)
self.assertEquals(18, result.day)
self.assertEquals(1, result.hour)
self.assertEquals(58, result.minute)
self.assertEquals(31, result.second)
encoded = '\x08\x01Bo%\xe2\xb2\x80\x00\x00'
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(2003, result.year)
self.assertEquals(12, result.month)
self.assertEquals(1, result.day)
def testComplexDict(self):
complex = {'element': 'ignore', 'objects': self.buildComplex()}
enc_context = EncoderContext(use_collections=False, use_proxies=False,
class_def_mapper=self.class_mapper, amf3=True)
encoded = encode(complex, enc_context)
decoded = decode(DecoderContext(encoded, class_def_mapper=self.class_mapper, amf3=True))
self.resultTest(decoded['objects'])
def testStaticObj(self):
self.class_mapper.mapClass(class_def.ClassDef(self.Spam, 'alias.spam', ('spam',)))
encoded = '\x0A\x13\x15alias.spam'
encoded += '\x09spam' # static attr definition
encoded += '\x06\x09eggs' # static attrs
result = decode.decode(DecoderContext(encoded,
class_def_mapper=self.class_mapper, amf3=True))
self.assertEquals('eggs', result.spam)
result = decode.decode(DecoderContext(StringIO(encoded),
class_def_mapper=self.class_mapper, amf3=True))
self.assertEquals('eggs', result.spam)
self.class_mapper.unmapClass(self.Spam)
def testEncodeFloat(self):
tests = {
0.1: '\x05\x3f\xb9\x99\x99\x99\x99\x99\x9a',
0.123456789: '\x05\x3f\xbf\x9a\xdd\x37\x39\x63\x5f'
}
for number, encoding in tests.iteritems():
self.assertEquals(number, decode.decode(DecoderContext(encoding, amf3=True)))
def testLongStringAmf3(self):
decoded = 's' * 65537
encoded = encode(decoded, EncoderContext(amf3=True))
result = decode(DecoderContext(encoded, amf3=True))
self.assertEquals(len(decoded), len(result))
for char in result:
self.assertEquals('s', char)
def testDict(self):
encoded = '\x0A\x0B\x01' # Object header
encoded += '\x09spam' # key
encoded += '\x06\x09eggs' #value
encoded += '\x01' # empty string terminator
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals('eggs', result['spam'])
def testDictRef(self):
encoded = '\x09\x05\x01' #array header
encoded += '\x0A\x0B\x01\x09spam\x06\x09eggs\x01' #array element 1 (dict encoded)
encoded += '\x0A\x02' # array element 2 (reference to dict)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals('eggs', result[0]['spam'])
self.assertEquals(result[0], result[1])
def testDictRef(self):
encoded = '\x09\x05\x01' #array header
encoded += '\x0A\x0B\x01\x09spam\x06\x09eggs\x01' #array element 1 (dict encoded)
encoded += '\x0A\x02' # array element 2 (reference to dict)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals('eggs', result[0]['spam'])
self.assertEquals(result[0], result[1])
def readExternal(self, obj, context):
AbstractSmallMsgDef.readExternal(self, obj, context)
flags = self._readFlags(context)
for i, flag in enumerate(flags):
if i == 0:
if flag & self.CORRELATION_ID_FLAG:
obj.correlationId = decode(context)
else:
obj.correlationId = None
if flag & self.CORRELATION_ID_BYTES_FLAG:
correlationIdBytes = decode(context)
obj.correlationId = self._readUid(correlationIdBytes)
else:
if not hasattr(obj, 'correlationId'):
obj.correlationId = None
def testString(self):
tests = {
'': '\x02\x00\x00',
'hello': '\x02\x00\x05hello'
}
for string, encoding in tests.iteritems():
self.assertEquals(string, decode.decode(DecoderContext(encoding)))
def testLongListAmf0(self):
decoded = [None] * 65537
encoded = encode(decoded)
result = decode(encoded)
self.assertEquals(len(decoded), len(result))
for val in result:
self.assertEquals(None, val)
def testLongStringAmf0(self):
decoded = 's' * 65537
encoded = encode(decoded)
result = decode(encoded)
self.assertEquals(len(decoded), len(result))
for char in result:
self.assertEquals('s', char)
def testLongListAmf3(self):
decoded = [None] * 65537
encoded = encode(decoded, EncoderContext(amf3=True))
result = decode(DecoderContext(encoded, amf3=True))
self.assertEquals(len(decoded), len(result))
for val in result:
self.assertEquals(None, val)
def testDict(self):
encoded = '\x0A\x0B\x01' # Object header
encoded += '\x09spam' # key
encoded += '\x06\x09eggs' #value
encoded += '\x01' # empty string terminator
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals('eggs', result['spam']);
def testEncodeLong(self):
tests = {
0x10000000: '\x05\x41\xb0\x00\x00\x00\x00\x00\x00',
-0x10000001: '\x05\xc1\xb0\x00\x00\x01\x00\x00\x00',
-0x10000000: '\x04\xc0\x80\x80\x00'
}
for number, encoding in tests.iteritems():
self.assertEquals(number, decode.decode(DecoderContext(encoding, amf3=True)))
def testXml(self):
import xml.dom.minidom
encoded = '\x0F' # XML header
encoded += '\x00\x00\x00\x55' # String header
encoded += '<?xml version="1.0" ?><test>\n <test_me>tester</test_me>\n </test>' # encoded XML
result = decode.decode(DecoderContext(encoded))
self.assertEquals(xml.dom.minidom.Document, result.__class__)
def testEncodeFloat(self):
tests = {
0.1: '\x05\x3f\xb9\x99\x99\x99\x99\x99\x9a',
0.123456789: '\x05\x3f\xbf\x9a\xdd\x37\x39\x63\x5f'
}
for number, encoding in tests.iteritems():
self.assertEquals(
number, decode.decode(DecoderContext(encoding, amf3=True)))
def testUnicode(self):
tests = {
u'': '\x06\x01',
u'hello': '\x06\x0bhello',
u'ᚠᛇᚻ': '\x06\x13\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb'
}
for string, encoding in tests.iteritems():
self.assertEquals(string, decode.decode(DecoderContext(encoding, amf3=True)))
def testEncodeXmlRef(self):
import xml.dom.minidom
encoded = '\x09\x05\x01' #array header
encoded += '\x0B\x81\x2B<?xml version="1.0" ?><test>\n <test_me>tester</test_me>\n </test>' # array element 1 (encoded dom)
encoded += '\x0B\x02' # array element 2 (reference to dom)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(xml.dom.minidom.Document, result[0].__class__)
self.assertEquals(result[0], result[1])
def testEncodeXmlRef(self):
import xml.dom.minidom
encoded = '\x09\x05\x01' #array header
encoded += '\x0B\x81\x2B<?xml version="1.0" ?><test>\n <test_me>tester</test_me>\n </test>' # array element 1 (encoded dom)
encoded += '\x0B\x02' # array element 2 (reference to dom)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(xml.dom.minidom.Document, result[0].__class__)
self.assertEquals(result[0], result[1])
def testXml(self):
import xml.dom.minidom
encoded = '\x0B' # XML header
encoded += '\x81\x2B' # String header
encoded += '<?xml version="1.0" ?><test>\n <test_me>tester</test_me>\n </test>' # encoded XML
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals(xml.dom.minidom.Document, result.__class__)
def testStaticObj(self):
self.class_mapper.mapClass(class_def = class_def.ClassDef(self.Spam, 'alias.spam', ('spam')))
encoded = '\x10\x00\x0Aalias.spam'
encoded += '\x00\x04spam\x02\x00\x04eggs\x00\x00\x09' # dynamic attrs
result = decode.decode(DecoderContext(encoded, class_def_mapper=self.class_mapper))
self.class_mapper.unmapClass(self.Spam)
self.assertEquals('eggs', result.spam)
def testArrayCollectionRef(self):
encoded = '\x0A\x07\x43flex.messaging.io.ArrayCollection\x09\x05\x01' # array header
encoded += '\x0A\x01\x09\x09\x01\x04\x00\x04\x01\x04\x02\x04\x03' # array element 1 (test_tuple encoded)
encoded += '\x0A\x04' # array element 2 (reference to test_tuple)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals([].__class__, result.__class__)
self.assertEquals(result[0], result[1])
for i in range(4):
self.assertEquals(i, result[0][i])
def testArrayCollectionRef(self):
encoded = '\x0A\x07\x43flex.messaging.io.ArrayCollection\x09\x05\x01' # array header
encoded += '\x0A\x01\x09\x09\x01\x04\x00\x04\x01\x04\x02\x04\x03' # array element 1 (test_tuple encoded)
encoded += '\x0A\x04' # array element 2 (reference to test_tuple)
result = decode.decode(DecoderContext(encoded, amf3=True))
self.assertEquals([].__class__, result.__class__)
self.assertEquals(result[0], result[1])
for i in range(4):
self.assertEquals(i, result[0][i])
def testEncodeLong(self):
tests = {
0x10000000: '\x05\x41\xb0\x00\x00\x00\x00\x00\x00',
-0x10000001: '\x05\xc1\xb0\x00\x00\x01\x00\x00\x00',
-0x10000000: '\x04\xc0\x80\x80\x00'
}
for number, encoding in tests.iteritems():
self.assertEquals(
number, decode.decode(DecoderContext(encoding, amf3=True)))
def testUnicode(self):
tests = {
u'': '\x06\x01',
u'hello': '\x06\x0bhello',
u'ᚠᛇᚻ': '\x06\x13\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb'
}
for string, encoding in tests.iteritems():
self.assertEquals(
string, decode.decode(DecoderContext(encoding, amf3=True)))
def testArray(self):
encoded = '\x09\x09\x01' #array header
encoded += '\x04\x00' #array element 1
encoded += '\x04\x01' #array element 2
encoded += '\x04\x02' #array element 3
encoded += '\x04\x03' #array element 4
result = decode.decode(DecoderContext(encoded, amf3=True))
for i, val in enumerate(result):
self.assertEquals(i, val)
def testDate(self):
import datetime
encoded = '\x0BBp+6!\x15\x80\x00\x00\x00'
result = decode.decode(DecoderContext(encoded))
self.assertEquals(2005, result.year)
self.assertEquals(3, result.month)
self.assertEquals(18, result.day)
self.assertEquals(1, result.hour)
self.assertEquals(58, result.minute)
self.assertEquals(31, result.second)
def testDate(self):
import datetime
encoded = '\x0BBp+6!\x15\x80\x00\x00\x00'
result = decode.decode(DecoderContext(encoded))
self.assertEquals(2005, result.year)
self.assertEquals(3, result.month)
self.assertEquals(18, result.day)
self.assertEquals(1, result.hour)
self.assertEquals(58, result.minute)
self.assertEquals(31, result.second)
def readExternal(self, obj, context):
AsyncSmallMsgDef.readExternal(self, obj, context)
flags = self._readFlags(context)
for i, flag in enumerate(flags):
if i == 0:
if flag & self.OPERATION_FLAG:
obj.operation = decode(context)
else:
obj.operation = None
def testArray(self):
encoded = '\x09\x09\x01' #array header
encoded += '\x04\x00' #array element 1
encoded += '\x04\x01' #array element 2
encoded += '\x04\x02' #array element 3
encoded += '\x04\x03' #array element 4
result = decode.decode(DecoderContext(encoded, amf3=True))
for i, val in enumerate(result):
self.assertEquals(i, val);
def testDynamicObj(self):
self.class_mapper.mapClass(
class_def.DynamicClassDef(self.Spam, 'alias.spam', ()))
encoded = '\x0A\x0B\x15alias.spam'
encoded += '\x09spam\x06\x09eggs\x01' # dynamic attrs
result = decode.decode(
DecoderContext(encoded,
class_def_mapper=self.class_mapper,
amf3=True))
self.assertEquals('eggs', result.spam)
result = decode.decode(
DecoderContext(StringIO(encoded),
class_def_mapper=self.class_mapper,
amf3=True))
self.assertEquals('eggs', result.spam)
self.class_mapper.unmapClass(self.Spam)
def testReusableDecoderContext(self):
import amfast.encoder
encoder = amfast.encoder.Encoder(amf3=True)
pre = {'foo': 'bar'}
post = encoder.encode(pre)
ct = DecoderContext(post, amf3=True)
result = decode.decode(ct)
assert result == pre
self.assertRaises(buffer.BufferError, decode.decode, ct)
def testReusableDecoderContext(self):
import amfast.encoder
encoder = amfast.encoder.Encoder(amf3=True)
pre = {'foo' : 'bar'}
post = encoder.encode(pre)
ct = DecoderContext(post, amf3=True)
result = decode.decode(ct)
assert result == pre
self.assertRaises(buffer.BufferError, decode.decode, ct)
def testStaticObj(self):
self.class_mapper.mapClass(
class_def=class_def.ClassDef(self.Spam, 'alias.spam', ('spam')))
encoded = '\x10\x00\x0Aalias.spam'
encoded += '\x00\x04spam\x02\x00\x04eggs\x00\x00\x09' # dynamic attrs
result = decode.decode(
DecoderContext(encoded, class_def_mapper=self.class_mapper))
self.class_mapper.unmapClass(self.Spam)
self.assertEquals('eggs', result.spam)
def testUnicodeRefs(self):
test = ['hello', 'hello', 'hello', 'hello']
encoded = '\x09\x09\x01' # array header
encoded += '\x06\x0bhello' # array element 1 (hello encoded)
encoded += '\x06\x00' #array element 2 (reference to hello)
encoded += '\x06\x00' #array element 3 (reference to hello)
encoded += '\x06\x00' #array element 4 (reference to hello)
results = decode.decode(DecoderContext(encoded, amf3=True))
for result in results:
self.assertEquals('hello', result)
def testUnicodeRefs(self):
test = ['hello', 'hello', 'hello', 'hello']
encoded = '\x09\x09\x01' # array header
encoded += '\x06\x0bhello' # array element 1 (hello encoded)
encoded += '\x06\x00' #array element 2 (reference to hello)
encoded += '\x06\x00' #array element 3 (reference to hello)
encoded += '\x06\x00' #array element 4 (reference to hello)
results = decode.decode(DecoderContext(encoded, amf3=True))
for result in results:
self.assertEquals('hello', result)
def testReferences(self):
encoded = '\x0A\x00\x00\x00\x04' # 3 element array header
encoded += '\x03\x00\x04spam\x02\x00\x04eggs\x00\x00\t' # obj 1
encoded += '\x07\x00\x01' # ref to obj 1
encoded += '\x07\x00\x01' # ref to obj 1
encoded += '\x07\x00\x00' # circular ref
result = decode.decode(DecoderContext(encoded))
self.assertEquals(4, len(result))
self.assertEquals(result, result.pop(-1))
for obj in result:
self.assertEquals('eggs', obj['spam'])
def testNumber(self):
tests = {
0: '\x00\x00\x00\x00\x00\x00\x00\x00\x00',
0.2: '\x00\x3f\xc9\x99\x99\x99\x99\x99\x9a',
1: '\x00\x3f\xf0\x00\x00\x00\x00\x00\x00',
42: '\x00\x40\x45\x00\x00\x00\x00\x00\x00',
-123: '\x00\xc0\x5e\xc0\x00\x00\x00\x00\x00',
1.23456789: '\x00\x3f\xf3\xc0\xca\x42\x83\xde\x1b'
}
for number, encoding in tests.iteritems():
self.assertEquals(number, decode.decode(DecoderContext(encoding)))
def testClassRef(self):
self.class_mapper.mapClass(class_def.ClassDef(self.Spam, 'alias.spam', ('spam',)))
encoded = '\x09\x05\x01' #array header
encoded += '\x0A\x13\x15alias.spam\x09spam\x06\x09eggs' # array element 1
encoded += '\x0A\x01\x06\x07foo' # array element 2
result = decode.decode(DecoderContext(encoded,
class_def_mapper=self.class_mapper, amf3=True))
self.class_mapper.unmapClass(self.Spam)
self.assertEquals(result[0].__class__, result[1].__class__)
