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 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 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 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 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 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 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 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 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__)