Port to current version of escpos-printer-db.

src/escpos/capabilities.py

@@ -7,8 +7,9 @@ import yaml
 # Load external printer database
 with open(path.join(path.dirname(__file__), 'capabilities.json')) as f:
     CAPABILITIES = yaml.load(f)
+
 PROFILES = CAPABILITIES['profiles']
-ENCODINGS = CAPABILITIES['encodings']
+
 
 
 class NotSupported(Exception):
@@ -51,6 +52,12 @@ class BaseProfile(object):
         """
         return self.features.get(feature)
 
+    def get_code_pages(self):
+        """Return the support code pages as a {name: index} dict.
+        """
+        return {v.lower(): k for k, v in self.codePages.items()}
+
+
 
 def get_profile(name=None, **kwargs):
     """Get the profile by name; if no name is given, return the

src/escpos/codepages.py

@@ -0,0 +1,32 @@
+from .capabilities import CAPABILITIES
+
+
+class CodePageManager:
+    """Holds information about all the code pages (as defined
+    in escpos-printer-db).
+    """
+
+    def __init__(self, data):
+        self.data = data
+
+    def get_all(self):
+        return self.data.values()
+
+    def encode(self, text, encoding, errors='strict'):
+        """Adds support for Japanese to the builtin str.encode().
+
+        TODO: Add support for custom code page data from
+        escpos-printer-db.
+        """
+        # Python has not have this builtin?
+        if encoding.upper() == 'KATAKANA':
+            return encode_katakana(text)
+
+        return text.encode(encoding, errors=errors)
+
+    def get_encoding(self, encoding):
+        # resolve the encoding alias
+        return encoding.lower()
+
+
+CodePages = CodePageManager(CAPABILITIES['encodings'])

src/escpos/constants.py

@@ -123,101 +123,9 @@ LINESPACING_FUNCS = {
   180: ESC + b'3', # line_spacing/180 of an inch, 0 <= line_spacing <= 255
 }
 
-
+# Prefix to change the codepage. You need to attach a byte to indicate
+# the codepage to use. We use escpos-printer-db as the data source.
 CODEPAGE_CHANGE = ESC + b'\x74'
