Python Unpacker Examples

Example #1

File: test_read_size.py Project: 5i7788/pandas

def test_correct_type_nested_array():
    unpacker = Unpacker()
    unpacker.feed(packb({'a': ['b', 'c', 'd']}))
    try:
        unpacker.read_array_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #2

File: test_read_size.py Project: 5i7788/pandas

def test_incorrect_type_nested_map():
    unpacker = Unpacker()
    unpacker.feed(packb([{'a': 'b'}]))
    try:
        unpacker.read_map_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #3

File: test_read_size.py Project: 5i7788/pandas

def test_incorrect_type_array():
    unpacker = Unpacker()
    unpacker.feed(packb(1))
    try:
        unpacker.read_array_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #4

def test_write_bytes_multi_buffer():
    long_val = (5) * 100
    expected = packb(long_val)
    unpacker = Unpacker(io.BytesIO(expected), read_size=3, max_buffer_size=3)

    f = io.BytesIO()
    unpacked = unpacker.unpack(f.write)
    assert unpacked == long_val
    assert f.getvalue() == expected

Example #5

File: test_unpack.py Project: BRGM/Pic-EAU

 def test_unpack_array_header_from_file(self):
     f = BytesIO(packb([1, 2, 3, 4]))
     unpacker = Unpacker(f)
     assert unpacker.read_array_header() == 4
     assert unpacker.unpack() == 1
     assert unpacker.unpack() == 2
     assert unpacker.unpack() == 3
     assert unpacker.unpack() == 4
     self.assertRaises(OutOfData, unpacker.unpack)

Example #6

File: test_unpack.py Project: BrenBarn/pandas

 def test_unpack_array_header_from_file(self):
     f = BytesIO(packb([1,2,3,4]))
     unpacker = Unpacker(f)
     assert unpacker.read_array_header() == 4
     assert unpacker.unpack() == 1
     assert unpacker.unpack() == 2
     assert unpacker.unpack() == 3
     assert unpacker.unpack() == 4
     self.assertRaises(OutOfData, unpacker.unpack)

Example #7

    def testArraySize(self, sizes=[0, 5, 50, 1000]):
        bio = compat.BytesIO()
        packer = Packer()
        for size in sizes:
            bio.write(packer.pack_array_header(size))
            for i in range(size):
                bio.write(packer.pack(i))

        bio.seek(0)
        unpacker = Unpacker(bio, use_list=1)
        for size in sizes:
            assert unpacker.unpack() == list(range(size))

Example #8

File: test_pack.py Project: 8ballbb/ProjectRothar

    def testArraySize(self, sizes=[0, 5, 50, 1000]):
        bio = compat.BytesIO()
        packer = Packer()
        for size in sizes:
            bio.write(packer.pack_array_header(size))
            for i in range(size):
                bio.write(packer.pack(i))

        bio.seek(0)
        unpacker = Unpacker(bio, use_list=1)
        for size in sizes:
            assert unpacker.unpack() == list(range(size))

Example #9

File: test_pack.py Project: 8ballbb/ProjectRothar

    def testMapSize(self, sizes=[0, 5, 50, 1000]):
        bio = compat.BytesIO()
        packer = Packer()
        for size in sizes:
            bio.write(packer.pack_map_header(size))
            for i in range(size):
                bio.write(packer.pack(i))  # key
                bio.write(packer.pack(i * 2))  # value

        bio.seek(0)
        unpacker = Unpacker(bio)
        for size in sizes:
            assert unpacker.unpack() == dict((i, i * 2) for i in range(size))

Example #10

    def testMapSize(self, sizes=[0, 5, 50, 1000]):
        bio = compat.BytesIO()
        packer = Packer()
        for size in sizes:
            bio.write(packer.pack_map_header(size))
            for i in range(size):
                bio.write(packer.pack(i))  # key
                bio.write(packer.pack(i * 2))  # value

        bio.seek(0)
        unpacker = Unpacker(bio)
        for size in sizes:
            assert unpacker.unpack() == dict((i, i * 2) for i in range(size))

Example #11

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

    def test_readbytes(self):
        unpacker = Unpacker(read_size=3)
        unpacker.feed(b'foobar')
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.read_bytes(3) == b'oob'
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')

        # Test buffer refill
        unpacker = Unpacker(compat.BytesIO(b'foobar'), read_size=3)
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.read_bytes(3) == b'oob'
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')

