--- a/tests/test-wireproto-serverreactor.py	Sat Oct 05 10:29:34 2019 -0400
+++ b/tests/test-wireproto-serverreactor.py	Sun Oct 06 09:45:02 2019 -0400
@@ -7,18 +7,18 @@
     util,
     wireprotoframing as framing,
 )
-from mercurial.utils import (
-    cborutil,
-)
+from mercurial.utils import cborutil
 
 ffs = framing.makeframefromhumanstring
 
 OK = b''.join(cborutil.streamencode({b'status': b'ok'}))
 
+
 def makereactor(deferoutput=False):
     ui = uimod.ui()
     return framing.serverreactor(ui, deferoutput=deferoutput)
 
+
 def sendframes(reactor, gen):
     """Send a generator of frame bytearray to a reactor.
 
@@ -26,21 +26,26 @@
     """
     for frame in gen:
         header = framing.parseheader(frame)
-        payload = frame[framing.FRAME_HEADER_SIZE:]
+        payload = frame[framing.FRAME_HEADER_SIZE :]
         assert len(payload) == header.length
 
-        yield reactor.onframerecv(framing.frame(header.requestid,
-                                                header.streamid,
-                                                header.streamflags,
-                                                header.typeid,
-                                                header.flags,
-                                                payload))
+        yield reactor.onframerecv(
+            framing.frame(
+                header.requestid,
+                header.streamid,
+                header.streamflags,
+                header.typeid,
+                header.flags,
+                payload,
+            )
+        )
+
 
 def sendcommandframes(reactor, stream, rid, cmd, args, datafh=None):
     """Generate frames to run a command and send them to a reactor."""
-    return sendframes(reactor,
-                      framing.createcommandframes(stream, rid, cmd, args,
-                                                  datafh))
+    return sendframes(
+        reactor, framing.createcommandframes(stream, rid, cmd, args, datafh)
+    )
 
 
 class ServerReactorTests(unittest.TestCase):
@@ -67,13 +72,16 @@
         results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {}))
         self.assertEqual(len(results), 1)
         self.assertaction(results[0], b'runcommand')
-        self.assertEqual(results[0][1], {
-            b'requestid': 1,
-            b'command': b'mycommand',
-            b'args': {},
-            b'redirect': None,
-            b'data': None,
-        })
+        self.assertEqual(
+            results[0][1],
+            {
+                b'requestid': 1,
+                b'command': b'mycommand',
+                b'args': {},
+                b'redirect': None,
+                b'data': None,
+            },
+        )
 
         result = reactor.oninputeof()
         self.assertaction(result, b'noop')
@@ -81,53 +89,77 @@
     def test1argument(self):
         reactor = makereactor()
         stream = framing.stream(1)
-        results = list(sendcommandframes(reactor, stream, 41, b'mycommand',
-                                         {b'foo': b'bar'}))
+        results = list(
+            sendcommandframes(
+                reactor, stream, 41, b'mycommand', {b'foo': b'bar'}
+            )
+        )
         self.assertEqual(len(results), 1)
         self.assertaction(results[0], b'runcommand')
-        self.assertEqual(results[0][1], {
-            b'requestid': 41,
-            b'command': b'mycommand',
-            b'args': {b'foo': b'bar'},
-            b'redirect': None,
-            b'data': None,
-        })
+        self.assertEqual(
+            results[0][1],
+            {
+                b'requestid': 41,
+                b'command': b'mycommand',
+                b'args': {b'foo': b'bar'},
+                b'redirect': None,
+                b'data': None,
+            },
+        )
 
     def testmultiarguments(self):
         reactor = makereactor()
         stream = framing.stream(1)
-        results = list(sendcommandframes(reactor, stream, 1, b'mycommand',
-                                         {b'foo': b'bar', b'biz': b'baz'}))
+        results = list(
+            sendcommandframes(
+                reactor,
+                stream,
+                1,
+                b'mycommand',
+                {b'foo': b'bar', b'biz': b'baz'},
+            )
+        )
         self.assertEqual(len(results), 1)
         self.assertaction(results[0], b'runcommand')
