tests: add all missing b prefixes in reactor tests

Both of these tests now pass on Python 3.

# skip-blame just b prefixes. So many b prefixes.

Differential Revision: https://phab.mercurial-scm.org/D3369

contrib/python3-whitelist

@@ -1,441 +1,443 b''
 test-abort-checkin.t
 test-add.t
 test-addremove-similar.t
 test-addremove.t
 test-amend-subrepo.t
 test-amend.t
 test-ancestor.py
 test-annotate.py
 test-annotate.t
 test-archive-symlinks.t
 test-atomictempfile.py
 test-audit-path.t
 test-audit-subrepo.t
 test-automv.t
 test-backout.t
 test-backwards-remove.t
 test-basic.t
 test-bheads.t
 test-bisect.t
 test-bisect2.t
 test-bisect3.t
 test-blackbox.t
 test-bookmarks-current.t
 test-bookmarks-merge.t
 test-bookmarks-rebase.t
 test-bookmarks-strip.t
 test-bookmarks.t
 test-branch-change.t
 test-branch-option.t
 test-branch-tag-confict.t
 test-branches.t
 test-bundle-phases.t
 test-bundle-type.t
 test-bundle-vs-outgoing.t
 test-bundle2-multiple-changegroups.t
 test-cappedreader.py
 test-casecollision.t
 test-cat.t
 test-censor.t
 test-changelog-exec.t
 test-check-commit.t
 test-check-execute.t
 test-check-module-imports.t
 test-check-pyflakes.t
 test-check-pylint.t
 test-check-shbang.t
 test-children.t
 test-clone-pull-corruption.t
 test-clone-r.t
 test-clone-update-order.t
 test-command-template.t
 test-commit-amend.t
 test-commit-interactive.t
 test-commit-multiple.t
 test-commit-unresolved.t
 test-commit.t
 test-committer.t
 test-completion.t
 test-config-env.py
 test-config.t
 test-conflict.t
 test-confused-revert.t
 test-contrib-check-code.t
 test-contrib-check-commit.t
 test-convert-authormap.t
 test-convert-clonebranches.t
 test-convert-datesort.t
 test-convert-filemap.t
 test-convert-hg-sink.t
 test-convert-hg-source.t
 test-convert-hg-startrev.t
 test-convert-splicemap.t
 test-convert-tagsbranch-topology.t
 test-copy-move-merge.t
 test-copy.t
 test-copytrace-heuristics.t
 test-debugbuilddag.t
 test-debugbundle.t
 test-debugextensions.t
 test-debugindexdot.t
 test-debugrename.t
 test-default-push.t
 test-diff-binary-file.t
 test-diff-change.t
 test-diff-copy-depth.t
 test-diff-hashes.t
 test-diff-ignore-whitespace.t
 test-diff-indent-heuristic.t
 test-diff-issue2761.t
 test-diff-newlines.t
 test-diff-reverse.t
 test-diff-subdir.t
 test-diff-unified.t
 test-diff-upgrade.t
 test-diffdir.t
 test-diffstat.t
 test-directaccess.t
 test-dirstate-backup.t
 test-dirstate-nonnormalset.t
 test-dirstate.t
 test-doctest.py
 test-double-merge.t
 test-drawdag.t
 test-duplicateoptions.py
 test-editor-filename.t
 test-empty-dir.t
 test-empty-file.t
 test-empty-group.t
 test-empty.t
 test-encode.t
 test-encoding-func.py
 test-encoding.t
 test-eol-add.t
 test-eol-clone.t
 test-eol-hook.t
 test-eol-tag.t
 test-eol-update.t
 test-excessive-merge.t
 test-exchange-obsmarkers-case-A1.t
 test-exchange-obsmarkers-case-A2.t
 test-exchange-obsmarkers-case-A3.t
 test-exchange-obsmarkers-case-A4.t
 test-exchange-obsmarkers-case-A5.t
 test-exchange-obsmarkers-case-A6.t
 test-exchange-obsmarkers-case-A7.t
 test-exchange-obsmarkers-case-B1.t
 test-exchange-obsmarkers-case-B2.t
 test-exchange-obsmarkers-case-B3.t
 test-exchange-obsmarkers-case-B4.t
 test-exchange-obsmarkers-case-B5.t
 test-exchange-obsmarkers-case-B6.t
 test-exchange-obsmarkers-case-B7.t
 test-exchange-obsmarkers-case-C1.t
 test-exchange-obsmarkers-case-C2.t
 test-exchange-obsmarkers-case-C3.t
 test-exchange-obsmarkers-case-C4.t
 test-exchange-obsmarkers-case-D1.t
 test-exchange-obsmarkers-case-D2.t
 test-exchange-obsmarkers-case-D3.t
 test-exchange-obsmarkers-case-D4.t
 test-execute-bit.t
 test-export.t
 test-extdiff.t
 test-extra-filelog-entry.t
 test-filebranch.t
 test-fileset-generated.t
 test-flags.t
 test-generaldelta.t
 test-getbundle.t
 test-git-export.t
 test-glog-topological.t
 test-gpg.t
 test-graft.t
 test-hghave.t
 test-hgignore.t
 test-hgk.t
 test-hgweb-bundle.t
 test-hgweb-descend-empties.t
 test-hgweb-empty.t
 test-hgweb-removed.t
 test-histedit-arguments.t
 test-histedit-base.t
 test-histedit-bookmark-motion.t
 test-histedit-commute.t
 test-histedit-drop.t
 test-histedit-edit.t
 test-histedit-fold-non-commute.t
 test-histedit-fold.t
 test-histedit-no-change.t
 test-histedit-non-commute-abort.t
 test-histedit-non-commute.t
 test-histedit-obsolete.t
 test-histedit-outgoing.t
 test-histedit-templates.t
 test-http-branchmap.t
 test-http-bundle1.t
 test-http-clone-r.t
 test-identify.t
 test-import-unknown.t
 test-import.t
 test-imports-checker.t
 test-incoming-outgoing.t
 test-inherit-mode.t
 test-issue1089.t
 test-issue1102.t
 test-issue1175.t
 test-issue1306.t
 test-issue1438.t
 test-issue1502.t
 test-issue1802.t
 test-issue1877.t
 test-issue1993.t
 test-issue2137.t
 test-issue3084.t
 test-issue4074.t
 test-issue522.t
 test-issue586.t
 test-issue612.t
 test-issue619.t
 test-issue660.t
 test-issue672.t
 test-issue842.t
 test-journal-exists.t
 test-journal-share.t
 test-journal.t
 test-largefiles-cache.t
 test-largefiles-misc.t
 test-largefiles-small-disk.t
 test-largefiles-update.t
 test-lfs-largefiles.t
 test-linerange.py
 test-locate.t
 test-lock-badness.t
 test-log-linerange.t
 test-log.t
 test-logexchange.t
 test-lrucachedict.py
 test-mactext.t
 test-mailmap.t
 test-manifest-merging.t
 test-manifest.py
 test-manifest.t
 test-match.py
 test-mdiff.py
 test-merge-changedelete.t
 test-merge-closedheads.t
 test-merge-commit.t
 test-merge-criss-cross.t
 test-merge-default.t
 test-merge-force.t
 test-merge-halt.t
 test-merge-internal-tools-pattern.t
 test-merge-local.t
 test-merge-remove.t
 test-merge-revert.t
 test-merge-revert2.t
 test-merge-subrepos.t
 test-merge-symlinks.t
 test-merge-tools.t
 test-merge-types.t
 test-merge1.t
 test-merge10.t
 test-merge2.t
 test-merge4.t
 test-merge5.t
 test-merge6.t
 test-merge7.t
 test-merge8.t
 test-merge9.t
 test-mq-git.t
 test-mq-header-date.t
 test-mq-header-from.t
 test-mq-merge.t
 test-mq-pull-from-bundle.t
 test-mq-qdelete.t
 test-mq-qdiff.t
 test-mq-qfold.t
 test-mq-qgoto.t
 test-mq-qimport-fail-cleanup.t
 test-mq-qnew.t
 test-mq-qpush-exact.t
 test-mq-qqueue.t
 test-mq-qrefresh-interactive.t
 test-mq-qrefresh-replace-log-message.t
 test-mq-qrefresh.t
 test-mq-qrename.t
 test-mq-qsave.t
 test-mq-safety.t
 test-mq-subrepo.t
 test-mq-symlinks.t
 test-mv-cp-st-diff.t
 test-narrow-archive.t
 test-narrow-clone-no-ellipsis.t
 test-narrow-clone-non-narrow-server.t
 test-narrow-clone-nonlinear.t
 test-narrow-clone.t
 test-narrow-commit.t
 test-narrow-copies.t
 test-narrow-debugcommands.t
 test-narrow-debugrebuilddirstate.t
 test-narrow-exchange-merges.t
 test-narrow-exchange.t
 test-narrow-expanddirstate.t
 test-narrow-merge.t
 test-narrow-patch.t
 test-narrow-patterns.t
 test-narrow-pull.t
 test-narrow-rebase.t
 test-narrow-shallow-merges.t
 test-narrow-shallow.t
 test-narrow-strip.t
 test-narrow-update.t
 test-nested-repo.t
 test-newbranch.t
 test-obshistory.t
 test-obsmarker-template.t
 test-obsmarkers-effectflag.t
 test-obsolete-bundle-strip.t
 test-obsolete-changeset-exchange.t
 test-obsolete-checkheads.t
 test-obsolete-distributed.t
 test-obsolete-tag-cache.t
 test-parents.t
 test-pathconflicts-merge.t
 test-pathconflicts-update.t
 test-pending.t
 test-permissions.t
 test-phases.t
 test-pull-branch.t
 test-pull-http.t
 test-pull-permission.t
 test-pull-pull-corruption.t
 test-pull-r.t
 test-pull-update.t
 test-purge.t
 test-push-checkheads-partial-C1.t
 test-push-checkheads-partial-C2.t
 test-push-checkheads-partial-C3.t
 test-push-checkheads-partial-C4.t
 test-push-checkheads-pruned-B1.t
 test-push-checkheads-pruned-B2.t
 test-push-checkheads-pruned-B3.t
 test-push-checkheads-pruned-B4.t
 test-push-checkheads-pruned-B5.t
 test-push-checkheads-pruned-B6.t
 test-push-checkheads-pruned-B7.t
 test-push-checkheads-pruned-B8.t
 test-push-checkheads-superceed-A1.t
 test-push-checkheads-superceed-A2.t
 test-push-checkheads-superceed-A3.t
 test-push-checkheads-superceed-A4.t
 test-push-checkheads-superceed-A5.t
 test-push-checkheads-superceed-A6.t
 test-push-checkheads-superceed-A7.t
 test-push-checkheads-superceed-A8.t
 test-push-checkheads-unpushed-D1.t
 test-push-checkheads-unpushed-D2.t
 test-push-checkheads-unpushed-D3.t
 test-push-checkheads-unpushed-D4.t
 test-push-checkheads-unpushed-D5.t
 test-push-checkheads-unpushed-D6.t
 test-push-checkheads-unpushed-D7.t
 test-push-http.t
 test-push-warn.t
 test-pushvars.t
 test-rebase-abort.t
 test-rebase-base-flag.t
 test-rebase-bookmarks.t
 test-rebase-brute-force.t
 test-rebase-cache.t
 test-rebase-check-restore.t
 test-rebase-collapse.t
 test-rebase-conflicts.t
 test-rebase-dest.t
 test-rebase-detach.t
 test-rebase-emptycommit.t
 test-rebase-inmemory.t
 test-rebase-interruptions.t
 test-rebase-issue-noparam-single-rev.t
 test-rebase-legacy.t
 test-rebase-mq-skip.t
 test-rebase-mq.t
 test-rebase-named-branches.t
 test-rebase-newancestor.t
 test-rebase-obsolete.t
 test-rebase-parameters.t
 test-rebase-partial.t
 test-rebase-pull.t
 test-rebase-rename.t
 test-rebase-scenario-global.t
 test-rebase-templates.t
 test-rebase-transaction.t
 test-record.t
 test-relink.t
 test-remove.t
 test-rename-after-merge.t
 test-rename-dir-merge.t
 test-rename-merge1.t
 test-rename.t
 test-repair-strip.t
 test-repo-compengines.t
 test-resolve.t
 test-revert-flags.t
 test-revert-unknown.t
 test-revlog-ancestry.py
 test-revlog-group-emptyiter.t
 test-revlog-mmapindex.t
 test-revlog-packentry.t
 test-revset-dirstate-parents.t
 test-revset-outgoing.t
 test-rollback.t
 test-run-tests.py
 test-schemes.t
 test-serve.t
 test-setdiscovery.t
 test-share.t
 test-show-stack.t
 test-show-work.t
 test-show.t
 test-simple-update.t
 test-single-head.t
 test-sparse-clear.t
 test-sparse-import.t
 test-sparse-merges.t
 test-sparse-profiles.t
 test-sparse-requirement.t
 test-sparse-verbose-json.t
 test-ssh-clone-r.t
 test-ssh-proto.t
 test-sshserver.py
 test-stack.t
 test-status-rev.t
 test-status-terse.t
 test-strip-cross.t
 test-strip.t
 test-subrepo-deep-nested-change.t
 test-subrepo-missing.t
 test-subrepo.t
 test-symlinks.t
 test-tag.t
 test-tags.t
 test-template-engine.t
 test-treemanifest.t
 test-unamend.t
 test-uncommit.t
 test-unified-test.t
 test-unrelated-pull.t
 test-up-local-change.t
 test-update-branches.t
 test-update-dest.t
 test-update-issue1456.t
 test-update-names.t
 test-update-reverse.t
 test-upgrade-repo.t
 test-url-rev.t
 test-username-newline.t
 test-verify.t
 test-websub.t
 test-win32text.t