Example #12

File: test_pack.py Project: 8ballbb/ProjectRothar

    def test_manualreset(self, sizes=[0, 5, 50, 1000]):
        packer = Packer(autoreset=False)
        for size in sizes:
            packer.pack_array_header(size)
            for i in range(size):
                packer.pack(i)

        bio = compat.BytesIO(packer.bytes())
        unpacker = Unpacker(bio, use_list=1)
        for size in sizes:
            assert unpacker.unpack() == list(range(size))

        packer.reset()
        assert packer.bytes() == b''

Example #13

File: test_sequnpack.py Project: B-Rich/pandas

    def test_readbytes(self):
        unpacker = Unpacker(read_size=3)
        unpacker.feed(b"foobar")
        assert unpacker.unpack() == ord(b"f")
        assert unpacker.read_bytes(3) == b"oob"
        assert unpacker.unpack() == ord(b"a")
        assert unpacker.unpack() == ord(b"r")

        # Test buffer refill
        unpacker = Unpacker(compat.BytesIO(b"foobar"), read_size=3)
        assert unpacker.unpack() == ord(b"f")
        assert unpacker.read_bytes(3) == b"oob"
        assert unpacker.unpack() == ord(b"a")
        assert unpacker.unpack() == ord(b"r")

Example #14

    def test_manualreset(self, sizes=[0, 5, 50, 1000]):
        packer = Packer(autoreset=False)
        for size in sizes:
            packer.pack_array_header(size)
            for i in range(size):
                packer.pack(i)

        bio = compat.BytesIO(packer.bytes())
        unpacker = Unpacker(bio, use_list=1)
        for size in sizes:
            assert unpacker.unpack() == list(range(size))

        packer.reset()
        assert packer.bytes() == b''

Example #15