-        self.assertEqual(results[0][1], {
-            b'requestid': 1,
-            b'command': b'mycommand',
-            b'args': {b'foo': b'bar', b'biz': b'baz'},
-            b'redirect': None,
-            b'data': None,
-        })
+        self.assertEqual(
+            results[0][1],
+            {
+                b'requestid': 1,
+                b'command': b'mycommand',
+                b'args': {b'foo': b'bar', b'biz': b'baz'},
+                b'redirect': None,
+                b'data': None,
+            },
+        )
 
     def testsimplecommanddata(self):
         reactor = makereactor()
         stream = framing.stream(1)
-        results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {},
-                                         util.bytesio(b'data!')))
+        results = list(
+            sendcommandframes(
+                reactor, stream, 1, b'mycommand', {}, util.bytesio(b'data!')
+            )
+        )
         self.assertEqual(len(results), 2)
         self.assertaction(results[0], b'wantframe')
         self.assertaction(results[1], b'runcommand')
-        self.assertEqual(results[1][1], {
-            b'requestid': 1,
-            b'command': b'mycommand',
-            b'args': {},
-            b'redirect': None,
-            b'data': b'data!',
-        })
+        self.assertEqual(
+            results[1][1],
+            {
+                b'requestid': 1,
+                b'command': b'mycommand',
+                b'args': {},
+                b'redirect': None,
+                b'data': b'data!',
+            },
+        )
 
     def testmultipledataframes(self):
         frames = [
-            ffs(b'1 1 stream-begin command-request new|have-data '
-                b"cbor:{b'name': b'mycommand'}"),
+            ffs(
+                b'1 1 stream-begin command-request new|have-data '
+                b"cbor:{b'name': b'mycommand'}"
+            ),
             ffs(b'1 1 0 command-data continuation data1'),
             ffs(b'1 1 0 command-data continuation data2'),
             ffs(b'1 1 0 command-data eos data3'),
@@ -139,19 +171,24 @@
         for i in range(3):
             self.assertaction(results[i], b'wantframe')
         self.assertaction(results[3], b'runcommand')
-        self.assertEqual(results[3][1], {
-            b'requestid': 1,
-            b'command': b'mycommand',
-            b'args': {},
-            b'redirect': None,
-            b'data': b'data1data2data3',
-        })
+        self.assertEqual(
+            results[3][1],
+            {
+                b'requestid': 1,
+                b'command': b'mycommand',
+                b'args': {},
+                b'redirect': None,
+                b'data': b'data1data2data3',
+            },
+        )
 
     def testargumentanddata(self):
         frames = [
-            ffs(b'1 1 stream-begin command-request new|have-data '
+            ffs(
+                b'1 1 stream-begin command-request new|have-data '
                 b"cbor:{b'name': b'command', b'args': {b'key': b'val',"
-                b"b'foo': b'bar'}}"),
+                b"b'foo': b'bar'}}"
+            ),
             ffs(b'1 1 0 command-data continuation value1'),
             ffs(b'1 1 0 command-data eos value2'),
         ]
@@ -160,169 +197,251 @@
         results = list(sendframes(reactor, frames))
 
         self.assertaction(results[-1], b'runcommand')
-        self.assertEqual(results[-1][1], {
-            b'requestid': 1,
-            b'command': b'command',
-            b'args': {
-                b'key': b'val',
-                b'foo': b'bar',
+        self.assertEqual(
+            results[-1][1],
+            {
+                b'requestid': 1,
+                b'command': b'command',
+                b'args': {b'key': b'val', b'foo': b'bar',},
+                b'redirect': None,
+                b'data': b'value1value2',
             },
-            b'redirect': None,
-            b'data': b'value1value2',
-        })
+        )
 
     def testnewandcontinuation(self):
-        result = self._sendsingleframe(makereactor(),
-            ffs(b'1 1 stream-begin command-request new|continuation '))
+        result = self._sendsingleframe(
+            makereactor(),
+            ffs(b'1 1 stream-begin command-request new|continuation '),
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'received command request frame with both new and '
-                        b'continuation flags set',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'received command request frame with both new and '
+                b'continuation flags set',
+            },
+        )
 
     def testneithernewnorcontinuation(self):
-        result = self._sendsingleframe(makereactor(),
-            ffs(b'1 1 stream-begin command-request 0 '))
+        result = self._sendsingleframe(
+            makereactor(), ffs(b'1 1 stream-begin command-request 0 ')
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'received command request frame with neither new nor '
-                        b'continuation flags set',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'received command request frame with neither new nor '
+                b'continuation flags set',
+            },
+        )
 
     def testunexpectedcommanddata(self):
         """Command data frame when not running a command is an error."""