+test-wireproto-clientreactor.py
 test-wireproto-framing.py
+test-wireproto-serverreactor.py
 test-xdg.t

tests/test-wireproto-clientreactor.py

@@ -1,130 +1,130 b''
 from __future__ import absolute_import
 
 import unittest
 
 from mercurial import (
     error,
     wireprotoframing as framing,
 )
 
 ffs = framing.makeframefromhumanstring
 
 def sendframe(reactor, frame):
     """Send a frame bytearray to a reactor."""
     header = framing.parseheader(frame)
     payload = frame[framing.FRAME_HEADER_SIZE:]
     assert len(payload) == header.length
 
     return reactor.onframerecv(framing.frame(header.requestid,
                                              header.streamid,
                                              header.streamflags,
                                              header.typeid,
                                              header.flags,
                                              payload))
 
 class SingleSendTests(unittest.TestCase):
     """A reactor that can only send once rejects subsequent sends."""
     def testbasic(self):
         reactor = framing.clientreactor(hasmultiplesend=False, buffersends=True)
 
         request, action, meta = reactor.callcommand(b'foo', {})
-        self.assertEqual(request.state, 'pending')
-        self.assertEqual(action, 'noop')
+        self.assertEqual(request.state, b'pending')
+        self.assertEqual(action, b'noop')
 
         action, meta = reactor.flushcommands()