File: test_limits.py Project: LiuFang816/SALSTM_py_data

    def test_max_ext_len(self):
        d = ExtType(42, b"abc")
        packed = packb(d)

        unpacker = Unpacker(max_ext_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_ext_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #16

File: test_limits.py Project: LiuFang816/SALSTM_py_data

    def test_max_map_len(self):
        d = {1: 2, 3: 4, 5: 6}
        packed = packb(d)

        unpacker = Unpacker(max_map_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_map_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #17

File: test_limits.py Project: LiuFang816/SALSTM_py_data

    def test_max_array_len(self):
        d = [1, 2, 3]
        packed = packb(d)

        unpacker = Unpacker(max_array_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_array_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #18

File: test_limits.py Project: LiuFang816/SALSTM_py_data

    def test_max_bin_len(self):
        d = b'x' * 3
        packed = packb(d, use_bin_type=True)

        unpacker = Unpacker(max_bin_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_bin_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #19

File: test_limits.py Project: LiuFang816/SALSTM_py_data

    def test_max_str_len(self):
        d = 'x' * 3
        packed = packb(d)

        unpacker = Unpacker(max_str_len=3, encoding='utf-8')
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_str_len=2, encoding='utf-8')
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #20

def test_read_array_header():
    unpacker = Unpacker()
    unpacker.feed(packb(['a', 'b', 'c']))
    assert unpacker.read_array_header() == 3
    assert unpacker.unpack() == b'a'
    assert unpacker.unpack() == b'b'
    assert unpacker.unpack() == b'c'
    try:
        unpacker.unpack()
        assert 0, 'should raise exception'
    except OutOfData:
        assert 1, 'okay'

Example #21

File: test_sequnpack.py Project: BRGM/Pic-EAU

 def test_issue124(self):
     unpacker = Unpacker()
     unpacker.feed(b'\xa1?\xa1!')
     assert tuple(unpacker) == (b'?', b'!')
     assert tuple(unpacker) == ()
     unpacker.feed(b"\xa1?\xa1")
     assert tuple(unpacker) == (b'?', )
     assert tuple(unpacker) == ()
     unpacker.feed(b"!")
     assert tuple(unpacker) == (b'!', )
     assert tuple(unpacker) == ()

Example #22

File: test_sequnpack.py Project: ubdsgroup/wikienergy

 def test_maxbuffersize(self):
     self.assertRaises(ValueError, Unpacker, read_size=5, max_buffer_size=3)
     unpacker = Unpacker(read_size=3, max_buffer_size=3, use_list=1)
     unpacker.feed(b'fo')
     self.assertRaises(BufferFull, unpacker.feed, b'ob')
     unpacker.feed(b'o')
     assert ord('f') == next(unpacker)
     unpacker.feed(b'b')
     assert ord('o') == next(unpacker)
     assert ord('o') == next(unpacker)
     assert ord('b') == next(unpacker)

Example #23

def test_read_map_header():
    unpacker = Unpacker()
    unpacker.feed(packb({'a': 'A'}))
    assert unpacker.read_map_header() == 1
    assert unpacker.unpack() == B'a'
    assert unpacker.unpack() == B'A'
    try:
        unpacker.unpack()
        assert 0, 'should raise exception'
    except OutOfData:
        assert 1, 'okay'

Example #24

File: test_read_size.py Project: 5i7788/pandas

def test_read_array_header():
    unpacker = Unpacker()
    unpacker.feed(packb(['a', 'b', 'c']))
    assert unpacker.read_array_header() == 3
    assert unpacker.unpack() == b'a'
    assert unpacker.unpack() == b'b'
    assert unpacker.unpack() == b'c'
    try:
        unpacker.unpack()
        assert 0, 'should raise exception'
    except OutOfData:
        assert 1, 'okay'

Example #25

 def testPackUnicode(self):
     test_data = [u(""), u("abcd"), [u("defgh")], u("Русский текст"), ]
     for td in test_data:
         re = unpackb(
             packb(td, encoding='utf-8'), use_list=1, encoding='utf-8')
         assert re == td
         packer = Packer(encoding='utf-8')
         data = packer.pack(td)
         re = Unpacker(
             compat.BytesIO(data), encoding='utf-8', use_list=1).unpack()
         assert re == td

Example #26

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

 def test_maxbuffersize(self):
     self.assertRaises(ValueError, Unpacker, read_size=5, max_buffer_size=3)
     unpacker = Unpacker(read_size=3, max_buffer_size=3, use_list=1)
     unpacker.feed(b'fo')
     self.assertRaises(BufferFull, unpacker.feed, b'ob')
     unpacker.feed(b'o')
     assert ord('f') == next(unpacker)
     unpacker.feed(b'b')
     assert ord('o') == next(unpacker)
     assert ord('o') == next(unpacker)
     assert ord('b') == next(unpacker)

Example #27

File: test_read_size.py Project: 5i7788/pandas

def test_read_map_header():
    unpacker = Unpacker()
    unpacker.feed(packb({'a': 'A'}))
    assert unpacker.read_map_header() == 1
    assert unpacker.unpack() == B'a'
    assert unpacker.unpack() == B'A'
    try:
        unpacker.unpack()
        assert 0, 'should raise exception'
    except OutOfData:
        assert 1, 'okay'

Example #28

File: test_limits.py Project: cgrin/pandas

    def test_max_map_len(self):
        d = {1: 2, 3: 4, 5: 6}
        packed = packb(d)

        unpacker = Unpacker(max_map_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_map_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #29

File: test_limits.py Project: cgrin/pandas

    def test_max_array_len(self):
        d = [1, 2, 3]
        packed = packb(d)

        unpacker = Unpacker(max_array_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_array_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #30

File: test_limits.py Project: cgrin/pandas

    def test_max_str_len(self):
        d = 'x' * 3
        packed = packb(d)

        unpacker = Unpacker(max_str_len=3, encoding='utf-8')
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_str_len=2, encoding='utf-8')
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #31

File: test_limits.py Project: cgrin/pandas

    def test_max_bin_len(self):
        d = b'x' * 3
        packed = packb(d, use_bin_type=True)

        unpacker = Unpacker(max_bin_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_bin_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #32

File: test_sequnpack.py Project: B-Rich/pandas

 def test_maxbuffersize(self):
     self.assertRaises(ValueError, Unpacker, read_size=5, max_buffer_size=3)
     unpacker = Unpacker(read_size=3, max_buffer_size=3, use_list=1)
     unpacker.feed(b"fo")
     self.assertRaises(BufferFull, unpacker.feed, b"ob")
     unpacker.feed(b"o")
     assert ord("f") == next(unpacker)
     unpacker.feed(b"b")
     assert ord("o") == next(unpacker)
     assert ord("o") == next(unpacker)
     assert ord("b") == next(unpacker)

Example #33

File: test_limits.py Project: cgrin/pandas

    def test_max_ext_len(self):
        d = ExtType(42, b"abc")
        packed = packb(d)

        unpacker = Unpacker(max_ext_len=3)
        unpacker.feed(packed)
        assert unpacker.unpack() == d

        unpacker = Unpacker(max_ext_len=2)
        unpacker.feed(packed)
        self.assertRaises(ValueError, unpacker.unpack)

Example #34

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

 def test_issue124(self):
     unpacker = Unpacker()
     unpacker.feed(b'\xa1?\xa1!')
     assert tuple(unpacker) == (b'?', b'!')
     assert tuple(unpacker) == ()
     unpacker.feed(b"\xa1?\xa1")
     assert tuple(unpacker) == (b'?', )
     assert tuple(unpacker) == ()
     unpacker.feed(b"!")
     assert tuple(unpacker) == (b'!', )
     assert tuple(unpacker) == ()

Example #35

def test_incorrect_type_nested_map():
    unpacker = Unpacker()
    unpacker.feed(packb([{'a': 'b'}]))
    try:
        unpacker.read_map_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #36

def test_incorrect_type_array():
    unpacker = Unpacker()
    unpacker.feed(packb(1))
    try:
        unpacker.read_array_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #37

def test_correct_type_nested_array():
    unpacker = Unpacker()
    unpacker.feed(packb({'a': ['b', 'c', 'd']}))
    try:
        unpacker.read_array_header()
        assert 0, 'should raise exception'
    except UnexpectedTypeException:
        assert 1, 'okay'

Example #38

File: test_sequnpack.py Project: ubdsgroup/wikienergy

    def test_foobar(self):
        unpacker = Unpacker(read_size=3, use_list=1)
        unpacker.feed(b'foobar')
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.unpack() == ord(b'o')
        assert unpacker.unpack() == ord(b'o')
        assert unpacker.unpack() == ord(b'b')
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')
        self.assertRaises(OutOfData, unpacker.unpack)

        unpacker.feed(b'foo')
        unpacker.feed(b'bar')

        k = 0
        for o, e in zip(unpacker, 'foobarbaz'):
            assert o == ord(e)
            k += 1
        assert k == len(b'foobar')

Example #39

def test_write_bytes():
    unpacker = Unpacker()
    unpacker.feed(b'abc')
    f = io.BytesIO()
    assert unpacker.unpack(f.write) == ord('a')
    assert f.getvalue() == b'a'
    f = io.BytesIO()
    assert unpacker.skip(f.write) is None
    assert f.getvalue() == b'b'
    f = io.BytesIO()
    assert unpacker.skip() is None
    assert f.getvalue() == b''

Example #40

File: test_unpack.py Project: BrenBarn/pandas

    def test_unpacker_hook_refcnt(self):
        if not hasattr(sys, 'getrefcount'):
            raise nose.SkipTest('no sys.getrefcount()')
        result = []

        def hook(x):
            result.append(x)
            return x

        basecnt = sys.getrefcount(hook)

        up = Unpacker(object_hook=hook, list_hook=hook)

        assert sys.getrefcount(hook) >= basecnt + 2

        up.feed(packb([{}]))
        up.feed(packb([{}]))
        assert up.unpack() == [{}]
        assert up.unpack() == [{}]
        assert result == [{}, [{}], {}, [{}]]

        del up

        assert sys.getrefcount(hook) == basecnt

Example #41

File: test_unpack.py Project: BRGM/Pic-EAU

    def test_unpacker_hook_refcnt(self):
        if not hasattr(sys, 'getrefcount'):
            raise nose.SkipTest('no sys.getrefcount()')
        result = []

        def hook(x):
            result.append(x)
            return x

        basecnt = sys.getrefcount(hook)

        up = Unpacker(object_hook=hook, list_hook=hook)

        assert sys.getrefcount(hook) >= basecnt + 2

        up.feed(packb([{}]))
        up.feed(packb([{}]))
        assert up.unpack() == [{}]
        assert up.unpack() == [{}]
        assert result == [{}, [{}], {}, [{}]]

        del up

        assert sys.getrefcount(hook) == basecnt

Example #42

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

    def test_foobar(self):
        unpacker = Unpacker(read_size=3, use_list=1)
        unpacker.feed(b'foobar')
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.unpack() == ord(b'o')
        assert unpacker.unpack() == ord(b'o')
        assert unpacker.unpack() == ord(b'b')
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')
        self.assertRaises(OutOfData, unpacker.unpack)

        unpacker.feed(b'foo')
        unpacker.feed(b'bar')

        k = 0
        for o, e in zip(unpacker, 'foobarbaz'):
            assert o == ord(e)
            k += 1
        assert k == len(b'foobar')

Example #43

File: test_sequnpack.py Project: B-Rich/pandas

    def test_foobar(self):
        unpacker = Unpacker(read_size=3, use_list=1)
        unpacker.feed(b"foobar")
        assert unpacker.unpack() == ord(b"f")
        assert unpacker.unpack() == ord(b"o")
        assert unpacker.unpack() == ord(b"o")
        assert unpacker.unpack() == ord(b"b")
        assert unpacker.unpack() == ord(b"a")
        assert unpacker.unpack() == ord(b"r")
        self.assertRaises(OutOfData, unpacker.unpack)

        unpacker.feed(b"foo")
        unpacker.feed(b"bar")

        k = 0
        for o, e in zip(unpacker, "foobarbaz"):
            assert o == ord(e)
            k += 1
        assert k == len(b"foobar")

Example #44

File: test_sequnpack.py Project: B-Rich/pandas

 def test_foobar_skip(self):
     unpacker = Unpacker(read_size=3, use_list=1)
     unpacker.feed(b"foobar")
     assert unpacker.unpack() == ord(b"f")
     unpacker.skip()
     assert unpacker.unpack() == ord(b"o")
     unpacker.skip()
     assert unpacker.unpack() == ord(b"a")
     unpacker.skip()
     self.assertRaises(OutOfData, unpacker.unpack)

Example #45

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

 def test_foobar_skip(self):
     unpacker = Unpacker(read_size=3, use_list=1)
     unpacker.feed(b'foobar')
     assert unpacker.unpack() == ord(b'f')
     unpacker.skip()
     assert unpacker.unpack() == ord(b'o')
     unpacker.skip()
     assert unpacker.unpack() == ord(b'a')
     unpacker.skip()
     self.assertRaises(OutOfData, unpacker.unpack)

Example #46

File: test_sequnpack.py Project: ubdsgroup/wikienergy

 def test_partialdata(self):
     unpacker = Unpacker()
     unpacker.feed(b'\xa5')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'h')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'a')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'l')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'l')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'o')
     assert next(iter(unpacker)) == b'hallo'