-        result = self._sendsingleframe(makereactor(),
-            ffs(b'1 1 stream-begin command-data 0 ignored'))
+        result = self._sendsingleframe(
+            makereactor(), ffs(b'1 1 stream-begin command-data 0 ignored')
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'expected sender protocol settings or command request '
-                        b'frame; got 2',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'expected sender protocol settings or command request '
+                b'frame; got 2',
+            },
+        )
 
     def testunexpectedcommanddatareceiving(self):
         """Same as above except the command is receiving."""
-        results = list(sendframes(makereactor(), [
-            ffs(b'1 1 stream-begin command-request new|more '
-                b"cbor:{b'name': b'ignored'}"),
-            ffs(b'1 1 0 command-data eos ignored'),
-        ]))
+        results = list(
+            sendframes(
+                makereactor(),
+                [
+                    ffs(
+                        b'1 1 stream-begin command-request new|more '
+                        b"cbor:{b'name': b'ignored'}"
+                    ),
+                    ffs(b'1 1 0 command-data eos ignored'),
+                ],
+            )
+        )
 
         self.assertaction(results[0], b'wantframe')
         self.assertaction(results[1], b'error')
-        self.assertEqual(results[1][1], {
-            b'message': b'received command data frame for request that is not '
-                        b'expecting data: 1',
-        })
+        self.assertEqual(
+            results[1][1],
+            {
+                b'message': b'received command data frame for request that is not '
+                b'expecting data: 1',
+            },
+        )
 
     def testconflictingrequestidallowed(self):
         """Multiple fully serviced commands with same request ID is allowed."""
         reactor = makereactor()
         results = []
         outstream = reactor.makeoutputstream()
-        results.append(self._sendsingleframe(
-            reactor, ffs(b'1 1 stream-begin command-request new '
-                         b"cbor:{b'name': b'command'}")))
+        results.append(
+            self._sendsingleframe(
+                reactor,
+                ffs(
+                    b'1 1 stream-begin command-request new '
+                    b"cbor:{b'name': b'command'}"
+                ),
+            )
+        )
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response1'])
+            outstream, 1, [b'response1']
+        )
         self.assertaction(result, b'sendframes')
         list(result[1][b'framegen'])
-        results.append(self._sendsingleframe(
-            reactor, ffs(b'1 1 stream-begin command-request new '
-                         b"cbor:{b'name': b'command'}")))
+        results.append(
+            self._sendsingleframe(
+                reactor,
+                ffs(
+                    b'1 1 stream-begin command-request new '
+                    b"cbor:{b'name': b'command'}"
+                ),
+            )
+        )
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response2'])
+            outstream, 1, [b'response2']
+        )
         self.assertaction(result, b'sendframes')
         list(result[1][b'framegen'])
-        results.append(self._sendsingleframe(
-            reactor, ffs(b'1 1 stream-begin command-request new '
-                         b"cbor:{b'name': b'command'}")))
+        results.append(
+            self._sendsingleframe(
+                reactor,
+                ffs(
+                    b'1 1 stream-begin command-request new '
+                    b"cbor:{b'name': b'command'}"
+                ),
+            )
+        )
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response3'])
+            outstream, 1, [b'response3']
+        )
         self.assertaction(result, b'sendframes')
         list(result[1][b'framegen'])
 
         for i in range(3):
             self.assertaction(results[i], b'runcommand')
