from .preserves import * import unittest import sys if isinstance(chr(123), bytes): def _byte(x): return chr(x) def _hex(x): return x.encode('hex') else: def _byte(x): return bytes([x]) def _hex(x): return x.hex() def _buf(*args): result = [] for chunk in args: if isinstance(chunk, bytes): result.append(chunk) elif isinstance(chunk, basestring): result.append(chunk.encode('utf-8')) elif isinstance(chunk, numbers.Number): result.append(_byte(chunk)) else: raise Exception('Invalid chunk in _buf %r' % (chunk,)) result = b''.join(result) return result def _varint(v): e = Encoder() e.varint(v) return e.contents() def _d(bs): return decode(bs) def _e(v): return encode(v) def _R(k, *args): return Record(Symbol(k), args) class CodecTests(unittest.TestCase): def _roundtrip(self, forward, expected, back=None, nondeterministic=False): if back is None: back = forward self.assertEqual(_d(_e(forward)), back) self.assertEqual(_d(_e(back)), back) self.assertEqual(_d(expected), back) if not nondeterministic: actual = _e(forward) self.assertEqual(actual, expected, '%s != %s' % (_hex(actual), _hex(expected))) def test_decode_varint(self): with self.assertRaises(DecodeError): Decoder(_buf()).varint() self.assertEqual(Decoder(_buf(0)).varint(), 0) self.assertEqual(Decoder(_buf(10)).varint(), 10) self.assertEqual(Decoder(_buf(100)).varint(), 100) self.assertEqual(Decoder(_buf(200, 1)).varint(), 200) self.assertEqual(Decoder(_buf(0b10101100, 0b00000010)).varint(), 300) self.assertEqual(Decoder(_buf(128, 148, 235, 220, 3)).varint(), 1000000000) def test_encode_varint(self): self.assertEqual(_varint(0), _buf(0)) self.assertEqual(_varint(10), _buf(10)) self.assertEqual(_varint(100), _buf(100)) self.assertEqual(_varint(200), _buf(200, 1)) self.assertEqual(_varint(300), _buf(0b10101100, 0b00000010)) self.assertEqual(_varint(1000000000), _buf(128, 148, 235, 220, 3)) def test_simple_seq(self): self._roundtrip([1,2,3,4], _buf(0xb5, 0x91, 0x92, 0x93, 0x94, 0x84), back=(1,2,3,4)) self._roundtrip(iter([1,2,3,4]), _buf(0xb5, 0x91, 0x92, 0x93, 0x94, 0x84), back=(1,2,3,4), nondeterministic=True) self._roundtrip((-2,-1,0,1), _buf(0xb5, 0x9E, 0x9F, 0x90, 0x91, 0x84)) def test_str(self): self._roundtrip(u'hello', _buf(0xb1, 0x05, 'hello')) def test_mixed1(self): self._roundtrip((u'hello', Symbol(u'there'), b'world', (), set(), True, False), _buf(0xb5, 0xb1, 0x05, 'hello', 0xb3, 0x05, 'there', 0xb2, 0x05, 'world', 0xb5, 0x84, 0xb6, 0x84, 0x81, 0x80, 0x84)) def test_signedinteger(self): self._roundtrip(-257, _buf(0xa1, 0xFE, 0xFF)) self._roundtrip(-256, _buf(0xa1, 0xFF, 0x00)) self._roundtrip(-255, _buf(0xa1, 0xFF, 0x01)) self._roundtrip(-254, _buf(0xa1, 0xFF, 0x02)) self._roundtrip(-129, _buf(0xa1, 0xFF, 0x7F)) self._roundtrip(-128, _buf(0xa0, 0x80)) self._roundtrip(-127, _buf(0xa0, 0x81)) self._roundtrip(-4, _buf(0xa0, 0xFC)) self._roundtrip(-3, _buf(0x9D)) self._roundtrip(-2, _buf(0x9E)) self._roundtrip(-1, _buf(0x9F)) self._roundtrip(0, _buf(0x90)) self._roundtrip(1, _buf(0x91)) self._roundtrip(12, _buf(0x9C)) self._roundtrip(13, _buf(0xa0, 0x0D)) self._roundtrip(127, _buf(0xa0, 0x7F)) self._roundtrip(128, _buf(0xa1, 0x00, 0x80)) self._roundtrip(255, _buf(0xa1, 0x00, 0xFF)) self._roundtrip(256, _buf(0xa1, 0x01, 0x00)) self._roundtrip(32767, _buf(0xa1, 0x7F, 0xFF)) self._roundtrip(32768, _buf(0xa2, 0x00, 0x80, 0x00)) self._roundtrip(65535, _buf(0xa2, 0x00, 0xFF, 0xFF)) self._roundtrip(65536, _buf(0xa2, 0x01, 0x00, 0x00)) self._roundtrip(131072, _buf(0xa2, 0x02, 0x00, 0x00)) def test_floats(self): self._roundtrip(Float(1.0), _buf(0x82, 0x3f, 0x80, 0, 0)) self._roundtrip(1.0, _buf(0x83, 0x3f, 0xf0, 0, 0, 0, 0, 0, 0)) self._roundtrip(-1.202e300, _buf(0x83, 0xfe, 0x3c, 0xb7, 0xb7, 0x59, 0xbf, 0x04, 0x26)) def test_dict(self): self._roundtrip({ Symbol(u'a'): 1, u'b': True, (1, 2, 3): b'c', ImmutableDict({ Symbol(u'first-name'): u'Elizabeth', }): { Symbol(u'surname'): u'Blackwell' } }, _buf(0xB7, 0xb3, 0x01, "a", 0x91, 0xb1, 0x01, "b", 0x81, 0xb5, 0x91, 0x92, 0x93, 0x84, 0xb2, 0x01, "c", 0xB7, 0xb3, 0x0A, "first-name", 0xb1, 0x09, "Elizabeth", 0x84, 0xB7, 0xb3, 0x07, "surname", 0xb1, 0x09, "Blackwell", 0x84, 0x84), nondeterministic = True) def test_iterator_stream(self): d = {u'a': 1, u'b': 2, u'c': 3} r = r'b5(b5b1016.9.84){3}84' if hasattr(d, 'iteritems'): # python 2 bs = _e(d.iteritems()) self.assertRegexpMatches(_hex(bs), r) else: # python 3 bs = _e(d.items()) self.assertRegex(_hex(bs), r) self.assertEqual(sorted(_d(bs)), [(u'a', 1), (u'b', 2), (u'c', 3)]) def test_long_sequence(self): self._roundtrip((False,) * 14, _buf(0xb5, b'\x80' * 14, 0x84)) self._roundtrip((False,) * 15, _buf(0xb5, b'\x80' * 15, 0x84)) self._roundtrip((False,) * 100, _buf(0xb5, b'\x80' * 100, 0x84)) self._roundtrip((False,) * 200, _buf(0xb5, b'\x80' * 200, 0x84)) def test_embedded_id(self): class A: def __init__(self, a): self.a = a a1 = A(1) a2 = A(1) self.assertNotEqual(_e(a1), _e(a2)) self.assertEqual(_e(a1), _e(a1)) from .preserves import _ord self.assertEqual(_ord(_e(a1)[0]), 0x86) self.assertEqual(_ord(_e(a2)[0]), 0x86) def test_decode_embedded_absent(self): with self.assertRaises(DecodeError): decode(b'\x86\xa0\xff') def test_encode_embedded(self): objects = [] def enc(p): objects.append(p) return len(objects) - 1 self.assertEqual(encode([object(), object()], encode_embedded = enc), b'\xb5\x86\x90\x86\x91\x84') def test_decode_embedded(self): objects = [123, 234] def dec(v): return objects[v] self.assertEqual(decode(b'\xb5\x86\x90\x86\x91\x84', decode_embedded = dec), (123, 234)) def add_method(d, tName, fn): if hasattr(fn, 'func_name'): # python2 fname = str(fn.func_name + '_' + tName) fn.func_name = fname else: # python3 fname = str(fn.__name__ + '_' + tName) fn.__name__ = fname d[fname] = fn expected_values = { "annotation1": { "forward": annotate(9, u"abc"), "back": 9 }, "annotation2": { "forward": annotate([[], annotate([], u"x")], u"abc", u"def"), "back": ((), ()) }, "annotation3": { "forward": annotate(5, annotate(2, 1), annotate(4, 3)), "back": 5 }, "annotation5": { "forward": annotate(_R('R', annotate(Symbol('f'), Symbol('af'))), Symbol('ar')), "back": _R('R', Symbol('f')) }, "annotation6": { "forward": Record(annotate(Symbol('R'), Symbol('ar')), [annotate(Symbol('f'), Symbol('af'))]), "back": _R('R', Symbol('f')) }, "annotation7": { "forward": annotate([], Symbol('a'), Symbol('b'), Symbol('c')), "back": () }, "record2": { "value": _R('observe', _R('speak', _R('discard'), _R('capture', _R('discard')))) }, } def get_expected_values(tName, textForm): entry = expected_values.get(tName, {"value": textForm}) if 'value' in entry: return { "forward": entry['value'], "back": entry['value'] } elif 'forward' in entry and 'back' in entry: return entry else: raise Exception('Invalid expected_values entry for ' + tName) def install_test(d, variant, tName, binaryForm, annotatedTextForm): textForm = annotatedTextForm.strip() entry = get_expected_values(tName, textForm) forward = entry['forward'] back = entry['back'] def test_match_expected(self): self.assertEqual(textForm, back) def test_roundtrip(self): self.assertEqual(self.DS(self.E(textForm)), back) def test_forward(self): self.assertEqual(self.DS(self.E(forward)), back) def test_back(self): self.assertEqual(self.DS(binaryForm), back) def test_back_ann(self): self.assertEqual(self.D(self.E(annotatedTextForm)), annotatedTextForm) def test_encode(self): self.assertEqual(self.E(forward), binaryForm) def test_encode_ann(self): self.assertEqual(self.E(annotatedTextForm), binaryForm) add_method(d, tName, test_match_expected) add_method(d, tName, test_roundtrip) add_method(d, tName, test_forward) add_method(d, tName, test_back) add_method(d, tName, test_back_ann) if variant not in ['decode', 'nondeterministic']: add_method(d, tName, test_encode) add_method(d, tName, test_encode_ann) def install_exn_test(d, tName, bs, check_proc): def test_exn(self): try: self.D(bs) except: check_proc(self, sys.exc_info()[1]) return self.fail('did not fail as expected') add_method(d, tName, test_exn) class Embedded: def __init__(self, v): self.v = strip_annotations(v) @staticmethod def value(i): return i.v def __eq__(self, other): if other.__class__ is self.__class__: return self.v == other.v def __hash__(self): return hash(self.v) class CommonTestSuite(unittest.TestCase): import os with open(os.path.join(os.path.dirname(__file__), '../../../tests/samples.bin'), 'rb') as f: samples = Decoder(f.read(), include_annotations=True, decode_embedded=Embedded).next() TestCases = Record.makeConstructor('TestCases', 'cases') tests = TestCases._cases(samples.peel()).peel() for (tName0, t0) in tests.items(): tName = tName0.strip().name t = t0.peel() if t.key == Symbol('Test'): install_test(locals(), 'normal', tName, t[0].strip(), t[1]) elif t.key == Symbol('NondeterministicTest'): install_test(locals(), 'nondeterministic', tName, t[0].strip(), t[1]) elif t.key == Symbol('DecodeTest'): install_test(locals(), 'decode', tName, t[0].strip(), t[1]) elif t.key == Symbol('DecodeError'): def expected_err(self, e): self.assertIsInstance(e, DecodeError) self.assertNotIsInstance(e, ShortPacket) install_exn_test(locals(), tName, t[0].strip(), expected_err) elif t.key in [Symbol('DecodeShort'), Symbol('DecodeEOF')]: def expected_short(self, e): self.assertIsInstance(e, ShortPacket) install_exn_test(locals(), tName, t[0].strip(), expected_short) elif t.key in [Symbol('ParseError'), Symbol('ParseShort'), Symbol('ParseEOF')]: # Skipped for now, until we have an implementation of text syntax pass else: raise Exception('Unsupported test kind', t.key) def DS(self, bs): return decode(bs, decode_embedded=Embedded) def D(self, bs): return decode_with_annotations(bs, decode_embedded=Embedded) def E(self, v): return encode(v, encode_embedded=Embedded.value) class RecordTests(unittest.TestCase): def test_getters(self): T = Record.makeConstructor('t', 'x y z') T2 = Record.makeConstructor('t', 'x y z') U = Record.makeConstructor('u', 'x y z') t = T(1, 2, 3) self.assertTrue(T.isClassOf(t)) self.assertTrue(T2.isClassOf(t)) self.assertFalse(U.isClassOf(t)) self.assertEqual(T._x(t), 1) self.assertEqual(T2._y(t), 2) self.assertEqual(T._z(t), 3) with self.assertRaises(TypeError): U._x(t)