def test_wnblocking(self):
p = Pipe(timeout=1, bsize=10, wblocking=False)
self.assertTrue(p.readblocking())
self.assertFalse(p.writeblocking())
p.write(b"1234567890")
data = b"extra"
try:
# should not block
wresult = p.write(data)
self.assertTrue(wresult is None, repr(wresult))
except IOError as e:
self.fail("Timeout on non-blocking write; %s" % str(e))
# read all the data to empty the buffer
self.assertTrue(len(p.read(10)) == 10, "in our case, True!")
try:
# should block for 1 second and then timeout
rresult = p.read(1)
self.fail("blocked read returned %s" % repr(rresult))
except IOError as e:
self.assertTrue(io_timedout(e))
p.write(b"1234567890")
try:
# should not block!
p.flush()
self.fail("non-blocking flush returned with data")
except io.BlockingIOError:
pass
except IOError as e:
self.fail("non-blocking flush timed out; %s" % str(e))
def test_blocking(self):
p = Pipe(timeout=1, bsize=10)
self.assertTrue(p.readblocking())
self.assertTrue(p.writeblocking())
try:
# should block for 1 second and then timeout
rresult = p.read(1)
self.fail("blocked read returned %s" % repr(rresult))
except IOError as e:
self.assertTrue(io_timedout(e))
p.write(b"123")
# should not block!
rresult = p.read(5)
self.assertTrue(rresult == b"123")
# should not block, just!
p.write(bytearray(b"1234567890"))
try:
# should block for 1 second
wresult = p.write(b"extra")
self.fail("blocked write returned %s" % repr(wresult))
except IOError as e:
self.assertTrue(io_timedout(e))
try:
# should block for 1 second
logging.debug("flush waiting for 1s timeout...")
p.flush()
self.fail("blocked flush returned")
except IOError as e:
logging.debug("flush caught 1s timeout; %s", str(e))
def test_wnblocking(self):
p = Pipe(timeout=1, bsize=10, wblocking=False)
self.assertTrue(p.readblocking())
self.assertFalse(p.writeblocking())
p.write(b"1234567890")
data = b"extra"
try:
# should not block
wresult = p.write(data)
self.assertTrue(wresult is None, repr(wresult))
except IOError as e:
self.fail("Timeout on non-blocking write; %s" % str(e))
# read all the data to empty the buffer
self.assertTrue(len(p.read(10)) == 10, "in our case, True!")
try:
# should block for 1 second and then timeout
rresult = p.read(1)
self.fail("blocked read returned %s" % repr(rresult))
except IOError as e:
self.assertTrue(io_timedout(e))
p.write(b"1234567890")
try:
# should not block!
p.flush()
self.fail("non-blocking flush returned with data")
except io.BlockingIOError:
pass
except IOError as e:
self.fail("non-blocking flush timed out; %s" % str(e))
def test_blocking(self):
p = Pipe(timeout=1, bsize=10)
self.assertTrue(p.readblocking())
self.assertTrue(p.writeblocking())
try:
# should block for 1 second and then timeout
rresult = p.read(1)
self.fail("blocked read returned %s" % repr(rresult))
except IOError as e:
self.assertTrue(io_timedout(e))
p.write(b"123")
# should not block!
rresult = p.read(5)
self.assertTrue(rresult == b"123")
# should not block, just!
p.write(bytearray(b"1234567890"))
try:
# should block for 1 second
wresult = p.write(b"extra")
self.fail("blocked write returned %s" % repr(wresult))
except IOError as e:
self.assertTrue(io_timedout(e))
try:
# should block for 1 second
logging.debug("flush waiting for 1s timeout...")
p.flush()
self.fail("blocked flush returned")
except IOError as e:
logging.debug("flush caught 1s timeout; %s", str(e))
def test_simple(self):
p = Pipe()
# default constructor
self.assertTrue(isinstance(p, io.RawIOBase))
self.assertFalse(p.closed)
try:
p.fileno()
self.fail("fileno should raise IOError")
except IOError:
pass
self.assertFalse(p.isatty())
self.assertTrue(p.readable())
self.assertFalse(p.seekable())
self.assertTrue(p.writable())
# now for our custom attributes
self.assertTrue(p.readblocking())
self.assertTrue(p.writeblocking())
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE)
self.assertFalse(p.canread())
# now try a quick read and write test
data = b"The quick brown fox jumped over the lazy dog"
wlen = p.write(data)
self.assertTrue(wlen == len(data))
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE - len(data))
self.assertTrue(p.canread())
self.assertTrue(p.read(3) == data[:3])
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE - len(data) + 3)
self.assertTrue(p.canread())
# now deal with EOF conditions
p.write_eof()
try:
p.write(b"extra")
self.fail("write past EOF")
except IOError:
pass
try:
p.canwrite()
self.fail("canwrite called past EOF")
except IOError:
pass
self.assertTrue(p.canread(), "But can still read")
self.assertFalse(p.closed)
self.assertTrue(p.readall() == data[3:])
self.assertTrue(p.canread(), "Can still read")
self.assertTrue(p.read(3) == b'')
self.assertTrue(len(p.read()) == 0)
self.assertTrue(len(p.readall()) == 0)
p.close()
self.assertTrue(p.closed)
try:
p.canread()
self.fail("canread called on closed pipe")
except IOError:
pass
def test_simple(self):
p = Pipe()
# default constructor
self.assertTrue(isinstance(p, io.RawIOBase))
self.assertFalse(p.closed)
try:
p.fileno()
self.fail("fileno should raise IOError")
except IOError:
pass
self.assertFalse(p.isatty())
self.assertTrue(p.readable())
self.assertFalse(p.seekable())
self.assertTrue(p.writable())
# now for our custom attributes
self.assertTrue(p.readblocking())
self.assertTrue(p.writeblocking())
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE)
self.assertFalse(p.canread())
# now try a quick read and write test
data = b"The quick brown fox jumped over the lazy dog"
wlen = p.write(data)
self.assertTrue(wlen == len(data))
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE - len(data))
self.assertTrue(p.canread())
self.assertTrue(p.read(3) == data[:3])
self.assertTrue(p.canwrite() == io.DEFAULT_BUFFER_SIZE - len(data) + 3)
self.assertTrue(p.canread())
# now deal with EOF conditions
p.write_eof()
try:
p.write(b"extra")
self.fail("write past EOF")
except IOError:
pass
try:
p.canwrite()
self.fail("canwrite called past EOF")
except IOError:
pass
self.assertTrue(p.canread(), "But can still read")
self.assertFalse(p.closed)
self.assertTrue(p.readall() == data[3:])
self.assertTrue(p.canread(), "Can still read")
self.assertTrue(p.read(3) == b'')
self.assertTrue(len(p.read()) == 0)
self.assertTrue(len(p.readall()) == 0)
p.close()
self.assertTrue(p.closed)
try:
p.canread()
self.fail("canread called on closed pipe")
except IOError:
pass
def test_rnblocking(self):
p = Pipe(timeout=1, bsize=10, rblocking=False)
self.assertFalse(p.readblocking())
self.assertTrue(p.writeblocking())
try:
# should not block
rresult = p.read(1)
self.assertTrue(rresult is None)
except IOError as e:
self.fail("Timeout on non-blocking read; %s" % str(e))
# write should still block
p.write(b"1234567890")
try:
# should block for 1 second
wresult = p.write(b"extra")
self.fail("blocked write returned %s" % repr(wresult))
except IOError as e:
self.assertTrue(io_timedout(e))
def test_rnblocking(self):
p = Pipe(timeout=1, bsize=10, rblocking=False)
self.assertFalse(p.readblocking())
self.assertTrue(p.writeblocking())
try:
# should not block
rresult = p.read(1)
self.assertTrue(rresult is None)
except IOError as e:
self.fail("Timeout on non-blocking read; %s" % str(e))
# write should still block
p.write(b"1234567890")
try:
# should block for 1 second
wresult = p.write(b"extra")
self.fail("blocked write returned %s" % repr(wresult))
except IOError as e:
self.assertTrue(io_timedout(e))