-            self.assertEqual(results[i][1], {
-                b'requestid': 1,
-                b'command': b'command',
-                b'args': {},
-                b'redirect': None,
-                b'data': None,
-            })
+            self.assertEqual(
+                results[i][1],
+                {
+                    b'requestid': 1,
+                    b'command': b'command',
+                    b'args': {},
+                    b'redirect': None,
+                    b'data': None,
+                },
+            )
 
     def testconflictingrequestid(self):
         """Request ID for new command matching in-flight command is illegal."""
-        results = list(sendframes(makereactor(), [
-            ffs(b'1 1 stream-begin command-request new|more '
-                b"cbor:{b'name': b'command'}"),
-            ffs(b'1 1 0 command-request new '
-                b"cbor:{b'name': b'command1'}"),
-        ]))
+        results = list(
+            sendframes(
+                makereactor(),
+                [
+                    ffs(
+                        b'1 1 stream-begin command-request new|more '
+                        b"cbor:{b'name': b'command'}"
+                    ),
+                    ffs(
+                        b'1 1 0 command-request new '
+                        b"cbor:{b'name': b'command1'}"
+                    ),
+                ],
+            )
+        )
 
         self.assertaction(results[0], b'wantframe')
         self.assertaction(results[1], b'error')
-        self.assertEqual(results[1][1], {
-            b'message': b'request with ID 1 already received',
-        })
+        self.assertEqual(
+            results[1][1], {b'message': b'request with ID 1 already received',}
+        )
 
     def testinterleavedcommands(self):
-        cbor1 = b''.join(cborutil.streamencode({
-            b'name': b'command1',
-            b'args': {
-                b'foo': b'bar',
-                b'key1': b'val',
-            }
-        }))
-        cbor3 = b''.join(cborutil.streamencode({
-            b'name': b'command3',
-            b'args': {
-                b'biz': b'baz',
-                b'key': b'val',
-            },
-        }))
-
-        results = list(sendframes(makereactor(), [
-            ffs(b'1 1 stream-begin command-request new|more %s' % cbor1[0:6]),
-            ffs(b'3 1 0 command-request new|more %s' % cbor3[0:10]),
-            ffs(b'1 1 0 command-request continuation|more %s' % cbor1[6:9]),
-            ffs(b'3 1 0 command-request continuation|more %s' % cbor3[10:13]),
-            ffs(b'3 1 0 command-request continuation %s' % cbor3[13:]),
-            ffs(b'1 1 0 command-request continuation %s' % cbor1[9:]),
-        ]))
+        cbor1 = b''.join(
+            cborutil.streamencode(
+                {
+                    b'name': b'command1',
+                    b'args': {b'foo': b'bar', b'key1': b'val',},
+                }
+            )
+        )
+        cbor3 = b''.join(
+            cborutil.streamencode(
+                {
+                    b'name': b'command3',
+                    b'args': {b'biz': b'baz', b'key': b'val',},
+                }
+            )
+        )
 
-        self.assertEqual([t[0] for t in results], [
-            b'wantframe',
-            b'wantframe',
-            b'wantframe',
-            b'wantframe',
-            b'runcommand',
-            b'runcommand',
-        ])
+        results = list(
+            sendframes(
+                makereactor(),
+                [
+                    ffs(
+                        b'1 1 stream-begin command-request new|more %s'
+                        % cbor1[0:6]
+                    ),
+                    ffs(b'3 1 0 command-request new|more %s' % cbor3[0:10]),
+                    ffs(
+                        b'1 1 0 command-request continuation|more %s'
+                        % cbor1[6:9]
+                    ),
+                    ffs(
+                        b'3 1 0 command-request continuation|more %s'
+                        % cbor3[10:13]
+                    ),
+                    ffs(b'3 1 0 command-request continuation %s' % cbor3[13:]),
+                    ffs(b'1 1 0 command-request continuation %s' % cbor1[9:]),
+                ],
+            )
+        )
 
