Here are the examples of the python api twisted.python.compat.iterbytes taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
106 Examples
3
Source : helper.py
with MIT License
from autofelix
with MIT License
from autofelix
def write(self, data):
"""
Add the given printable bytes to the terminal.
Line feeds in L{bytes} will be replaced with carriage return / line
feed pairs.
"""
for b in iterbytes(data.replace(b'\n', b'\r\n')):
self.insertAtCursor(b)
def _currentFormattingState(self):
3
Source : recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def handle_TAB(self):
n = self.TABSTOP - (len(self.lineBuffer) % self.TABSTOP)
self.terminal.cursorForward(n)
self.lineBufferIndex += n
self.lineBuffer.extend(iterbytes(b' ' * n))
def handle_LEFT(self):
3
Source : recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def _deliverBuffer(self, buf):
if buf:
for ch in iterbytes(buf[:-1]):
self.characterReceived(ch, True)
self.characterReceived(buf[-1:], False)
def handle_UP(self):
3
Source : test_insults.py
with MIT License
from autofelix
with MIT License
from autofelix
def verifyResults(self, transport, proto, parser):
ByteGroupingsMixin.verifyResults(self, transport, proto, parser)
for char in iterbytes(b'abc123ABC!@#'):
result = self.assertCall(occurrences(proto).pop(0), "keystrokeReceived", (char, None))
self.assertEqual(occurrences(result), [])
for char in iterbytes(b'abc123'):
result = self.assertCall(occurrences(proto).pop(0), "keystrokeReceived", (char, parser.ALT))
self.assertEqual(occurrences(result), [])
occs = occurrences(proto)
self.assertFalse(occs, "%r should have been []" % (occs,))
class ServerFunctionKeysTests(ByteGroupingsMixin, unittest.TestCase):
3
Source : test_insults.py
with MIT License
from autofelix
with MIT License
from autofelix
def testSimpleCardinals(self):
self.parser.dataReceived(
b''.join(
[b''.join([b'\x1b[' + n + ch
for n in (b'', intToBytes(2), intToBytes(20), intToBytes(200))]
) for ch in iterbytes(b'BACD')
]))
occs = occurrences(self.proto)
for meth in ("Down", "Up", "Forward", "Backward"):
for count in (1, 2, 20, 200):
result = self.assertCall(occs.pop(0), "cursor" + meth, (count,))
self.assertFalse(occurrences(result))
self.assertFalse(occs)
def testScrollRegion(self):
3
Source : test_insults.py
with MIT License
from autofelix
with MIT License
from autofelix
def testCharacterSet(self):
self.parser.dataReceived(
b''.join(
[b''.join([b'\x1b' + g + n for n in iterbytes(b'AB012')])
for g in iterbytes(b'()')
]))
occs = occurrences(self.proto)
for which in (G0, G1):
for charset in (CS_UK, CS_US, CS_DRAWING, CS_ALTERNATE, CS_ALTERNATE_SPECIAL):
result = self.assertCall(occs.pop(0), "selectCharacterSet", (charset, which))
self.assertFalse(occurrences(result))
self.assertFalse(occs)
def testShifting(self):
3
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_home(self):
"""
When L{HistoricRecvLine} receives a HOME keystroke it moves the
cursor to the beginning of the current line buffer.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'hello, world'):
kR(ch)
self.assertEqual(self.p.currentLineBuffer(), (b'hello, world', b''))
kR(self.pt.HOME)
self.assertEqual(self.p.currentLineBuffer(), (b'', b'hello, world'))
def test_end(self):
3
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_end(self):
"""
When L{HistoricRecvLine} receives an END keystroke it moves the cursor
to the end of the current line buffer.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'hello, world'):
kR(ch)
self.assertEqual(self.p.currentLineBuffer(), (b'hello, world', b''))
kR(self.pt.HOME)
kR(self.pt.END)
self.assertEqual(self.p.currentLineBuffer(), (b'hello, world', b''))
def test_backspace(self):
3
Source : test_telnet.py
with MIT License
from autofelix
with MIT License
from autofelix
def testSubnegotiation(self):
# Send a subnegotiation command and make sure it gets
# parsed and that the correct method is called.
h = self.p.protocol
cmd = telnet.IAC + telnet.SB + b'\x12hello world' + telnet.IAC + telnet.SE
L = [b"These are some bytes but soon" + cmd,
b"there will be some more"]
for b in L:
self.p.dataReceived(b)
self.assertEqual(h.data, b''.join(L).replace(cmd, b''))
self.assertEqual(h.subcmd, list(iterbytes(b"hello world")))
def testSubnegotiationWithEmbeddedSE(self):
3
Source : smtp.py
with MIT License
from autofelix
with MIT License
from autofelix
def xtext_encode(s, errors=None):
r = []
for ch in iterbytes(s):
o = ord(ch)
if ch == '+' or ch == '=' or o < 33 or o > 126:
r.append(networkString('+%02X' % (o,)))
else:
r.append(_bytesChr(o))
return (b''.join(r), len(s))
def xtext_decode(s, errors=None):
3
Source : _v2parser.py
with MIT License
from autofelix
with MIT License
from autofelix
def _bytesToIPv4(bytestring):
"""
Convert packed 32-bit IPv4 address bytes into a dotted-quad ASCII bytes
representation of that address.
@param bytestring: 4 octets representing an IPv4 address.
@type bytestring: L{bytes}
@return: a dotted-quad notation IPv4 address.
@rtype: L{bytes}
"""
return b'.'.join(
('%i' % (ord(b),)).encode('ascii')
for b in compat.iterbytes(bytestring)
)
@staticmethod
3
Source : test_basic.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_buffer(self):
"""
Test buffering over line protocol: data received should match buffer.
"""
t = proto_helpers.StringTransport()
a = LineOnlyTester()
a.makeConnection(t)
for c in iterbytes(self.buffer):
a.dataReceived(c)
self.assertEqual(a.received, self.buffer.split(b'\n')[:-1])
def test_greaterThanMaximumLineLength(self):
3
Source : test_basic.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_illegal(self):
"""
Assert that illegal strings cause the transport to be closed.
"""
for s in self.illegalStrings:
r = self.getProtocol()
for c in iterbytes(s):
r.dataReceived(c)
self.assertTrue(r.transport.disconnecting)
class NetstringReceiverTests(unittest.SynchronousTestCase, LPTestCaseMixin):
3
Source : test_basic.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_receive(self):
"""
Test receiving data find the same data send.
"""
r = self.getProtocol()
for s in self.strings:
for c in iterbytes(struct.pack(r.structFormat,len(s)) + s):
r.dataReceived(c)
self.assertEqual(r.received, self.strings)
def test_partial(self):
3
Source : test_basic.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_partial(self):
"""
Send partial data, nothing should be definitely received.
"""
for s in self.partialStrings:
r = self.getProtocol()
for c in iterbytes(s):
r.dataReceived(c)
self.assertEqual(r.received, [])
def test_send(self):
3
Source : test_tls.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_writeSequence(self):
"""
Bytes written to L{TLSMemoryBIOProtocol} with C{writeSequence} are
received by the protocol on the other side of the connection.
"""
data = b"some bytes"
class SimpleSendingProtocol(Protocol):
def connectionMade(self):
self.transport.writeSequence(list(iterbytes(data)))
return self.writeBeforeHandshakeTest(SimpleSendingProtocol, data)
def test_writeAfterLoseConnection(self):
3
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_buffer(self):
"""
Send requests over a channel and check responses match what is expected.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DummyHTTPHandlerProxy
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all one"))
value = b.value()
self.assertResponseEquals(value, self.expected_response)
def test_requestBodyTimeout(self):
3
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_noPipeliningApi(self):
"""
Test that a L{http.Request} subclass with no queued kwarg works as
expected.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DummyHTTPHandlerProxy
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all done"))
value = b.value()
self.assertResponseEquals(value, self.expected_response)
def test_noPipelining(self):
3
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def _negotiatedProtocolForTransportInstance(self, t):
"""
Run a request using the specific instance of a transport. Returns the
negotiated protocol string.
"""
a = http._genericHTTPChannelProtocolFactory(b'')
a.requestFactory = DummyHTTPHandlerProxy
a.makeConnection(t)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all done"))
return a._negotiatedProtocol
def test_protocolUnspecified(self):
3
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_short(self):
"""
L{_ChunkedTransferDecoder.dataReceived} decodes chunks broken up and
delivered in multiple calls.
"""
L = []
finished = []
p = http._ChunkedTransferDecoder(L.append, finished.append)
for s in iterbytes(b'3\r\nabc\r\n5\r\n12345\r\n0\r\n\r\n'):
p.dataReceived(s)
self.assertEqual(L, [b'a', b'b', b'c', b'1', b'2', b'3', b'4', b'5'])
self.assertEqual(finished, [b''])
def test_newlines(self):
3
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def testConcatenatedChunks(self):
chunked = b''.join([b''.join(http.toChunk(t)) for t in self.strings])
result = []
buffer = b""
for c in iterbytes(chunked):
buffer = buffer + c
try:
data, buffer = http.fromChunk(buffer)
result.append(data)
except ValueError:
pass
self.assertEqual(result, self.strings)
def test_chunkedResponses(self):
3
Source : test_basic.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def test_buffer(self):
"""
Test buffering over line protocol: data received should match buffer.
"""
t = proto_helpers.StringTransport()
a = LineOnlyTester()
a.makeConnection(t)
for c in iterbytes(self.buffer):
a.dataReceived(c)
self.assertEqual(a.received, self.buffer.split(b'\n')[:-1])
def test_lineTooLong(self):
3
Source : test_http.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def test_buffer(self):
"""
Send requests over a channel and check responses match what is expected.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DummyHTTPHandler
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all one"))
value = b.value()
self.assertResponseEquals(value, self.expected_response)
def test_requestBodyTimeout(self):
3
Source : test_http.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def test_noPipeliningApi(self):
"""
Test that a L{http.Request} subclass with no queued kwarg works as
expected.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DummyNewHTTPHandler
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all done"))
value = b.value()
self.assertResponseEquals(value, self.expected_response)
def test_noPipelining(self):
3
Source : test_http.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def _negotiatedProtocolForTransportInstance(self, t):
"""
Run a request using the specific instance of a transport. Returns the
negotiated protocol string.
"""
a = http._genericHTTPChannelProtocolFactory(b'')
a.requestFactory = DummyHTTPHandler
a.makeConnection(t)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
a.connectionLost(IOError("all done"))
return a._negotiatedProtocol
def test_protocolUnspecified(self):
0
Source : insults.py
with MIT License
from autofelix
with MIT License
from autofelix
def dataReceived(self, data):
for ch in iterbytes(data):
if self.state == b'data':
if ch == b'\x1b':
self.state = b'escaped'
else:
self.terminalProtocol.keystrokeReceived(ch, None)
elif self.state == b'escaped':
if ch == b'[':
self.state = b'bracket-escaped'
self.escBuf = []
elif ch == b'O':
self.state = b'low-function-escaped'
else:
self.state = b'data'
self._handleShortControlSequence(ch)
elif self.state == b'bracket-escaped':
if ch == b'O':
self.state = b'low-function-escaped'
elif ch.isalpha() or ch == b'~':
self._handleControlSequence(b''.join(self.escBuf) + ch)
del self.escBuf
self.state = b'data'
else:
self.escBuf.append(ch)
elif self.state == b'low-function-escaped':
self._handleLowFunctionControlSequence(ch)
self.state = b'data'
else:
raise ValueError("Illegal state")
def _handleShortControlSequence(self, ch):
0
Source : insults.py
with MIT License
from autofelix
with MIT License
from autofelix
def dataReceived(self, data):
"""
Parse the given data from a terminal server, dispatching to event
handlers defined by C{self.terminal}.
"""
toWrite = []
for b in iterbytes(data):
if self.state == b'data':
if b == b'\x1b':
if toWrite:
self.terminal.write(b''.join(toWrite))
del toWrite[:]
self.state = b'escaped'
elif b == b'\x14':
if toWrite:
self.terminal.write(b''.join(toWrite))
del toWrite[:]
self.terminal.shiftOut()
elif b == b'\x15':
if toWrite:
self.terminal.write(b''.join(toWrite))
del toWrite[:]
self.terminal.shiftIn()
elif b == b'\x08':
if toWrite:
self.terminal.write(b''.join(toWrite))
del toWrite[:]
self.terminal.cursorBackward()
else:
toWrite.append(b)
elif self.state == b'escaped':
fName = self._shorts.get(b)
if fName is not None:
self.state = b'data'
getattr(self.terminal, fName.decode("ascii"))()
else:
state = self._longs.get(b)
if state is not None:
self.state = state
else:
self.terminal.unhandledControlSequence(b'\x1b' + b)
self.state = b'data'
elif self.state == b'bracket-escape':
if self._escBuf is None:
self._escBuf = []
if b.isalpha() or b == b'~':
self._handleControlSequence(b''.join(self._escBuf), b)
del self._escBuf
self.state = b'data'
else:
self._escBuf.append(b)
elif self.state == b'select-g0':
self.terminal.selectCharacterSet(self._charsets.get(b, b), G0)
self.state = b'data'
elif self.state == b'select-g1':
self.terminal.selectCharacterSet(self._charsets.get(b, b), G1)
self.state = b'data'
elif self.state == b'select-height-width':
self._handleHeightWidth(b)
self.state = b'data'
else:
raise ValueError("Illegal state")
if toWrite:
self.terminal.write(b''.join(toWrite))
def _handleControlSequence(self, buf, terminal):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_horizontalArrows(self):
"""
When L{HistoricRecvLine} receives a LEFT_ARROW or
RIGHT_ARROW keystroke it moves the cursor left or right
in the current line buffer, respectively.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz'):
kR(ch)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.RIGHT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.LEFT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'xy', b'z'))
kR(self.pt.LEFT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'x', b'yz'))
kR(self.pt.LEFT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'', b'xyz'))
kR(self.pt.LEFT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'', b'xyz'))
kR(self.pt.RIGHT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'x', b'yz'))
kR(self.pt.RIGHT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'xy', b'z'))
kR(self.pt.RIGHT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.RIGHT_ARROW)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
def test_newline(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_newline(self):
"""
When {HistoricRecvLine} receives a newline, it adds the current
line buffer to the end of its history buffer.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz\nabc\n123\n'):
kR(ch)
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc', b'123'), ()))
kR(b'c')
kR(b'b')
kR(b'a')
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc', b'123'), ()))
kR(b'\n')
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc', b'123', b'cba'), ()))
def test_verticalArrows(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_verticalArrows(self):
"""
When L{HistoricRecvLine} receives UP_ARROW or DOWN_ARROW
keystrokes it move the current index in the current history
buffer up or down, and resets the current line buffer to the
previous or next line in history, respectively for each.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz\nabc\n123\n'):
kR(ch)
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc', b'123'), ()))
self.assertEqual(self.p.currentLineBuffer(), (b'', b''))
kR(self.pt.UP_ARROW)
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc'), (b'123',)))
self.assertEqual(self.p.currentLineBuffer(), (b'123', b''))
kR(self.pt.UP_ARROW)
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz',), (b'abc', b'123')))
self.assertEqual(self.p.currentLineBuffer(), (b'abc', b''))
kR(self.pt.UP_ARROW)
self.assertEqual(self.p.currentHistoryBuffer(),
((), (b'xyz', b'abc', b'123')))
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.UP_ARROW)
self.assertEqual(self.p.currentHistoryBuffer(),
((), (b'xyz', b'abc', b'123')))
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
for i in range(4):
kR(self.pt.DOWN_ARROW)
self.assertEqual(self.p.currentHistoryBuffer(),
((b'xyz', b'abc', b'123'), ()))
def test_home(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_backspace(self):
"""
When L{HistoricRecvLine} receives a BACKSPACE keystroke it deletes
the character immediately before the cursor.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz'):
kR(ch)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.BACKSPACE)
self.assertEqual(self.p.currentLineBuffer(), (b'xy', b''))
kR(self.pt.LEFT_ARROW)
kR(self.pt.BACKSPACE)
self.assertEqual(self.p.currentLineBuffer(), (b'', b'y'))
kR(self.pt.BACKSPACE)
self.assertEqual(self.p.currentLineBuffer(), (b'', b'y'))
def test_delete(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_delete(self):
"""
When L{HistoricRecvLine} receives a DELETE keystroke, it
delets the character immediately after the cursor.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz'):
kR(ch)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.DELETE)
self.assertEqual(self.p.currentLineBuffer(), (b'xyz', b''))
kR(self.pt.LEFT_ARROW)
kR(self.pt.DELETE)
self.assertEqual(self.p.currentLineBuffer(), (b'xy', b''))
kR(self.pt.LEFT_ARROW)
kR(self.pt.DELETE)
self.assertEqual(self.p.currentLineBuffer(), (b'x', b''))
kR(self.pt.LEFT_ARROW)
kR(self.pt.DELETE)
self.assertEqual(self.p.currentLineBuffer(), (b'', b''))
kR(self.pt.DELETE)
self.assertEqual(self.p.currentLineBuffer(), (b'', b''))
def test_insert(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_insert(self):
"""
When not in INSERT mode, L{HistoricRecvLine} inserts the typed
character at the cursor before the next character.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz'):
kR(ch)
kR(self.pt.LEFT_ARROW)
kR(b'A')
self.assertEqual(self.p.currentLineBuffer(), (b'xyA', b'z'))
kR(self.pt.LEFT_ARROW)
kR(b'B')
self.assertEqual(self.p.currentLineBuffer(), (b'xyB', b'Az'))
def test_typeover(self):
0
Source : test_recvline.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_typeover(self):
"""
When in INSERT mode and upon receiving a keystroke with a printable
character, L{HistoricRecvLine} replaces the character at
the cursor with the typed character rather than inserting before.
Ah, the ironies of INSERT mode.
"""
kR = lambda ch: self.p.keystrokeReceived(ch, None)
for ch in iterbytes(b'xyz'):
kR(ch)
kR(self.pt.INSERT)
kR(self.pt.LEFT_ARROW)
kR(b'A')
self.assertEqual(self.p.currentLineBuffer(), (b'xyA', b''))
kR(self.pt.LEFT_ARROW)
kR(b'B')
self.assertEqual(self.p.currentLineBuffer(), (b'xyB', b''))
def test_unprintableCharacters(self):
0
Source : test_telnet.py
with MIT License
from autofelix
with MIT License
from autofelix
def testBoundarySubnegotiation(self):
# Send a subnegotiation command. Split it at every possible byte boundary
# and make sure it always gets parsed and that it is passed to the correct
# method.
cmd = (telnet.IAC + telnet.SB +
b'\x12' + telnet.SE + b'hello' +
telnet.IAC + telnet.SE)
for i in range(len(cmd)):
h = self.p.protocol = TestProtocol()
h.makeConnection(self.p)
a, b = cmd[:i], cmd[i:]
L = [b"first part" + a,
b + b"last part"]
for data in L:
self.p.dataReceived(data)
self.assertEqual(h.data, b''.join(L).replace(cmd, b''))
self.assertEqual(h.subcmd, [telnet.SE] + list(iterbytes(b'hello')))
def _enabledHelper(self, o, eL=[], eR=[], dL=[], dR=[]):
0
Source : endpoints.py
with MIT License
from autofelix
with MIT License
from autofelix
def _tokenize(description):
"""
Tokenize a strports string and yield each token.
@param description: a string as described by L{serverFromString} or
L{clientFromString}.
@type description: L{str} or L{bytes}
@return: an iterable of 2-tuples of (C{_OP} or C{_STRING}, string). Tuples
starting with C{_OP} will contain a second element of either ':' (i.e.
'next parameter') or '=' (i.e. 'assign parameter value'). For example,
the string 'hello:greeting=world' would result in a generator yielding
these values::
_STRING, 'hello'
_OP, ':'
_STRING, 'greet=ing'
_OP, '='
_STRING, 'world'
"""
empty = _matchingString(u'', description)
colon = _matchingString(u':', description)
equals = _matchingString(u'=', description)
backslash = _matchingString(u'\x5c', description)
current = empty
ops = colon + equals
nextOps = {colon: colon + equals, equals: colon}
iterdesc = iter(iterbytes(description))
for n in iterdesc:
if n in iterbytes(ops):
yield _STRING, current
yield _OP, n
current = empty
ops = nextOps[n]
elif n == backslash:
current += next(iterdesc)
else:
current += n
yield _STRING, current
def _parse(description):
0
Source : test_tuntap.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_doReadSeveralDatagrams(self):
"""
L{TuntapPort.doRead} reads several datagrams, of up to
C{TuntapPort.maxThroughput} bytes total, before returning.
"""
values = cycle(iterbytes(b'abcdefghijklmnopqrstuvwxyz'))
total = 0
datagrams = []
while total < self.port.maxThroughput:
datagrams.append(next(values) * self.port.maxPacketSize)
total += self.port.maxPacketSize
self.port.startListening()
tunnel = self.system.getTunnel(self.port)
tunnel.readBuffer.extend(datagrams)
tunnel.readBuffer.append(b'excessive datagram, not to be read')
self.port.doRead()
self.assertEqual(datagrams, self.protocol.received)
def _datagramReceivedException(self):
0
Source : nmea.py
with MIT License
from autofelix
with MIT License
from autofelix
def _validateChecksum(sentence):
"""
Validates the checksum of an NMEA sentence.
@param sentence: The NMEA sentence to check the checksum of.
@type sentence: C{bytes}
@raise ValueError: If the sentence has an invalid checksum.
Simply returns on sentences that either don't have a checksum,
or have a valid checksum.
"""
if sentence[-3:-2] == b'*': # Sentence has a checksum
reference, source = int(sentence[-2:], 16), sentence[1:-3]
computed = reduce(operator.xor, [ord(x) for x in iterbytes(source)])
if computed != reference:
raise base.InvalidChecksum("%02x != %02x" % (computed, reference))
class NMEAProtocol(LineReceiver, _sentence._PositioningSentenceProducerMixin):
0
Source : test_tls.py
with MIT License
from autofelix
with MIT License
from autofelix
def handshakeProtocols(self, clientProtocols, serverProtocols):
"""
Start handshake between TLS client and server.
@param clientProtocols: The protocols the client will accept speaking
after the TLS handshake is complete.
@type clientProtocols: L{list} of L{bytes}
@param serverProtocols: The protocols the server will accept speaking
after the TLS handshake is complete.
@type serverProtocols: L{list} of L{bytes}
@return: A L{tuple} of four different items: the client L{Protocol},
the server L{Protocol}, a L{Deferred} that fires when the client
first receives bytes (and so the TLS connection is complete), and a
L{Deferred} that fires when the server first receives bytes.
@rtype: A L{tuple} of (L{Protocol}, L{Protocol}, L{Deferred},
L{Deferred})
"""
data = b'some bytes'
class NotifyingSender(Protocol):
def __init__(self, notifier):
self.notifier = notifier
def connectionMade(self):
self.transport.writeSequence(list(iterbytes(data)))
def dataReceived(self, data):
if self.notifier is not None:
self.notifier.callback(self)
self.notifier = None
clientDataReceived = Deferred()
clientFactory = ClientNegotiationFactory(clientProtocols)
clientFactory.protocol = lambda: NotifyingSender(
clientDataReceived
)
clientContextFactory, _ = (
HandshakeCallbackContextFactory.factoryAndDeferred())
wrapperFactory = TLSMemoryBIOFactory(
clientContextFactory, True, clientFactory)
sslClientProtocol = wrapperFactory.buildProtocol(None)
serverDataReceived = Deferred()
serverFactory = ServerNegotiationFactory(serverProtocols)
serverFactory.protocol = lambda: NotifyingSender(
serverDataReceived
)
serverContextFactory = ServerTLSContext()
wrapperFactory = TLSMemoryBIOFactory(
serverContextFactory, False, serverFactory)
sslServerProtocol = wrapperFactory.buildProtocol(None)
loopbackAsync(
sslServerProtocol, sslClientProtocol
)
return (sslClientProtocol, sslServerProtocol, clientDataReceived,
serverDataReceived)
def test_negotiationWithNoProtocols(self):
0
Source : test_pb.py
with MIT License
from autofelix
with MIT License
from autofelix
def pump(self):
"""
Move data back and forth.
Returns whether any data was moved.
"""
self.clientIO.seek(0)
self.serverIO.seek(0)
cData = self.clientIO.read()
sData = self.serverIO.read()
self.clientIO.seek(0)
self.serverIO.seek(0)
self.clientIO.truncate()
self.serverIO.truncate()
self.client.transport._checkProducer()
self.server.transport._checkProducer()
for byte in iterbytes(cData):
self.server.dataReceived(byte)
for byte in iterbytes(sData):
self.client.dataReceived(byte)
if cData or sData:
return 1
else:
return 0
def connectServerAndClient(test, clientFactory, serverFactory):
0
Source : test_protocols.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_portforward(self):
"""
Test port forwarding through Echo protocol.
"""
realServerFactory = protocol.ServerFactory()
realServerFactory.protocol = lambda: self.serverProtocol
realServerPort = reactor.listenTCP(0, realServerFactory,
interface='127.0.0.1')
self.openPorts.append(realServerPort)
self.proxyServerFactory = TestableProxyFactory('127.0.0.1',
realServerPort.getHost().port)
proxyServerPort = reactor.listenTCP(0, self.proxyServerFactory,
interface='127.0.0.1')
self.openPorts.append(proxyServerPort)
nBytes = 1000
received = []
d = defer.Deferred()
def testDataReceived(data):
received.extend(iterbytes(data))
if len(received) >= nBytes:
self.assertEqual(b''.join(received), b'x' * nBytes)
d.callback(None)
self.clientProtocol.dataReceived = testDataReceived
def testConnectionMade():
self.clientProtocol.transport.write(b'x' * nBytes)
self.clientProtocol.connectionMade = testConnectionMade
clientFactory = protocol.ClientFactory()
clientFactory.protocol = lambda: self.clientProtocol
reactor.connectTCP(
'127.0.0.1', proxyServerPort.getHost().port, clientFactory)
return d
def test_registerProducers(self):
0
Source : test_socks.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_socks4aSuccessfulResolution(self):
"""
If the destination IP address has zeros for the first three octets and
non-zero for the fourth octet, the client is attempting a v4a
connection. A hostname is specified after the user ID string and the
server connects to the address that hostname resolves to.
@see: U{http://en.wikipedia.org/wiki/SOCKS#SOCKS_4a_protocol}
"""
# send the domain name "localhost" to be resolved
clientRequest = (
struct.pack('!BBH', 4, 1, 34)
+ socket.inet_aton('0.0.0.1')
+ b'fooBAZ\0'
+ b'localhost\0')
# Deliver the bytes one by one to exercise the protocol's buffering
# logic. FakeResolverReactor's resolve method is invoked to "resolve"
# the hostname.
for byte in iterbytes(clientRequest):
self.sock.dataReceived(byte)
sent = self.sock.transport.value()
self.sock.transport.clear()
# Verify that the server responded with the address which will be
# connected to.
self.assertEqual(
sent,
struct.pack('!BBH', 0, 90, 34) + socket.inet_aton('127.0.0.1'))
self.assertFalse(self.sock.transport.stringTCPTransport_closing)
self.assertIsNotNone(self.sock.driver_outgoing)
# Pass some data through and verify it is forwarded to the outgoing
# connection.
self.sock.dataReceived(b'hello, world')
self.assertEqual(
self.sock.driver_outgoing.transport.value(), b'hello, world')
# Deliver some data from the output connection and verify it is
# passed along to the incoming side.
self.sock.driver_outgoing.dataReceived(b'hi there')
self.assertEqual(self.sock.transport.value(), b'hi there')
self.sock.connectionLost('fake reason')
def test_socks4aFailedResolution(self):
0
Source : test_socks.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_socks4aFailedResolution(self):
"""
Failed hostname resolution on a SOCKSv4a packet results in a 91 error
response and the connection getting closed.
"""
# send the domain name "failinghost" to be resolved
clientRequest = (
struct.pack('!BBH', 4, 1, 34)
+ socket.inet_aton('0.0.0.1')
+ b'fooBAZ\0'
+ b'failinghost\0')
# Deliver the bytes one by one to exercise the protocol's buffering
# logic. FakeResolverReactor's resolve method is invoked to "resolve"
# the hostname.
for byte in iterbytes(clientRequest):
self.sock.dataReceived(byte)
# Verify that the server responds with a 91 error.
sent = self.sock.transport.value()
self.assertEqual(
sent,
struct.pack('!BBH', 0, 91, 0) + socket.inet_aton('0.0.0.0'))
# A failed resolution causes the transport to drop the connection.
self.assertTrue(self.sock.transport.stringTCPTransport_closing)
self.assertIsNone(self.sock.driver_outgoing)
def test_accessDenied(self):
0
Source : test_socks.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_socks4a(self):
"""
If the destination IP address has zeros for the first three octets and
non-zero for the fourth octet, the client is attempting a v4a
connection. A hostname is specified after the user ID string and the
server connects to the address that hostname resolves to.
@see: U{http://en.wikipedia.org/wiki/SOCKS#SOCKS_4a_protocol}
"""
# send the domain name "localhost" to be resolved
clientRequest = (
struct.pack('!BBH', 4, 2, 34)
+ socket.inet_aton('0.0.0.1')
+ b'fooBAZ\0'
+ b'localhost\0')
# Deliver the bytes one by one to exercise the protocol's buffering
# logic. FakeResolverReactor's resolve method is invoked to "resolve"
# the hostname.
for byte in iterbytes(clientRequest):
self.sock.dataReceived(byte)
sent = self.sock.transport.value()
self.sock.transport.clear()
# Verify that the server responded with the address which will be
# connected to.
self.assertEqual(
sent,
struct.pack('!BBH', 0, 90, 1234) + socket.inet_aton('6.7.8.9'))
self.assertFalse(self.sock.transport.stringTCPTransport_closing)
self.assertIsNotNone(self.sock.driver_listen)
# connect
incoming = self.sock.driver_listen.buildProtocol(('127.0.0.1', 5345))
self.assertIsNotNone(incoming)
incoming.transport = StringTCPTransport()
incoming.connectionMade()
# now we should have the second reply packet
sent = self.sock.transport.value()
self.sock.transport.clear()
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 0)
+ socket.inet_aton('0.0.0.0'))
self.assertIsNot(
self.sock.transport.stringTCPTransport_closing, None)
# Deliver some data from the output connection and verify it is
# passed along to the incoming side.
self.sock.dataReceived(b'hi there')
self.assertEqual(incoming.transport.value(), b'hi there')
# the other way around
incoming.dataReceived(b'hi there')
self.assertEqual(self.sock.transport.value(), b'hi there')
self.sock.connectionLost('fake reason')
def test_socks4aFailedResolution(self):
0
Source : test_socks.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_socks4aFailedResolution(self):
"""
Failed hostname resolution on a SOCKSv4a packet results in a 91 error
response and the connection getting closed.
"""
# send the domain name "failinghost" to be resolved
clientRequest = (
struct.pack('!BBH', 4, 2, 34)
+ socket.inet_aton('0.0.0.1')
+ b'fooBAZ\0'
+ b'failinghost\0')
# Deliver the bytes one by one to exercise the protocol's buffering
# logic. FakeResolverReactor's resolve method is invoked to "resolve"
# the hostname.
for byte in iterbytes(clientRequest):
self.sock.dataReceived(byte)
# Verify that the server responds with a 91 error.
sent = self.sock.transport.value()
self.assertEqual(
sent,
struct.pack('!BBH', 0, 91, 0) + socket.inet_aton('0.0.0.0'))
# A failed resolution causes the transport to drop the connection.
self.assertTrue(self.sock.transport.stringTCPTransport_closing)
self.assertIsNone(self.sock.driver_outgoing)
def test_accessDenied(self):
0
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_noPipelining(self):
"""
Test that pipelined requests get buffered, not processed in parallel.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DelayedHTTPHandlerProxy
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
value = b.value()
# So far only one request should have been dispatched.
self.assertEqual(value, b'')
self.assertEqual(1, len(a.requests))
# Now, process each request one at a time.
while a.requests:
self.assertEqual(1, len(a.requests))
request = a.requests[0].original
request.delayedProcess()
value = b.value()
self.assertResponseEquals(value, self.expected_response)
class HTTP1_1Tests(HTTP1_0Tests):
0
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_noPipelining(self):
"""
Test that pipelined requests get buffered, not processed in parallel.
"""
b = StringTransport()
a = http.HTTPChannel()
a.requestFactory = DelayedHTTPHandlerProxy
a.makeConnection(b)
# one byte at a time, to stress it.
for byte in iterbytes(self.requests):
a.dataReceived(byte)
value = b.value()
# So far only one request should have been dispatched.
self.assertEqual(value, b'')
self.assertEqual(1, len(a.requests))
# Now, process each request one at a time.
while a.requests:
self.assertEqual(1, len(a.requests))
request = a.requests[0].original
request.delayedProcess()
value = b.value()
self.assertResponseEquals(value, self.expectedResponses)
def test_pipeliningReadLimit(self):
0
Source : test_http.py
with MIT License
from autofelix
with MIT License
from autofelix
def runRequest(self, httpRequest, requestFactory=None, success=True,
channel=None):
"""
Execute a web request based on plain text content.
@param httpRequest: Content for the request which is processed.
@type httpRequest: C{bytes}
@param requestFactory: 2-argument callable returning a Request.
@type requestFactory: C{callable}
@param success: Value to compare against I{self.didRequest}.
@type success: C{bool}
@param channel: Channel instance over which the request is processed.
@type channel: L{HTTPChannel}
@return: Returns the channel used for processing the request.
@rtype: L{HTTPChannel}
"""
if not channel:
channel = http.HTTPChannel()
if requestFactory:
channel.requestFactory = _makeRequestProxyFactory(requestFactory)
httpRequest = httpRequest.replace(b"\n", b"\r\n")
transport = StringTransport()
channel.makeConnection(transport)
# one byte at a time, to stress it.
for byte in iterbytes(httpRequest):
if channel.transport.disconnecting:
break
channel.dataReceived(byte)
channel.connectionLost(IOError("all done"))
if success:
self.assertTrue(self.didRequest)
else:
self.assertFalse(self.didRequest)
return channel
def test_invalidNonAsciiMethod(self):
0
Source : test_http2.py
with MIT License
from autofelix
with MIT License
from autofelix
def connectAndReceive(self, connection, headers, body):
"""
Takes a single L{H2Connection} object and connects it to a
L{StringTransport} using a brand new L{FrameFactory}.
@param connection: The L{H2Connection} object to connect.
@type connection: L{H2Connection}
@param headers: The headers to send on the first request.
@type headers: L{Iterable} of L{tuple} of C{(bytes, bytes)}
@param body: Chunks of body to send, if any.
@type body: L{Iterable} of L{bytes}
@return: A tuple of L{FrameFactory}, L{StringTransport}
"""
frameFactory = FrameFactory()
transport = StringTransport()
requestBytes = frameFactory.clientConnectionPreface()
requestBytes += buildRequestBytes(headers, body, frameFactory)
connection.makeConnection(transport)
# One byte at a time, to stress the implementation.
for byte in iterbytes(requestBytes):
connection.dataReceived(byte)
return frameFactory, transport
def test_basicRequest(self):
0
Source : test_http2.py
with MIT License
from autofelix
with MIT License
from autofelix
def test_interleavedRequests(self):
"""
Many interleaved POST requests all get received and responded to
appropriately.
"""
# Unfortunately this test is pretty complex.
REQUEST_COUNT = 40
f = FrameFactory()
b = StringTransport()
a = H2Connection()
a.requestFactory = DummyHTTPHandlerProxy
# Stream IDs are always odd numbers.
streamIDs = list(range(1, REQUEST_COUNT * 2, 2))
frames = [
buildRequestFrames(
self.postRequestHeaders, self.postRequestData, f, streamID
) for streamID in streamIDs
]
requestBytes = f.clientConnectionPreface()
# Interleave the frames. That is, send one frame from each stream at a
# time. This wacky line lets us do that.
frames = itertools.chain.from_iterable(zip(*frames))
requestBytes += b''.join(frame.serialize() for frame in frames)
a.makeConnection(b)
# one byte at a time, to stress the implementation.
for byte in iterbytes(requestBytes):
a.dataReceived(byte)
def validate(results):
frames = framesFromBytes(b.value())
# We expect 1 Settings frame for the connection, and then 3 frames
# *per stream* (1 Headers frame, 2 Data frames). This doesn't send
# enough data to trigger a window update.
self.assertEqual(len(frames), 1 + (3 * 40))
# Let's check the data is ok. We need the non-WindowUpdate frames
# for each stream.
for streamID in streamIDs:
streamFrames = [
f for f in frames if f.stream_id == streamID and
not isinstance(f, hyperframe.frame.WindowUpdateFrame)
]
self.assertEqual(len(streamFrames), 3)
self.assertEqual(
dict(streamFrames[0].data), dict(self.postResponseHeaders)
)
self.assertEqual(streamFrames[1].data, self.postResponseData)
self.assertEqual(streamFrames[2].data, b'')
self.assertTrue('END_STREAM' in streamFrames[2].flags)
return defer.DeferredList(
list(a._streamCleanupCallbacks.values())
).addCallback(validate)
def test_sendAccordingToPriority(self):
See More Examples