Lines Matching refs:buffer
337 buffer = bytearray(b" world\n\n\n")
338 self.assertEqual(f.write(buffer), 9)
339 buffer[:] = b"*" * 9 # Overwrite our copy of the data
762 self.assertEqual(f.buffer.raw.closefd, True)
764 self.assertEqual(file.buffer.raw.closefd, False)
930 buffer = byteslike(5)
931 self.assertEqual(getattr(stream, method)(buffer), 5)
932 self.assertEqual(bytes(buffer), b"12345")
984 # (test method, total data available, read buffer size, expected
990 ("readinto", 10, 0, 0), # Empty buffer
995 ("readinto1", 10, 0, 0), # Empty buffer
1002 buffer = bytearray((UNUSED_BYTE,) * request)
1004 self.assertEqual(method(buffer), result)
1005 self.assertEqual(len(buffer), request)
1006 self.assertSequenceEqual(buffer[:result], range(result))
1008 self.assertSequenceEqual(buffer[result:], unused)
1481 # Intra-buffer read then buffer-flushing read
1665 # Write to the buffered IO but don't overflow the buffer.
1670 buffer = bytearray(b"def")
1671 bufio.write(buffer)
1672 buffer[:] = b"***" # Overwrite our copy of the data
1809 # Truncate implicitly flushes the buffer.
1821 # writes longer than the buffer size.
1825 # Fill with some buffer
1855 # writing the buffer to the raw streams. This is in addition
2054 buffer = bytearray(b"def")
2055 pair.write(buffer)
2056 buffer[:] = b"***" # Overwrite our copy of the data
2248 # flush() resets the read buffer
2265 # This relies on the fact that the buffer can contain the whole
2320 # Issue #6629: writing after the buffer was filled by readahead should
2331 # If the write size was smaller than the buffer size, flush() and
2343 # Fill the buffer
2348 # the buffer.
2368 self.assertEqual(bufio.read(2), b"AA") # the read buffer gets filled
2370 self.assertEqual(bufio.write(b"BB"), 2) # the write buffer increases
2490 self.buffer = bytearray()
2494 return bytes(self.buffer), i*100 + o
2497 buffer, io = state
2498 self.buffer = bytearray(buffer)
2507 if self.buffer:
2510 self.buffer.append(b)
2512 self.buffer.append(b)
2513 if len(self.buffer) == self.i:
2515 if final and self.buffer: # EOF terminates the last word
2521 if self.buffer[0] == ord('i'):
2522 self.i = min(99, int(self.buffer[1:] or 0)) # set input length
2523 elif self.buffer[0] == ord('o'):
2524 self.o = min(99, int(self.buffer[1:] or 0)) # set output length
2526 output = self.buffer.decode('ascii')
2532 self.buffer = bytearray()
2676 t.buffer.detach()
2817 # Try a range of buffer sizes to test the case where \r is the last
3236 buffer = self.BytesIO(self.testdata)
3237 txt = self.TextIOWrapper(buffer, encoding="ascii")
3239 self.assertEqual(buffer.seekable(), txt.seekable())
3315 closed[:] = [txt.closed, txt.buffer.closed]
3320 self.assertTrue(txt.buffer.closed)
3327 buffer = self.BytesIO(self.testdata)
3332 buffer.close = bad_close
3333 txt = self.TextIOWrapper(buffer, encoding="ascii")
3343 buffer.close = lambda: None
3348 buffer = self.BytesIO(self.testdata)
3353 buffer.close = bad_close
3354 txt = self.TextIOWrapper(buffer, encoding="ascii")
3364 buffer.close = lambda: None
3383 txt.buffer = buf
3423 # write to the buffered io but don't overflow the buffer
3427 # buffer.flush is not called with write_through=True
3429 # buffer.write *is* called with write_through=True
3434 textio.write(text * 10) # total content is larger than bufio buffer
3784 # bpo-43260: TextIOWrapper's internal buffer should not store
3973 self.assertEqual(f.buffer.mode, "rb+") # Does it really matter?
3974 self.assertEqual(f.buffer.raw.mode, "rb+")
4182 # to play with buffer sizes. For instance, if we choose a
4183 # buffer size less than or equal to _PIPE_BUF (4096 on Linux)
4184 # then we will never get a partial write of the buffer.
4238 # there used to be a buffer overflow in the parser for rawmode
4477 # buffer, and block again.
4517 # Make sure the buffer doesn't fill up and block further writes
4575 # A quantity that exceeds the buffer size of an anonymous pipe's
4610 # - first raw write() is partial (because of the limited pipe buffer
4630 # buffer, and could block (in case of failure).