-        self.assertEqual(results[4][1], {
-            b'requestid': 3,
-            b'command': b'command3',
-            b'args': {b'biz': b'baz', b'key': b'val'},
-            b'redirect': None,
-            b'data': None,
-        })
-        self.assertEqual(results[5][1], {
-            b'requestid': 1,
-            b'command': b'command1',
-            b'args': {b'foo': b'bar', b'key1': b'val'},
-            b'redirect': None,
-            b'data': None,
-        })
+        self.assertEqual(
+            [t[0] for t in results],
+            [
+                b'wantframe',
+                b'wantframe',
+                b'wantframe',
+                b'wantframe',
+                b'runcommand',
+                b'runcommand',
+            ],
+        )
+
+        self.assertEqual(
+            results[4][1],
+            {
+                b'requestid': 3,
+                b'command': b'command3',
+                b'args': {b'biz': b'baz', b'key': b'val'},
+                b'redirect': None,
+                b'data': None,
+            },
+        )
+        self.assertEqual(
+            results[5][1],
+            {
+                b'requestid': 1,
+                b'command': b'command1',
+                b'args': {b'foo': b'bar', b'key1': b'val'},
+                b'redirect': None,
+                b'data': None,
+            },
+        )
 
     def testmissingcommanddataframe(self):
         # The reactor doesn't currently handle partially received commands.
         # So this test is failing to do anything with request 1.
         frames = [
-            ffs(b'1 1 stream-begin command-request new|have-data '
-                b"cbor:{b'name': b'command1'}"),
-            ffs(b'3 1 0 command-request new '
-                b"cbor:{b'name': b'command2'}"),
+            ffs(
+                b'1 1 stream-begin command-request new|have-data '
+                b"cbor:{b'name': b'command1'}"
+            ),
+            ffs(b'3 1 0 command-request new ' b"cbor:{b'name': b'command2'}"),
         ]
         results = list(sendframes(makereactor(), frames))
         self.assertEqual(len(results), 2)
@@ -331,31 +450,45 @@
 
     def testmissingcommanddataframeflags(self):
         frames = [
-            ffs(b'1 1 stream-begin command-request new|have-data '
-                b"cbor:{b'name': b'command1'}"),
+            ffs(
+                b'1 1 stream-begin command-request new|have-data '
+                b"cbor:{b'name': b'command1'}"
+            ),
             ffs(b'1 1 0 command-data 0 data'),
         ]
         results = list(sendframes(makereactor(), frames))
         self.assertEqual(len(results), 2)
         self.assertaction(results[0], b'wantframe')
         self.assertaction(results[1], b'error')
-        self.assertEqual(results[1][1], {
-            b'message': b'command data frame without flags',
-        })
+        self.assertEqual(
+            results[1][1], {b'message': b'command data frame without flags',}
+        )
 
     def testframefornonreceivingrequest(self):
         """Receiving a frame for a command that is not receiving is illegal."""
-        results = list(sendframes(makereactor(), [
-            ffs(b'1 1 stream-begin command-request new '
-                b"cbor:{b'name': b'command1'}"),
-            ffs(b'3 1 0 command-request new|have-data '
-                b"cbor:{b'name': b'command3'}"),
-            ffs(b'5 1 0 command-data eos ignored'),
-        ]))
+        results = list(
+            sendframes(
+                makereactor(),
+                [
+                    ffs(
+                        b'1 1 stream-begin command-request new '
+                        b"cbor:{b'name': b'command1'}"
+                    ),
+                    ffs(
+                        b'3 1 0 command-request new|have-data '
+                        b"cbor:{b'name': b'command3'}"
+                    ),
+                    ffs(b'5 1 0 command-data eos ignored'),
+                ],
+            )
+        )
         self.assertaction(results[2], b'error')
-        self.assertEqual(results[2][1], {
-            b'message': b'received frame for request that is not receiving: 5',
-        })
+        self.assertEqual(
+            results[2][1],
+            {
+                b'message': b'received frame for request that is not receiving: 5',
+            },
+        )
 
     def testsimpleresponse(self):
         """Bytes response to command sends result frames."""