-# Char code table
-# CHARCODE = {
-#     'PC437':
-#         [ESC + b'\x74\x00', 'cp437'],  # PC437 USA
-#     'KATAKANA':
-#         [ESC + b'\x74\x01', ''],  # KATAKANA (JAPAN)
-#     'PC850':
-#         [ESC + b'\x74\x02', 'cp850'],  # PC850 Multilingual
-#     'PC860':
-#         [ESC + b'\x74\x03', 'cp860'],  # PC860 Portuguese
-#     'PC863':
-#         [ESC + b'\x74\x04', 'cp863'],  # PC863 Canadian-French
-#     'PC865':
-#         [ESC + b'\x74\x05', 'cp865'],  # PC865 Nordic
-#     'KANJI6':
-#         [ESC + b'\x74\x06', ''],  # One-pass Kanji, Hiragana
-#     'KANJI7':
-#         [ESC + b'\x74\x07', ''],  # One-pass Kanji
-#     'KANJI8':
-#         [ESC + b'\x74\x08', ''],  # One-pass Kanji
-#     'PC851':
-#         [ESC + b'\x74\x0b', 'cp851'],  # PC851 Greek
-#     'PC853':
-#         [ESC + b'\x74\x0c', 'cp853'],  # PC853 Turkish
-#     'PC857':
-#         [ESC + b'\x74\x0d', 'cp857'],  # PC857 Turkish
-#     'PC737':
-#         [ESC + b'\x74\x0e', 'cp737'],  # PC737 Greek
-#     '8859_7':
-#         [ESC + b'\x74\x0f', 'iso8859_7'],  # ISO8859-7 Greek
-#     'WPC1252':
-#         [ESC + b'\x74\x10', 'cp1252'],  # WPC1252
-#     'PC866':
-#         [ESC + b'\x74\x11', 'cp866'],  # PC866 Cyrillic #2
-#     'PC852':
-#         [ESC + b'\x74\x12', 'cp852'],  # PC852 Latin2
-#     'PC858':
-#         [ESC + b'\x74\x13', 'cp858'],  # PC858 Euro
-#     'KU42':
-#         [ESC + b'\x74\x14', ''],  # KU42 Thai
-#     'TIS11':
-#         [ESC + b'\x74\x15', ''],  # TIS11 Thai
-#     'TIS18':
-#         [ESC + b'\x74\x1a', ''],  # TIS18 Thai
-#     'TCVN3':
-#         [ESC + b'\x74\x1e', ''],  # TCVN3 Vietnamese
-#     'TCVN3B':
-#         [ESC + b'\x74\x1f', ''],  # TCVN3 Vietnamese
-#     'PC720':
-#         [ESC + b'\x74\x20', 'cp720'],  # PC720 Arabic
-#     'WPC775':
-#         [ESC + b'\x74\x21', ''],  # WPC775 Baltic Rim
-#     'PC855':
-#         [ESC + b'\x74\x22', 'cp855'],  # PC855 Cyrillic
-#     'PC861':
-#         [ESC + b'\x74\x23', 'cp861'],  # PC861 Icelandic
-#     'PC862':
-#         [ESC + b'\x74\x24', 'cp862'],  # PC862 Hebrew
-#     'PC864':
-#         [ESC + b'\x74\x25', 'cp864'],  # PC864 Arabic
-#     'PC869':
-#         [ESC + b'\x74\x26', 'cp869'],  # PC869 Greek
-#     '8859_2':
-#         [ESC + b'\x74\x27', 'iso8859_2'],  # ISO8859-2 Latin2
-#     '8859_9':
-#         [ESC + b'\x74\x28', 'iso8859_9'],  # ISO8859-2 Latin9
-#     'PC1098':
-#         [ESC + b'\x74\x29', 'cp1098'],  # PC1098 Farsi
-#     'PC1118':
-#         [ESC + b'\x74\x2a', 'cp1118'],  # PC1118 Lithuanian
-#     'PC1119':
-#         [ESC + b'\x74\x2b', 'cp1119'],  # PC1119 Lithuanian
-#     'PC1125':
-#         [ESC + b'\x74\x2c', 'cp1125'],  # PC1125 Ukrainian
-#     'WPC1250':
-#         [ESC + b'\x74\x2d', 'cp1250'],  # WPC1250 Latin2
-#     'WPC1251':
-#         [ESC + b'\x74\x2e', 'cp1251'],  # WPC1251 Cyrillic
-#     'WPC1253':
-#         [ESC + b'\x74\x2f', 'cp1253'],  # WPC1253 Greek
-#     'WPC1254':
-#         [ESC + b'\x74\x30', 'cp1254'],  # WPC1254 Turkish
-#     'WPC1255':
-#         [ESC + b'\x74\x31', 'cp1255'],  # WPC1255 Hebrew
-#     'WPC1256':
-#         [ESC + b'\x74\x32', 'cp1256'],  # WPC1256 Arabic
-#     'WPC1257':
-#         [ESC + b'\x74\x33', 'cp1257'],  # WPC1257 Baltic Rim
-#     'WPC1258':
-#         [ESC + b'\x74\x34', 'cp1258'],  # WPC1258 Vietnamese
-#     'KZ1048':
-#         [ESC + b'\x74\x35', 'kz1048'],  # KZ-1048 Kazakhstan
-# }
 
 # Barcode format
 _SET_BARCODE_TXT_POS = lambda n: GS + b'H' + n

src/escpos/katakana.py