-        self.assertEqual(action, 'sendframes')
+        self.assertEqual(action, b'sendframes')
 
-        for frame in meta['framegen']:
-            self.assertEqual(request.state, 'sending')
+        for frame in meta[b'framegen']:
+            self.assertEqual(request.state, b'sending')
 
-        self.assertEqual(request.state, 'sent')
+        self.assertEqual(request.state, b'sent')
 
         with self.assertRaisesRegexp(error.ProgrammingError,
                                      'cannot issue new commands'):
             reactor.callcommand(b'foo', {})
 
         with self.assertRaisesRegexp(error.ProgrammingError,
                                      'cannot issue new commands'):
             reactor.callcommand(b'foo', {})
 
 class NoBufferTests(unittest.TestCase):
     """A reactor without send buffering sends requests immediately."""
     def testbasic(self):
         reactor = framing.clientreactor(hasmultiplesend=True, buffersends=False)
 
         request, action, meta = reactor.callcommand(b'command1', {})
         self.assertEqual(request.requestid, 1)
-        self.assertEqual(action, 'sendframes')
+        self.assertEqual(action, b'sendframes')
 
-        self.assertEqual(request.state, 'pending')
+        self.assertEqual(request.state, b'pending')
 
-        for frame in meta['framegen']:
-            self.assertEqual(request.state, 'sending')
+        for frame in meta[b'framegen']:
+            self.assertEqual(request.state, b'sending')
 