@@ -365,14 +498,18 @@
 
         outstream = reactor.makeoutputstream()
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response'])
+            outstream, 1, [b'response']
+        )
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b'1 2 stream-begin stream-settings eos cbor:b"identity"',
-            b'1 2 encoded command-response continuation %s' % OK,
-            b'1 2 encoded command-response continuation cbor:b"response"',
-            b'1 2 0 command-response eos ',
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
+                b'1 2 encoded command-response continuation %s' % OK,
+                b'1 2 encoded command-response continuation cbor:b"response"',
+                b'1 2 0 command-response eos ',
+            ],
+        )
 
     def testmultiframeresponse(self):
         """Bytes response spanning multiple frames is handled."""
@@ -385,16 +522,20 @@
 
         outstream = reactor.makeoutputstream()
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [first + second])
+            outstream, 1, [first + second]
+        )
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b'1 2 stream-begin stream-settings eos cbor:b"identity"',
-            b'1 2 encoded command-response continuation %s' % OK,
-            b'1 2 encoded command-response continuation Y\x80d',
-            b'1 2 encoded command-response continuation %s' % first,
-            b'1 2 encoded command-response continuation %s' % second,
-            b'1 2 0 command-response eos '
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
+                b'1 2 encoded command-response continuation %s' % OK,
+                b'1 2 encoded command-response continuation Y\x80d',
+                b'1 2 encoded command-response continuation %s' % first,
+                b'1 2 encoded command-response continuation %s' % second,
+                b'1 2 0 command-response eos ',
+            ],
+        )
 
     def testservererror(self):
         reactor = makereactor()
@@ -404,33 +545,41 @@
         outstream = reactor.makeoutputstream()
         result = reactor.onservererror(outstream, 1, b'some message')
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b"1 2 stream-begin error-response 0 "
-            b"cbor:{b'type': b'server', "
-            b"b'message': [{b'msg': b'some message'}]}",
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b"1 2 stream-begin error-response 0 "
+                b"cbor:{b'type': b'server', "
+                b"b'message': [{b'msg': b'some message'}]}",
+            ],
+        )
 
     def test1commanddeferresponse(self):
         """Responses when in deferred output mode are delayed until EOF."""
         reactor = makereactor(deferoutput=True)
         instream = framing.stream(1)
-        results = list(sendcommandframes(reactor, instream, 1, b'mycommand',
-                                         {}))
+        results = list(
+            sendcommandframes(reactor, instream, 1, b'mycommand', {})
+        )
         self.assertEqual(len(results), 1)
         self.assertaction(results[0], b'runcommand')
 
         outstream = reactor.makeoutputstream()
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response'])
+            outstream, 1, [b'response']
+        )
         self.assertaction(result, b'noop')
         result = reactor.oninputeof()
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b'1 2 stream-begin stream-settings eos cbor:b"identity"',
-            b'1 2 encoded command-response continuation %s' % OK,
-            b'1 2 encoded command-response continuation cbor:b"response"',
-            b'1 2 0 command-response eos ',
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
+                b'1 2 encoded command-response continuation %s' % OK,
+                b'1 2 encoded command-response continuation cbor:b"response"',
+                b'1 2 0 command-response eos ',
+            ],
+        )
 
     def testmultiplecommanddeferresponse(self):
         reactor = makereactor(deferoutput=True)
@@ -440,22 +589,27 @@
 
         outstream = reactor.makeoutputstream()
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 1, [b'response1'])
+            outstream, 1, [b'response1']
+        )
         self.assertaction(result, b'noop')
         result = reactor.oncommandresponsereadyobjects(
-            outstream, 3, [b'response2'])
+            outstream, 3, [b'response2']
+        )
         self.assertaction(result, b'noop')
         result = reactor.oninputeof()
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b'1 2 stream-begin stream-settings eos cbor:b"identity"',
-            b'1 2 encoded command-response continuation %s' % OK,
-            b'1 2 encoded command-response continuation cbor:b"response1"',
-            b'1 2 0 command-response eos ',
-            b'3 2 encoded command-response continuation %s' % OK,
-            b'3 2 encoded command-response continuation cbor:b"response2"',
-            b'3 2 0 command-response eos ',
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
+                b'1 2 encoded command-response continuation %s' % OK,
+                b'1 2 encoded command-response continuation cbor:b"response1"',
+                b'1 2 0 command-response eos ',
+                b'3 2 encoded command-response continuation %s' % OK,
+                b'3 2 encoded command-response continuation cbor:b"response2"',
+                b'3 2 0 command-response eos ',
+            ],
+        )
 
     def testrequestidtracking(self):
         reactor = makereactor(deferoutput=True)