@@ -0,0 +1,104 @@
+#  -*- coding: utf-8 -*-
+"""Helpers to encode Japanese characters.
+
+I doubt that this currently works correctly.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+
+try:
+    import jcconv
+except ImportError:
+    jcconv = None
+
+
+def encode_katakana(text):
+    """I don't think this quite works yet."""
+    encoded = []
+    for char in text:
+        if jcconv:
+            # try to convert japanese text to half-katakanas
+            char = jcconv.kata2half(jcconv.hira2kata(char))
+            # TODO: "the conversion may result in multiple characters"
+            # When? What should we do about it?
+
+        if char in TXT_ENC_KATAKANA_MAP:
+            encoded.append(TXT_ENC_KATAKANA_MAP[char])
+        else:
+            pass
+    return b"".join(encoded)
+
+
+
+TXT_ENC_KATAKANA_MAP = {
+    # Maps UTF-8 Katakana symbols to KATAKANA Page Codes
+
+    # Half-Width Katakanas
+    '｡': b'\xa1',
+    '｢': b'\xa2',
+    '｣': b'\xa3',
+    '､': b'\xa4',
+    '･': b'\xa5',
+    'ｦ': b'\xa6',
+    'ｧ': b'\xa7',
+    'ｨ': b'\xa8',
+    'ｩ': b'\xa9',
+    'ｪ': b'\xaa',
+    'ｫ': b'\xab',
+    'ｬ': b'\xac',
+    'ｭ': b'\xad',
+    'ｮ': b'\xae',
+    'ｯ': b'\xaf',
+    'ｰ': b'\xb0',
+    'ｱ': b'\xb1',
+    'ｲ': b'\xb2',
+    'ｳ': b'\xb3',
+    'ｴ': b'\xb4',
+    'ｵ': b'\xb5',
+    'ｶ': b'\xb6',
+    'ｷ': b'\xb7',
+    'ｸ': b'\xb8',
+    'ｹ': b'\xb9',
+    'ｺ': b'\xba',
+    'ｻ': b'\xbb',
+    'ｼ': b'\xbc',
+    'ｽ': b'\xbd',
+    'ｾ': b'\xbe',
+    'ｿ': b'\xbf',
+    'ﾀ': b'\xc0',
+    'ﾁ': b'\xc1',
+    'ﾂ': b'\xc2',
+    'ﾃ': b'\xc3',
+    'ﾄ': b'\xc4',
+    'ﾅ': b'\xc5',
+    'ﾆ': b'\xc6',
+    'ﾇ': b'\xc7',
+    'ﾈ': b'\xc8',
+    'ﾉ': b'\xc9',
+    'ﾊ': b'\xca',
+    'ﾋ': b'\xcb',
+    'ﾌ': b'\xcc',
+    'ﾍ': b'\xcd',
+    'ﾎ': b'\xce',
+    'ﾏ': b'\xcf',
+    'ﾐ': b'\xd0',
+    'ﾑ': b'\xd1',
+    'ﾒ': b'\xd2',
+    'ﾓ': b'\xd3',
+    'ﾔ': b'\xd4',
+    'ﾕ': b'\xd5',
+    'ﾖ': b'\xd6',
+    'ﾗ': b'\xd7',
+    'ﾘ': b'\xd8',
+    'ﾙ': b'\xd9',
+    'ﾚ': b'\xda',
+    'ﾛ': b'\xdb',
+    'ﾜ': b'\xdc',
+    'ﾝ': b'\xdd',
+    'ﾞ': b'\xde',
+    'ﾟ': b'\xdf',
+}

src/escpos/magicencode.py

@@ -20,68 +20,16 @@ from __future__ import unicode_literals
 from .constants import CODEPAGE_CHANGE
 from .exceptions import CharCodeError, Error
 from .capabilities import get_profile
+from .codepages import CodePages
 import copy
 import six
 
-try:
-    import jcconv
-except ImportError:
-    jcconv = None
-
-
-def encode_katakana(text):
-    """I don't think this quite works yet."""
-    encoded = []
-    for char in text:
-        if jcconv:
-            # try to convert japanese text to half-katakanas
-            char = jcconv.kata2half(jcconv.hira2kata(char))
-            # TODO: "the conversion may result in multiple characters"
-            # When? What should we do about it?
-
-        if char in TXT_ENC_KATAKANA_MAP:
-            encoded.append(TXT_ENC_KATAKANA_MAP[char])
-        else:
-            encoded.append(char)
-    print(encoded)
-    return b"".join(encoded)
-
-
-
-# TODO: When the capabilities.yml format is finished, this should be
-# in the profile itself.
-def get_encodings_from_profile(profile):
-    mapping = {k: v.lower() for k, v in profile.codePageMap.items()}
-    if hasattr(profile, 'codePages'):
-        code_pages = [n.lower() for n in profile.codePages]
-        return {k: v for k, v in mapping.items() if v in code_pages}
-    else:
-        return mapping
-
-
-class CodePages:
-    def get_all(self):
-        return get_encodings_from_profile(get_profile()).values()
-
-    def encode(self, text, encoding, errors='strict'):
-        # Python has not have this builtin?
-        if encoding.upper() == 'KATAKANA':
-            return encode_katakana(text)
-
-        return text.encode(encoding, errors=errors)
-
-    def get_encoding(self, encoding):
-        # resolve the encoding alias
-        return encoding.lower()
-
-code_pages = CodePages()
-
 
 class Encoder(object):
     """Takes a list of available code spaces. Picks the right one for a
     given character.
 
-    Note: To determine the codespace, it needs to do the conversion, and
+    Note: To determine the code page, it needs to do the conversion, and
     thus already knows what the final byte in the target encoding would
     be. Nevertheless, the API of this class doesn't return the byte.
 
@@ -94,36 +42,32 @@ class Encoder(object):
         100000000 loops, best of 3: 0.0141 usec per loop
     """
 