-        self.assertEqual(request.state, 'sent')
+        self.assertEqual(request.state, b'sent')
 
         action, meta = reactor.flushcommands()
-        self.assertEqual(action, 'noop')
+        self.assertEqual(action, b'noop')
 
         # And we can send another command.
         request, action, meta = reactor.callcommand(b'command2', {})
         self.assertEqual(request.requestid, 3)
-        self.assertEqual(action, 'sendframes')
+        self.assertEqual(action, b'sendframes')
 
-        for frame in meta['framegen']:
-            self.assertEqual(request.state, 'sending')
+        for frame in meta[b'framegen']:
+            self.assertEqual(request.state, b'sending')
 
-        self.assertEqual(request.state, 'sent')
+        self.assertEqual(request.state, b'sent')
 
 class BadFrameRecvTests(unittest.TestCase):
     def testoddstream(self):
         reactor = framing.clientreactor()
 
         action, meta = sendframe(reactor, ffs(b'1 1 0 1 0 foo'))
-        self.assertEqual(action, 'error')
-        self.assertEqual(meta['message'],
-                         'received frame with odd numbered stream ID: 1')
+        self.assertEqual(action, b'error')
+        self.assertEqual(meta[b'message'],
+                         b'received frame with odd numbered stream ID: 1')
 
     def testunknownstream(self):
         reactor = framing.clientreactor()
 
         action, meta = sendframe(reactor, ffs(b'1 0 0 1 0 foo'))