@@ -472,18 +626,21 @@
 
         result = reactor.oninputeof()
         self.assertaction(result, b'sendframes')
-        self.assertframesequal(result[1][b'framegen'], [
-            b'3 2 stream-begin stream-settings eos cbor:b"identity"',
-            b'3 2 encoded command-response continuation %s' % OK,
-            b'3 2 encoded command-response continuation cbor:b"response3"',
-            b'3 2 0 command-response eos ',
-            b'1 2 encoded command-response continuation %s' % OK,
-            b'1 2 encoded command-response continuation cbor:b"response1"',
-            b'1 2 0 command-response eos ',
-            b'5 2 encoded command-response continuation %s' % OK,
-            b'5 2 encoded command-response continuation cbor:b"response5"',
-            b'5 2 0 command-response eos ',
-        ])
+        self.assertframesequal(
+            result[1][b'framegen'],
+            [
+                b'3 2 stream-begin stream-settings eos cbor:b"identity"',
+                b'3 2 encoded command-response continuation %s' % OK,
+                b'3 2 encoded command-response continuation cbor:b"response3"',
+                b'3 2 0 command-response eos ',
+                b'1 2 encoded command-response continuation %s' % OK,
+                b'1 2 encoded command-response continuation cbor:b"response1"',
+                b'1 2 0 command-response eos ',
+                b'5 2 encoded command-response continuation %s' % OK,
+                b'5 2 encoded command-response continuation cbor:b"response5"',
+                b'5 2 0 command-response eos ',
+            ],
+        )
 
     def testduplicaterequestonactivecommand(self):
         """Receiving a request ID that matches a request that isn't finished."""
@@ -493,9 +650,9 @@
         results = list(sendcommandframes(reactor, stream, 1, b'command1', {}))
 
         self.assertaction(results[0], b'error')
-        self.assertEqual(results[0][1], {
-            b'message': b'request with ID 1 is already active',
-        })
+        self.assertEqual(
+            results[0][1], {b'message': b'request with ID 1 is already active',}
+        )
 
     def testduplicaterequestonactivecommandnosend(self):
         """Same as above but we've registered a response but haven't sent it."""
@@ -510,9 +667,9 @@
 
         results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
         self.assertaction(results[0], b'error')
-        self.assertEqual(results[0][1], {
-            b'message': b'request with ID 1 is already active',
-        })
+        self.assertEqual(
+            results[0][1], {b'message': b'request with ID 1 is already active',}
+        )
 
     def testduplicaterequestaftersend(self):
         """We can use a duplicate request ID after we've sent the response."""