Example #47

File: test_sequnpack.py Project: 8ballbb/ProjectRothar

 def test_partialdata(self):
     unpacker = Unpacker()
     unpacker.feed(b'\xa5')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'h')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'a')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'l')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'l')
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b'o')
     assert next(iter(unpacker)) == b'hallo'

Example #48

File: test_sequnpack.py Project: ubdsgroup/wikienergy

 def test_foobar_skip(self):
     unpacker = Unpacker(read_size=3, use_list=1)
     unpacker.feed(b'foobar')
     assert unpacker.unpack() == ord(b'f')
     unpacker.skip()
     assert unpacker.unpack() == ord(b'o')
     unpacker.skip()
     assert unpacker.unpack() == ord(b'a')
     unpacker.skip()
     self.assertRaises(OutOfData, unpacker.unpack)

Example #49

File: test_sequnpack.py Project: ubdsgroup/wikienergy

    def test_readbytes(self):
        unpacker = Unpacker(read_size=3)
        unpacker.feed(b'foobar')
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.read_bytes(3) == b'oob'
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')

        # Test buffer refill
        unpacker = Unpacker(compat.BytesIO(b'foobar'), read_size=3)
        assert unpacker.unpack() == ord(b'f')
        assert unpacker.read_bytes(3) == b'oob'
        assert unpacker.unpack() == ord(b'a')
        assert unpacker.unpack() == ord(b'r')

Example #50

File: test_sequnpack.py Project: B-Rich/pandas

 def test_partialdata(self):
     unpacker = Unpacker()
     unpacker.feed(b"\xa5")
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b"h")
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b"a")
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b"l")
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b"l")
     self.assertRaises(StopIteration, next, iter(unpacker))
     unpacker.feed(b"o")
     assert next(iter(unpacker)) == b"hallo"