-        self.assertEqual(action, 'error')
-        self.assertEqual(meta['message'],
-                         'received frame on unknown stream without beginning '
-                         'of stream flag set')
+        self.assertEqual(action, b'error')
+        self.assertEqual(meta[b'message'],
+                         b'received frame on unknown stream without beginning '
+                         b'of stream flag set')
 
     def testunhandledframetype(self):
         reactor = framing.clientreactor(buffersends=False)
 
         request, action, meta = reactor.callcommand(b'foo', {})
-        for frame in meta['framegen']:
+        for frame in meta[b'framegen']:
             pass
 
         with self.assertRaisesRegexp(error.ProgrammingError,
                                      'unhandled frame type'):
             sendframe(reactor, ffs(b'1 0 stream-begin text-output 0 foo'))
 
 class StreamTests(unittest.TestCase):
     def testmultipleresponseframes(self):
         reactor = framing.clientreactor(buffersends=False)
 
         request, action, meta = reactor.callcommand(b'foo', {})
 
-        self.assertEqual(action, 'sendframes')
-        for f in meta['framegen']:
+        self.assertEqual(action, b'sendframes')
+        for f in meta[b'framegen']:
             pass
 
         action, meta = sendframe(
             reactor,
             ffs(b'%d 0 stream-begin 4 0 foo' % request.requestid))
-        self.assertEqual(action, 'responsedata')
+        self.assertEqual(action, b'responsedata')
 
         action, meta = sendframe(
             reactor,
             ffs(b'%d 0 0 4 eos bar' % request.requestid))
-        self.assertEqual(action, 'responsedata')
+        self.assertEqual(action, b'responsedata')
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)

tests/test-wireproto-serverreactor.py

@@ -1,485 +1,485 b''
 from __future__ import absolute_import, print_function
 
 import unittest
 
 from mercurial.thirdparty import (
     cbor,
 )
 from mercurial import (
     util,
     wireprotoframing as framing,
 )
 
 ffs = framing.makeframefromhumanstring
 
 def makereactor(deferoutput=False):
     return framing.serverreactor(deferoutput=deferoutput)
 
 def sendframes(reactor, gen):
     """Send a generator of frame bytearray to a reactor.
 
     Emits a generator of results from ``onframerecv()`` calls.
     """
     for frame in gen:
         header = framing.parseheader(frame)
         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))
 
 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))
 
 
 class ServerReactorTests(unittest.TestCase):
     def _sendsingleframe(self, reactor, f):
         results = list(sendframes(reactor, [f]))
         self.assertEqual(len(results), 1)
 
         return results[0]
 
     def assertaction(self, res, expected):
         self.assertIsInstance(res, tuple)
         self.assertEqual(len(res), 2)
         self.assertIsInstance(res[1], dict)
         self.assertEqual(res[0], expected)
 
     def assertframesequal(self, frames, framestrings):
         expected = [ffs(s) for s in framestrings]
         self.assertEqual(list(frames), expected)
 
     def test1framecommand(self):
         """Receiving a command in a single frame yields request to run it."""
         reactor = makereactor()
         stream = framing.stream(1)
         results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {}))
         self.assertEqual(len(results), 1)
-        self.assertaction(results[0], 'runcommand')
+        self.assertaction(results[0], b'runcommand')
         self.assertEqual(results[0][1], {
-            'requestid': 1,
-            'command': b'mycommand',
-            'args': {},
-            'data': None,
+            b'requestid': 1,
+            b'command': b'mycommand',
+            b'args': {},
+            b'data': None,
         })
 
         result = reactor.oninputeof()