@@ -528,70 +685,100 @@
 
     def testprotocolsettingsnoflags(self):
         result = self._sendsingleframe(
-            makereactor(),
-            ffs(b'0 1 stream-begin sender-protocol-settings 0 '))
+            makereactor(), ffs(b'0 1 stream-begin sender-protocol-settings 0 ')
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'sender protocol settings frame must have '
-                        b'continuation or end of stream flag set',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'sender protocol settings frame must have '
+                b'continuation or end of stream flag set',
+            },
+        )
 
     def testprotocolsettingsconflictflags(self):
         result = self._sendsingleframe(
             makereactor(),
-            ffs(b'0 1 stream-begin sender-protocol-settings continuation|eos '))
+            ffs(b'0 1 stream-begin sender-protocol-settings continuation|eos '),
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'sender protocol settings frame cannot have both '
-                        b'continuation and end of stream flags set',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'sender protocol settings frame cannot have both '
+                b'continuation and end of stream flags set',
+            },
+        )
 
     def testprotocolsettingsemptypayload(self):
         result = self._sendsingleframe(
             makereactor(),
-            ffs(b'0 1 stream-begin sender-protocol-settings eos '))
+            ffs(b'0 1 stream-begin sender-protocol-settings eos '),
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'sender protocol settings frame did not contain CBOR '
-                        b'data',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'sender protocol settings frame did not contain CBOR '
+                b'data',
+            },
+        )
 
     def testprotocolsettingsmultipleobjects(self):
         result = self._sendsingleframe(
             makereactor(),
-            ffs(b'0 1 stream-begin sender-protocol-settings eos '
-                b'\x46foobar\x43foo'))
+            ffs(
+                b'0 1 stream-begin sender-protocol-settings eos '
+                b'\x46foobar\x43foo'
+            ),
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'sender protocol settings frame contained multiple '
-                        b'CBOR values',
-        })
+        self.assertEqual(
+            result[1],
+            {
+                b'message': b'sender protocol settings frame contained multiple '
+                b'CBOR values',
+            },
+        )
 
     def testprotocolsettingscontentencodings(self):
         reactor = makereactor()
 
         result = self._sendsingleframe(
             reactor,
-            ffs(b'0 1 stream-begin sender-protocol-settings eos '
-                b'cbor:{b"contentencodings": [b"a", b"b"]}'))
+            ffs(
+                b'0 1 stream-begin sender-protocol-settings eos '
+                b'cbor:{b"contentencodings": [b"a", b"b"]}'
+            ),
+        )
         self.assertaction(result, b'wantframe')
 
         self.assertEqual(reactor._state, b'idle')
-        self.assertEqual(reactor._sendersettings[b'contentencodings'],
-                         [b'a', b'b'])
+        self.assertEqual(
+            reactor._sendersettings[b'contentencodings'], [b'a', b'b']
+        )
 
     def testprotocolsettingsmultipleframes(self):
         reactor = makereactor()
 
-        data = b''.join(cborutil.streamencode({
-            b'contentencodings': [b'value1', b'value2'],
-        }))
+        data = b''.join(
+            cborutil.streamencode(
+                {b'contentencodings': [b'value1', b'value2'],}
+            )
+        )
 
-        results = list(sendframes(reactor, [
-            ffs(b'0 1 stream-begin sender-protocol-settings continuation %s' %
-                data[0:5]),
-            ffs(b'0 1 0 sender-protocol-settings eos %s' % data[5:]),
-        ]))
+        results = list(
+            sendframes(
+                reactor,
+                [
+                    ffs(
+                        b'0 1 stream-begin sender-protocol-settings continuation %s'
+                        % data[0:5]
+                    ),
+                    ffs(b'0 1 0 sender-protocol-settings eos %s' % data[5:]),
+                ],
+            )
+        )
 
         self.assertEqual(len(results), 2)
 
@@ -599,13 +786,15 @@
         self.assertaction(results[1], b'wantframe')
 
         self.assertEqual(reactor._state, b'idle')
-        self.assertEqual(reactor._sendersettings[b'contentencodings'],
-                         [b'value1', b'value2'])
+        self.assertEqual(
+            reactor._sendersettings[b'contentencodings'], [b'value1', b'value2']
+        )
 
     def testprotocolsettingsbadcbor(self):
         result = self._sendsingleframe(
             makereactor(),
-            ffs(b'0 1 stream-begin sender-protocol-settings eos badvalue'))
+            ffs(b'0 1 stream-begin sender-protocol-settings eos badvalue'),
+        )
         self.assertaction(result, b'error')
 
     def testprotocolsettingsnoninitial(self):
@@ -618,13 +807,15 @@
         self.assertaction(results[0], b'runcommand')
 
         result = self._sendsingleframe(
-            reactor,
-            ffs(b'0 1 0 sender-protocol-settings eos '))
+            reactor, ffs(b'0 1 0 sender-protocol-settings eos ')
+        )
         self.assertaction(result, b'error')
-        self.assertEqual(result[1], {
-            b'message': b'expected command request frame; got 8',
-        })
+        self.assertEqual(
+            result[1], {b'message': b'expected command request frame; got 8',}
+        )
+
 
 if __name__ == '__main__':
     import silenttestrunner
+
     silenttestrunner.main(__name__)