-    def __init__(self, codepages):
+    def __init__(self, codepage_map):
-        self.codepages = codepages
+        self.codepages = codepage_map
-        self.reverse = {v:k for k, v in codepages.items()}
+        self.available_encodings = set(codepage_map.keys())
-        self.available_encodings = set(codepages.values())
         self.used_encodings = set()
 
     def get_sequence(self, encoding):
-        return self.reverse[encoding]
+        return int(self.codepages[encoding])
 
     def get_encoding(self, encoding):
-        """resolve aliases
+        """Given an encoding provided by the user, will return a
+        canonical encoding name; and also validate that the encoding
+        is supported.
 
-        check that the profile allows this encoding
+        TOOD: Support encoding aliases.
         """
-        encoding = code_pages.get_encoding(encoding)
+        encoding = CodePages.get_encoding(encoding)
-        if not encoding in self.available_encodings:
+        if not encoding in self.codepages:
-            raise ValueError('This encoding cannot be used for the current profile')
+            raise ValueError((
+                    'Encoding "{}" cannot be used for the current profile. '
+                    'Valid encodings are: {}'
+                ).format(encoding, ','.join(self.codepages.keys())))
         return encoding
 
-    def get_encodings(self):
-        """
-        - remove the ones not supported
-        - order by used first, then others
-        - do not use a cache, because encode already is so fast
-        """
-        return self.available_encodings
-
     def can_encode(self, encoding, char):
         try:
-            encoded = code_pages.encode(char, encoding)
+            encoded = CodePages.encode(char, encoding)
             assert type(encoded) is bytes
             return encoded
         except LookupError:
@@ -134,7 +78,7 @@ class Encoder(object):
 
         return True
 
-    def find_suitable_codespace(self, char):
+    def find_suitable_encoding(self, char):
         """The order of our search is a specific one:
 
         1. code pages that we already tried before; there is a good
@@ -150,9 +94,16 @@ class Encoder(object):
            that the code page we pick for this character is actually
            supported.
 
-        # XXX actually do speed up the search
+        # TODO actually do speed up the search
         """
-        for encoding in self.get_encodings():
+        """
+        - remove the ones not supported
+        - order by used first, then others
+        - do not use a cache, because encode already is so fast
+        """
+        sorted_encodings = self.codepages.keys()
+
+        for encoding in sorted_encodings:
             if self.can_encode(encoding, char):
                 # This encoding worked; at it to the set of used ones.
                 self.used_encodings.add(encoding)
@@ -160,14 +111,20 @@ class Encoder(object):
 
 
 class MagicEncode(object):
-    """ Magic Encode Class
+    """A helper that helps us to automatically switch to the right
+    code page to encode any given Unicode character.
 
-    It tries to automatically encode utf-8 input into the right coding. When encoding is impossible a configurable
+    This will consider the printers supported codepages, according
-    symbol will be inserted.
+    to the printer profile, and if a character cannot be encoded
+    with the current profile, it will attempt to find a suitable one.
 
-    encoding: If you know the current encoding of the printer when
+    If the printer does not support a suitable code page, it can
-    initializing this class, set it here. If the current encoding is
+    insert an error character.
-    unknown, the first character emitted will be a codepage switch.
+
+    :param encoding: If you know the current encoding of the printer
+        when initializing this class, set it here. If the current
+        encoding is unknown, the first character emitted will be a
+        codepage switch.
     """
     def __init__(self, driver, encoding=None, disabled=False,
                  defaultsymbol='?', encoder=None):
@@ -175,7 +132,7 @@ class MagicEncode(object):
             raise Error('If you disable magic encode, you need to define an encoding!')
 
         self.driver = driver
-        self.encoder = encoder or Encoder(get_encodings_from_profile(driver.profile))
+        self.encoder = encoder or Encoder(driver.profile.get_code_pages())
 
         self.encoding = self.encoder.get_encoding(encoding) if encoding else None
         self.defaultsymbol = defaultsymbol
@@ -219,12 +176,12 @@ class MagicEncode(object):
             # We have to find another way to print this character.
             # See if any of the code pages that the printer profile supports
             # can encode this character.
