def test_goodsize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# default buffer is larger than src
b = BufferedStreamWrapper(src)
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertTrue(b.seekable())
self.assertTrue(b.length == len(data))
pos = b.tell()
self.assertTrue(pos == 0, "buffer starts at beginning of stream")
for i in range3(100):
# check seek and read
newpos = random.randint(0, len(data) + 1)
rlen = random.randint(0, len(data) + 1)
whence = random.choice((io.SEEK_SET, io.SEEK_CUR, io.SEEK_END))
if whence == io.SEEK_CUR:
adj = newpos - pos
elif whence == io.SEEK_END:
adj = newpos - len(data)
elif whence == io.SEEK_SET:
adj = newpos
b.seek(adj, whence)
self.assertTrue(b.tell() == newpos,
"Expected %i found %i" % (newpos, b.tell()))
pos = newpos
xlen = max(0, min(len(data) - pos, rlen))
rdata = b.read(rlen)
self.assertTrue(len(rdata) == xlen)
self.assertTrue(rdata == data[pos:pos + rlen])
pos += xlen
def test_blocked(self):
data = b"How long is a piece of string?"
src = Pipe(rblocking=False, name="test_blocked")
src.write(data)
# no eof, default buffer size will trigger block
b = BufferedStreamWrapper(src)
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
# but note that we can still peek on the data
# that we have buffered
self.assertTrue(b.peek(3) == data[0:3])
def test_unblocked(self):
data = b"How long is a piece of string?"
src = Pipe(rblocking=False, name="test_unblocked")
# write one byte at a time
for c in data:
src.write(byte_to_bstr(c))
src.write_eof()
# default buffer size outgrows pipe
b = BufferedStreamWrapper(src)
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertTrue(b.seekable())
self.assertTrue(b.length == len(data))
# the buffer also smooths access to the data
self.assertTrue(b.read(10) == data[0:10])
def test_boundarysize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer same length as src
b = BufferedStreamWrapper(src, len(data))
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
# not seekable as we can't peek past the end of src so it counts
# as an overflow.
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
# treat as readall
result = b.read()
self.assertTrue(result == data, repr(result))
def test_badsize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer smaller than src
b = BufferedStreamWrapper(src, len(data) // 2)
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
buff = []
while True:
rdata = b.read(7)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
# now read to align with buffer size
src.seek(0)
b = BufferedStreamWrapper(src, 10)
buff = []
while True:
rdata = b.read(5)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
# now read exactly buffer size
src.seek(0)
b = BufferedStreamWrapper(src, 10)
buff = []
while True:
rdata = b.read(10)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
def test_peek(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer smaller than src
b = BufferedStreamWrapper(src, 10)
self.assertTrue(b.peek(3) == data[0:3])
self.assertTrue(b.read(8) == data[0:8], "Data consumed by peek")
self.assertTrue(b.peek(3) == data[8:10], "Peek to end of buffer")
nbytes = 0
while nbytes < 3:
rdata = b.read(3 - nbytes)
self.assertTrue(rdata, "reading past buffer")
nbytes += len(rdata)
# now peek should always return empty
self.assertTrue(b.peek(1) == b"", "Can't peek past end of buffer")
def test_blocked(self):
data = b"How long is a piece of string?"
src = Pipe(rblocking=False, name="test_blocked")
src.write(data)
# no eof, default buffer size will trigger block
b = BufferedStreamWrapper(src)
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
# but note that we can still peek on the data
# that we have buffered
self.assertTrue(b.peek(3) == data[0:3])
def test_boundarysize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer same length as src
b = BufferedStreamWrapper(src, len(data))
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
# not seekable as we can't peek past the end of src so it counts
# as an overflow.
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
# treat as readall
result = b.read()
self.assertTrue(result == data, repr(result))
def test_unblocked(self):
data = b"How long is a piece of string?"
src = Pipe(rblocking=False, name="test_unblocked")
# write one byte at a time
for c in data:
src.write(byte_to_bstr(c))
src.write_eof()
# default buffer size outgrows pipe
b = BufferedStreamWrapper(src)
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertTrue(b.seekable())
self.assertTrue(b.length == len(data))
# the buffer also smooths access to the data
self.assertTrue(b.read(10) == data[0:10])
def test_peek(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer smaller than src
b = BufferedStreamWrapper(src, 10)
self.assertTrue(b.peek(3) == data[0:3])
self.assertTrue(b.read(8) == data[0:8], "Data consumed by peek")
self.assertTrue(b.peek(3) == data[8:10], "Peek to end of buffer")
nbytes = 0
while nbytes < 3:
rdata = b.read(3 - nbytes)
self.assertTrue(rdata, "reading past buffer")
nbytes += len(rdata)
# now peek should always return empty
self.assertTrue(b.peek(1) == b"", "Can't peek past end of buffer")
def test_badsize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# make buffer smaller than src
b = BufferedStreamWrapper(src, len(data) // 2)
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertFalse(b.seekable())
self.assertTrue(b.length is None)
buff = []
while True:
rdata = b.read(7)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
# now read to align with buffer size
src.seek(0)
b = BufferedStreamWrapper(src, 10)
buff = []
while True:
rdata = b.read(5)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
# now read exactly buffer size
src.seek(0)
b = BufferedStreamWrapper(src, 10)
buff = []
while True:
rdata = b.read(10)
if rdata == b'':
break
else:
buff.append(rdata)
result = b''.join(buff)
self.assertTrue(result == data, repr(result))
def test_goodsize(self):
data = b"How long is a piece of string?"
src = io.BytesIO(data)
# default buffer is larger than src
b = BufferedStreamWrapper(src)
self.assertTrue(isinstance(b, io.RawIOBase))
self.assertTrue(b.readable())
self.assertFalse(b.writable())
self.assertTrue(b.seekable())
self.assertTrue(b.length == len(data))
pos = b.tell()
self.assertTrue(pos == 0, "buffer starts at beginning of stream")
for i in range3(100):
# check seek and read
newpos = random.randint(0, len(data) + 1)
rlen = random.randint(0, len(data) + 1)
whence = random.choice((io.SEEK_SET, io.SEEK_CUR, io.SEEK_END))
if whence == io.SEEK_CUR:
adj = newpos - pos
elif whence == io.SEEK_END:
adj = newpos - len(data)
elif whence == io.SEEK_SET:
adj = newpos
b.seek(adj, whence)
self.assertTrue(b.tell() == newpos,
"Expected %i found %i" % (newpos, b.tell()))
pos = newpos
xlen = max(0, min(len(data) - pos, rlen))
rdata = b.read(rlen)
self.assertTrue(len(rdata) == xlen)
self.assertTrue(rdata == data[pos:pos + rlen])
pos += xlen