-        self.assertaction(result, 'noop')
+        self.assertaction(result, b'noop')
 
     def test1argument(self):
         reactor = makereactor()
         stream = framing.stream(1)
         results = list(sendcommandframes(reactor, stream, 41, b'mycommand',
                                          {b'foo': b'bar'}))
         self.assertEqual(len(results), 1)
-        self.assertaction(results[0], 'runcommand')
+        self.assertaction(results[0], b'runcommand')
         self.assertEqual(results[0][1], {
-            'requestid': 41,
-            'command': b'mycommand',
-            'args': {b'foo': b'bar'},
-            'data': None,
+            b'requestid': 41,
+            b'command': b'mycommand',
+            b'args': {b'foo': b'bar'},
+            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'}))
         self.assertEqual(len(results), 1)
-        self.assertaction(results[0], 'runcommand')
+        self.assertaction(results[0], b'runcommand')
         self.assertEqual(results[0][1], {
-            'requestid': 1,
-            'command': b'mycommand',
-            'args': {b'foo': b'bar', b'biz': b'baz'},
-            'data': None,
+            b'requestid': 1,
+            b'command': b'mycommand',
+            b'args': {b'foo': b'bar', b'biz': b'baz'},
+            b'data': None,
         })
 
     def testsimplecommanddata(self):
         reactor = makereactor()
         stream = framing.stream(1)
         results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {},
                                          util.bytesio(b'data!')))
         self.assertEqual(len(results), 2)
-        self.assertaction(results[0], 'wantframe')
-        self.assertaction(results[1], 'runcommand')
+        self.assertaction(results[0], b'wantframe')
+        self.assertaction(results[1], b'runcommand')
         self.assertEqual(results[1][1], {
-            'requestid': 1,
-            'command': b'mycommand',
-            'args': {},
-            'data': b'data!',
+            b'requestid': 1,
+            b'command': b'mycommand',
+            b'args': {},
+            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 0 command-data continuation data1'),
             ffs(b'1 1 0 command-data continuation data2'),
             ffs(b'1 1 0 command-data eos data3'),
         ]
 
         reactor = makereactor()
         results = list(sendframes(reactor, frames))
         self.assertEqual(len(results), 4)
         for i in range(3):
-            self.assertaction(results[i], 'wantframe')
-        self.assertaction(results[3], 'runcommand')
+            self.assertaction(results[i], b'wantframe')
+        self.assertaction(results[3], b'runcommand')
         self.assertEqual(results[3][1], {
-            'requestid': 1,
-            'command': b'mycommand',
-            'args': {},
-            'data': b'data1data2data3',
+            b'requestid': 1,
+            b'command': b'mycommand',
+            b'args': {},
+            b'data': b'data1data2data3',
         })
 
     def testargumentanddata(self):
         frames = [
             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'}}"),
             ffs(b'1 1 0 command-data continuation value1'),
             ffs(b'1 1 0 command-data eos value2'),
         ]
 
         reactor = makereactor()
         results = list(sendframes(reactor, frames))
 
-        self.assertaction(results[-1], 'runcommand')
+        self.assertaction(results[-1], b'runcommand')
         self.assertEqual(results[-1][1], {
-            'requestid': 1,
-            'command': b'command',
-            'args': {
+            b'requestid': 1,
+            b'command': b'command',
+            b'args': {
                 b'key': b'val',
                 b'foo': b'bar',
             },
-            'data': b'value1value2',
+            b'data': b'value1value2',
         })
 
     def testnewandcontinuation(self):
         result = self._sendsingleframe(makereactor(),
             ffs(b'1 1 stream-begin command-request new|continuation '))
-        self.assertaction(result, 'error')
+        self.assertaction(result, b'error')
         self.assertEqual(result[1], {
-            'message': b'received command request frame with both new and '
+            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 '))
-        self.assertaction(result, 'error')
+        self.assertaction(result, b'error')
         self.assertEqual(result[1], {
-            'message': b'received command request frame with neither new nor '
+            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'))
-        self.assertaction(result, 'error')
+        self.assertaction(result, b'error')
         self.assertEqual(result[1], {
-            'message': b'expected command request frame; got 3',
+            b'message': b'expected command request frame; got 3',
         })
 
     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'),
         ]))
 
-        self.assertaction(results[0], 'wantframe')
-        self.assertaction(results[1], 'error')
+        self.assertaction(results[0], b'wantframe')
+        self.assertaction(results[1], b'error')
         self.assertEqual(results[1][1], {
-            'message': b'received command data frame for request that is not '
+            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'}")))
         result = reactor.onbytesresponseready(outstream, 1, b'response1')
-        self.assertaction(result, 'sendframes')
-        list(result[1]['framegen'])
+        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'}")))
         result = reactor.onbytesresponseready(outstream, 1, b'response2')
-        self.assertaction(result, 'sendframes')
-        list(result[1]['framegen'])
+        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'}")))
         result = reactor.onbytesresponseready(outstream, 1, b'response3')
-        self.assertaction(result, 'sendframes')
-        list(result[1]['framegen'])
+        self.assertaction(result, b'sendframes')
+        list(result[1][b'framegen'])
 
         for i in range(3):
-            self.assertaction(results[i], 'runcommand')
+            self.assertaction(results[i], b'runcommand')
             self.assertEqual(results[i][1], {
-                'requestid': 1,
-                'command': b'command',
-                'args': {},
-                'data': None,
+                b'requestid': 1,
+                b'command': b'command',
+                b'args': {},
+                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'}"),
         ]))
 
-        self.assertaction(results[0], 'wantframe')
-        self.assertaction(results[1], 'error')
+        self.assertaction(results[0], b'wantframe')
+        self.assertaction(results[1], b'error')
         self.assertEqual(results[1][1], {
-            'message': b'request with ID 1 already received',
+            b'message': b'request with ID 1 already received',
         })
 
     def testinterleavedcommands(self):
         cbor1 = cbor.dumps({
             b'name': b'command1',
             b'args': {
                 b'foo': b'bar',
                 b'key1': b'val',
             }
         }, canonical=True)
         cbor3 = cbor.dumps({
             b'name': b'command3',
             b'args': {
                 b'biz': b'baz',
                 b'key': b'val',
             },
         }, canonical=True)
 
         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([t[0] for t in results], [
-            'wantframe',
-            'wantframe',
-            'wantframe',
-            'wantframe',
-            'runcommand',
-            'runcommand',
+            b'wantframe',
+            b'wantframe',
+            b'wantframe',
+            b'wantframe',
+            b'runcommand',
+            b'runcommand',
         ])
 
         self.assertEqual(results[4][1], {
-            'requestid': 3,
-            'command': 'command3',
-            'args': {b'biz': b'baz', b'key': b'val'},
-            'data': None,
+            b'requestid': 3,
+            b'command': b'command3',
+            b'args': {b'biz': b'baz', b'key': b'val'},
+            b'data': None,
         })
         self.assertEqual(results[5][1], {
-            'requestid': 1,
-            'command': 'command1',
-            'args': {b'foo': b'bar', b'key1': b'val'},
-            'data': None,
+            b'requestid': 1,
+            b'command': b'command1',
+            b'args': {b'foo': b'bar', b'key1': b'val'},
+            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'}"),
         ]
         results = list(sendframes(makereactor(), frames))
         self.assertEqual(len(results), 2)
-        self.assertaction(results[0], 'wantframe')
-        self.assertaction(results[1], 'runcommand')
+        self.assertaction(results[0], b'wantframe')
+        self.assertaction(results[1], b'runcommand')
 
     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 0 command-data 0 data'),
         ]
         results = list(sendframes(makereactor(), frames))
         self.assertEqual(len(results), 2)
-        self.assertaction(results[0], 'wantframe')
-        self.assertaction(results[1], 'error')
+        self.assertaction(results[0], b'wantframe')
+        self.assertaction(results[1], b'error')
         self.assertEqual(results[1][1], {
-            'message': b'command data frame without flags',
+            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'),
         ]))
-        self.assertaction(results[2], 'error')
+        self.assertaction(results[2], b'error')
         self.assertEqual(results[2][1], {
-            'message': b'received frame for request that is not receiving: 5',
+            b'message': b'received frame for request that is not receiving: 5',
         })
 
     def testsimpleresponse(self):
         """Bytes response to command sends result frames."""
         reactor = makereactor()
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
 
         outstream = reactor.makeoutputstream()
         result = reactor.onbytesresponseready(outstream, 1, b'response')
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'1 2 stream-begin bytes-response eos response',
         ])
 
     def testmultiframeresponse(self):
         """Bytes response spanning multiple frames is handled."""
         first = b'x' * framing.DEFAULT_MAX_FRAME_SIZE
         second = b'y' * 100
 
         reactor = makereactor()
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
 
         outstream = reactor.makeoutputstream()
         result = reactor.onbytesresponseready(outstream, 1, first + second)
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'1 2 stream-begin bytes-response continuation %s' % first,
             b'1 2 0 bytes-response eos %s' % second,
         ])
 
     def testapplicationerror(self):
         reactor = makereactor()
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
 
         outstream = reactor.makeoutputstream()
         result = reactor.onapplicationerror(outstream, 1, b'some message')
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'1 2 stream-begin error-response application 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',
                                          {}))
         self.assertEqual(len(results), 1)
-        self.assertaction(results[0], 'runcommand')
+        self.assertaction(results[0], b'runcommand')
 
         outstream = reactor.makeoutputstream()
         result = reactor.onbytesresponseready(outstream, 1, b'response')
-        self.assertaction(result, 'noop')
+        self.assertaction(result, b'noop')
         result = reactor.oninputeof()
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'1 2 stream-begin bytes-response eos response',
         ])
 
     def testmultiplecommanddeferresponse(self):
         reactor = makereactor(deferoutput=True)
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'command1', {}))
         list(sendcommandframes(reactor, instream, 3, b'command2', {}))
 
         outstream = reactor.makeoutputstream()
         result = reactor.onbytesresponseready(outstream, 1, b'response1')
-        self.assertaction(result, 'noop')
+        self.assertaction(result, b'noop')
         result = reactor.onbytesresponseready(outstream, 3, b'response2')
-        self.assertaction(result, 'noop')
+        self.assertaction(result, b'noop')
         result = reactor.oninputeof()
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'1 2 stream-begin bytes-response eos response1',
             b'3 2 0 bytes-response eos response2'
         ])
 
     def testrequestidtracking(self):
         reactor = makereactor(deferoutput=True)
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'command1', {}))
         list(sendcommandframes(reactor, instream, 3, b'command2', {}))
         list(sendcommandframes(reactor, instream, 5, b'command3', {}))
 
         # Register results for commands out of order.
         outstream = reactor.makeoutputstream()
         reactor.onbytesresponseready(outstream, 3, b'response3')
         reactor.onbytesresponseready(outstream, 1, b'response1')
         reactor.onbytesresponseready(outstream, 5, b'response5')
 
         result = reactor.oninputeof()
-        self.assertaction(result, 'sendframes')
-        self.assertframesequal(result[1]['framegen'], [
+        self.assertaction(result, b'sendframes')
+        self.assertframesequal(result[1][b'framegen'], [
             b'3 2 stream-begin bytes-response eos response3',
             b'1 2 0 bytes-response eos response1',
             b'5 2 0 bytes-response eos response5',
         ])
 
     def testduplicaterequestonactivecommand(self):
         """Receiving a request ID that matches a request that isn't finished."""
         reactor = makereactor()
         stream = framing.stream(1)
         list(sendcommandframes(reactor, stream, 1, b'command1', {}))
         results = list(sendcommandframes(reactor, stream, 1, b'command1', {}))
 
-        self.assertaction(results[0], 'error')
+        self.assertaction(results[0], b'error')
         self.assertEqual(results[0][1], {
-            'message': b'request with ID 1 is already active',
+            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."""
         reactor = makereactor()
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'command1', {}))
         outstream = reactor.makeoutputstream()
         reactor.onbytesresponseready(outstream, 1, b'response')
 
         # We've registered the response but haven't sent it. From the
         # perspective of the reactor, the command is still active.
 
         results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
-        self.assertaction(results[0], 'error')
+        self.assertaction(results[0], b'error')
         self.assertEqual(results[0][1], {
-            'message': b'request with ID 1 is already active',
+            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."""
         reactor = makereactor()
         instream = framing.stream(1)
         list(sendcommandframes(reactor, instream, 1, b'command1', {}))
         outstream = reactor.makeoutputstream()
         res = reactor.onbytesresponseready(outstream, 1, b'response')
-        list(res[1]['framegen'])
+        list(res[1][b'framegen'])
 
         results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
-        self.assertaction(results[0], 'runcommand')
+        self.assertaction(results[0], b'runcommand')
 
 if __name__ == '__main__':
     import silenttestrunner
     silenttestrunner.main(__name__)