-            codespace = self.encoder.find_suitable_codespace(char)
+            encoding = self.encoder.find_suitable_encoding(char)
-            if not codespace:
+            if not encoding:
                 self._handle_character_failed(char)
                 continue
 
-            self.write_with_encoding(codespace, char)
+            self.write_with_encoding(encoding, char)
 
     def _handle_character_failed(self, char):
         """Called when no codepage was found to render a character.
@@ -239,8 +196,6 @@ class MagicEncode(object):
                 type=type(text)
             ))
 
-        encoding = self.encoder.get_encoding(encoding)
-
         # We always know the current code page; if the new codepage
         # is different, emit a change command.
         if encoding != self.encoding:
@@ -251,78 +206,4 @@ class MagicEncode(object):
             ))
 
         if text:
-            self.driver._raw(code_pages.encode(text, encoding, errors="replace"))
+            self.driver._raw(CodePages.encode(text, encoding, errors="replace"))
-
-
-# todo emoticons mit charmap encoden
-# todo Escpos liste von unterdrückten charcodes mitgeben
-# TODO Sichtbarkeit der Methode anpassen (Eigentlich braucht man nur die set_encode und die encode_text)
-
-TXT_ENC_KATAKANA_MAP = {
-    # Maps UTF-8 Katakana symbols to KATAKANA Page Codes
-
-    # Half-Width Katakanas
-    '｡': b'\xa1',
-    '｢': b'\xa2',
-    '｣': b'\xa3',
-    '､': b'\xa4',
-    '･': b'\xa5',
-    'ｦ': b'\xa6',
-    'ｧ': b'\xa7',
-    'ｨ': b'\xa8',
-    'ｩ': b'\xa9',
-    'ｪ': b'\xaa',
-    'ｫ': b'\xab',
-    'ｬ': b'\xac',
-    'ｭ': b'\xad',
-    'ｮ': b'\xae',
-    'ｯ': b'\xaf',
-    'ｰ': b'\xb0',
-    'ｱ': b'\xb1',
-    'ｲ': b'\xb2',
-    'ｳ': b'\xb3',
-    'ｴ': b'\xb4',
-    'ｵ': b'\xb5',
-    'ｶ': b'\xb6',
-    'ｷ': b'\xb7',
-    'ｸ': b'\xb8',
-    'ｹ': b'\xb9',
-    'ｺ': b'\xba',
-    'ｻ': b'\xbb',
-    'ｼ': b'\xbc',
-    'ｽ': b'\xbd',
-    'ｾ': b'\xbe',
-    'ｿ': b'\xbf',
-    'ﾀ': b'\xc0',
-    'ﾁ': b'\xc1',
-    'ﾂ': b'\xc2',
-    'ﾃ': b'\xc3',
-    'ﾄ': b'\xc4',
-    'ﾅ': b'\xc5',
-    'ﾆ': b'\xc6',
-    'ﾇ': b'\xc7',
-    'ﾈ': b'\xc8',
-    'ﾉ': b'\xc9',
-    'ﾊ': b'\xca',
-    'ﾋ': b'\xcb',
-    'ﾌ': b'\xcc',
-    'ﾍ': b'\xcd',
-    'ﾎ': b'\xce',
-    'ﾏ': b'\xcf',
-    'ﾐ': b'\xd0',
-    'ﾑ': b'\xd1',
-    'ﾒ': b'\xd2',
-    'ﾓ': b'\xd3',
-    'ﾔ': b'\xd4',
-    'ﾕ': b'\xd5',
-    'ﾖ': b'\xd6',
-    'ﾗ': b'\xd7',
-    'ﾘ': b'\xd8',
-    'ﾙ': b'\xd9',
-    'ﾚ': b'\xda',
-    'ﾛ': b'\xdb',
-    'ﾜ': b'\xdc',
-    'ﾝ': b'\xdd',
-    'ﾞ': b'\xde',
-    'ﾟ': b'\xdf',
-}

test/test_function_text.py

@@ -12,23 +12,29 @@ from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
 
+import pytest
 import mock
-from hypothesis import given
+from hypothesis import given, assume
 import hypothesis.strategies as st
 from escpos.printer import Dummy
 
 
+def get_printer():
+    return Dummy(magic_encode_args={'disabled': True, 'encoding': 'cp437'})
+
+
 @given(text=st.text())
-def test_function_text_dies_ist_ein_test_lf(text):
+def test_text(text):
-    """test the text printing function with simple string and compare output"""
+    """Test that text() calls the MagicEncode object.
-    instance = Dummy()
+    """
-    instance.magic.encode_text = mock.Mock()
+    instance = get_printer()
+    instance.magic.write = mock.Mock()
     instance.text(text)
-    instance.magic.encode_text.assert_called_with(txt=text)
+    instance.magic.write.assert_called_with(text)
 
 
 def test_block_text():
-    printer = Dummy()
+    printer = get_printer()
     printer.block_text(
         "All the presidents men were eating falafel for breakfast.", font='a')
     assert printer.output == \

test/test_magicencode.py

@@ -17,7 +17,8 @@ import pytest
 from nose.tools import raises, assert_raises
 from hypothesis import given, example
 import hypothesis.strategies as st
-from escpos.magicencode import MagicEncode, Encoder, encode_katakana
+from escpos.magicencode import MagicEncode, Encoder
+from escpos.katakana import encode_katakana
 from escpos.exceptions import CharCodeError, Error
 
 
@@ -25,13 +26,13 @@ from escpos.exceptions import CharCodeError, Error
 class TestEncoder:
 
     def test_can_encode(self):
-        assert not Encoder({1: 'cp437'}).can_encode('cp437', u'€')
+        assert not Encoder({'cp437': 1}).can_encode('cp437', u'€')
-        assert Encoder({1: 'cp437'}).can_encode('cp437', u'á')
+        assert Encoder({'cp437': 1}).can_encode('cp437', u'á')
-        assert not Encoder({1: 'foobar'}).can_encode('foobar', 'a')
+        assert not Encoder({'foobar': 1}).can_encode('foobar', 'a')
 
     def test_find_suitable_encoding(self):
-        assert not Encoder({1: 'cp437'}).find_suitable_codespace(u'€')
+        assert not Encoder({'cp437': 1}).find_suitable_encoding(u'€')
-        assert Encoder({1: 'cp858'}).find_suitable_codespace(u'€') == 'cp858'
+        assert Encoder({'cp858': 1}).find_suitable_encoding(u'€') == 'cp858'
 
     @raises(ValueError)
     def test_get_encoding(self):
@@ -51,12 +52,12 @@ class TestMagicEncode:
         def test_init_from_none(self, driver):
             encode = MagicEncode(driver, encoding=None)
             encode.write_with_encoding('cp858', '€ ist teuro.')
-            assert driver.output == b'\x1bt\xd5 ist teuro.'
+            assert driver.output == b'\x1bt\x13\xd5 ist teuro.'
 
         def test_change_from_another(self, driver):
             encode = MagicEncode(driver, encoding='cp437')
             encode.write_with_encoding('cp858', '€ ist teuro.')
-            assert driver.output == b'\x1bt\xd5 ist teuro.'
+            assert driver.output == b'\x1bt\x13\xd5 ist teuro.'
 
         def test_no_change(self, driver):
             encode = MagicEncode(driver, encoding='cp858')
@@ -68,7 +69,7 @@ class TestMagicEncode:
         def test_write(self, driver):
             encode = MagicEncode(driver)
             encode.write('€ ist teuro.')
-            assert driver.output == b'\x1bt\xa4 ist teuro.'
+            assert driver.output == b'\x1bt\x0f\xa4 ist teuro.'
 
         def test_write_disabled(self, driver):
             encode = MagicEncode(driver, encoding='cp437', disabled=True)
@@ -77,7 +78,7 @@ class TestMagicEncode:
 
         def test_write_no_codepage(self, driver):
             encode = MagicEncode(
-                driver, defaultsymbol="_", encoder=Encoder({1: 'cp437'}),
+                driver, defaultsymbol="_", encoder=Encoder({'cp437': 1}),
                 encoding='cp437')
             encode.write(u'€ ist teuro.')
             assert driver.output == b'_ ist teuro.'
@@ -87,10 +88,10 @@ class TestMagicEncode:
         def test(self, driver):
             encode = MagicEncode(driver)
             encode.force_encoding('cp437')
-            assert driver.output == b'\x1bt'
+            assert driver.output == b'\x1bt\x00'
 
             encode.write('€ ist teuro.')
-            assert driver.output == b'\x1bt? ist teuro.'
+            assert driver.output == b'\x1bt\x00? ist teuro.'
 
 
 class TestKatakana: