updated changelog

Pass lines to parser including line endings

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+branch = True

.gitignore

@@ -3,3 +3,6 @@
 .tox
 .cache
 *.egg-info
+/.project
+/.pydevproject
+/.coverage

.travis.yml

@@ -1,10 +1,17 @@
 language: python
+
 python:
   - 2.7
   - 3.4
   - 3.5
-install: pip install tox-travis
+  
+install: pip install tox-travis codecov
+
 script: tox
+
+after_success:
+  - codecov
+
 matrix:
   allow_failures:
     - python: 2.7

CHANGELOG.rst

@@ -1,6 +1,15 @@
 Change Log
 ----------
 
+**0.6** (2017-01-04)
+
+- Fixed bug in CRC checksum verification for the asyncio client (`pull request #15 <https://github.com/ndokter/dsmr_parser/pull/15>`_)
+- Support added for TCP connections using the asyncio client (`pull request #12 <https://github.com/ndokter/dsmr_parser/pull/12/>`_)
+
+**0.5** (2016-12-29)
+
+- CRC checksum verification for DSMR v4 telegrams (`issue #10 <https://github.com/ndokter/dsmr_parser/issues/10>`_)
+
 **0.4** (2016-11-21)
 
 - DSMR v2.2 serial settings now uses parity serial.EVEN by default (`pull request #5 <https://github.com/ndokter/dsmr_parser/pull/5>`_)
@@ -8,7 +17,7 @@ Change Log
 
 **0.3** (2016-11-12)
 
-- asyncio reader for non-blocking reads. (`pull request #3 <https://github.com/ndokter/dsmr_parser/pull/3>`_)
+- asyncio reader for non-blocking reads (`pull request #3 <https://github.com/ndokter/dsmr_parser/pull/3>`_)
 
 **0.2** (2016-11-08)
 

README.rst

@@ -70,9 +70,3 @@ If the serial settings SERIAL_SETTINGS_V2_2 or SERIAL_SETTINGS_V4 don't work.
 Make sure to try and replace the parity settings to EVEN or NONE.
 It's possible that alternative settings will be added in the future if these
 settings don't work for the majority of meters.
-
-TODO
-----
-
-- verify telegram checksum
-- improve ease of use

dsmr_parser/__main__.py

@@ -1,8 +1,9 @@
 import argparse
 import asyncio
 import logging
+from functools import partial
 
-from .protocol import create_dsmr_reader
+from .protocol import create_dsmr_reader, create_tcp_dsmr_reader
 
 
 def console():
@@ -11,6 +12,10 @@ def console():
     parser = argparse.ArgumentParser(description=console.__doc__)
     parser.add_argument('--device', default='/dev/ttyUSB0',
                         help='port to read DSMR data from')
+    parser.add_argument('--host', default=None,
+                        help='alternatively connect using TCP host.')
+    parser.add_argument('--port', default=None,
+                        help='TCP port to use for connection')
     parser.add_argument('--version', default='2.2', choices=['2.2', '4'],
                         help='DSMR version (2.2, 4)')
     parser.add_argument('--verbose', '-v', action='count')
@@ -32,7 +37,29 @@ def console():
                 print(obj.value, obj.unit)
         print()
 
-    conn = create_dsmr_reader(args.device, args.version, print_callback, loop=loop)
+    # create tcp or serial connection depending on args
+    if args.host and args.port:
+        create_connection = partial(create_tcp_dsmr_reader,
+                                    args.host, args.port, args.version,
+                                    print_callback, loop=loop)
+    else:
+        create_connection = partial(create_dsmr_reader,
+                                    args.device, args.version,
+                                    print_callback, loop=loop)
 
-    loop.create_task(conn)
-    loop.run_forever()
+    try:
+        # connect and keep connected until interrupted by ctrl-c
+        while True:
+            # create serial or tcp connection
+            conn = create_connection()
+            transport, protocol = loop.run_until_complete(conn)
+            # wait until connection it closed
+            loop.run_until_complete(protocol.wait_closed())
+            # wait 5 seconds before attempting reconnect
+            loop.run_until_complete(asyncio.sleep(5))
+    except KeyboardInterrupt:
+        # cleanup connection after user initiated shutdown
+        transport.close()
+        loop.run_until_complete(asyncio.sleep(0))
+    finally:
+        loop.close()

dsmr_parser/exceptions.py

@@ -1,2 +1,6 @@
 class ParseError(Exception):
     pass
+
+
+class InvalidChecksumError(ParseError):
+    pass

dsmr_parser/parsers.py

@@ -1,8 +1,10 @@
 import logging
 import re
 
+from PyCRC.CRC16 import CRC16
+
 from .objects import MBusObject, MBusObjectV2_2, CosemObject
-from .exceptions import ParseError
+from .exceptions import ParseError, InvalidChecksumError
 from .obis_references import GAS_METER_READING
 
 logger = logging.getLogger(__name__)
@@ -18,7 +20,6 @@ class TelegramParser(object):
         self.telegram_specification = telegram_specification
 
     def _find_line_parser(self, line_value):
-
         for obis_reference, parser in self.telegram_specification.items():
             if re.search(obis_reference, line_value):
                 return obis_reference, parser
@@ -29,7 +30,10 @@ class TelegramParser(object):
         telegram = {}
 
         for line_value in line_values:
-            obis_reference, dsmr_object = self.parse_line(line_value.strip())
+            # TODO temporarily strip newline characters.
+            line_value = line_value.strip()
+
+            obis_reference, dsmr_object = self.parse_line(line_value)
 
             telegram[obis_reference] = dsmr_object
 
@@ -47,7 +51,51 @@ class TelegramParser(object):
         return obis_reference, parser.parse(line_value)
 
 
+class TelegramParserV4(TelegramParser):
+
+    @staticmethod
+    def validate_telegram_checksum(line_values):
+        """
+        :type line_values: list
+        :raises ParseError:
+        :raises InvalidChecksumError:
+        """
+
+        full_telegram = ''.join(line_values)
+
+        # Extract the bytes that count towards the checksum.
+        checksum_contents = re.search(r'\/.+\!', full_telegram, re.DOTALL)
+
+        # Extract the hexadecimal checksum value itself.
+        checksum_hex = re.search(r'((?<=\!)[0-9A-Z]{4}(?=\r\n))+', full_telegram)
+
+        if not checksum_contents or not checksum_hex:
+            raise ParseError(
+                'Failed to perform CRC validation because the telegram is '
+                'incomplete. The checksum and/or content values are missing.'
+            )
+
+        calculated_crc = CRC16().calculate(checksum_contents.group(0))
+        expected_crc = checksum_hex.group(0)
+        expected_crc = int(expected_crc, base=16)
+
+        if calculated_crc != expected_crc:
+            raise InvalidChecksumError(
+                "Invalid telegram. The CRC checksum '{}' does not match the "
+                "expected '{}'".format(
+                    calculated_crc,
+                    expected_crc
+                )
+            )
+
+    def parse(self, line_values):
+        self.validate_telegram_checksum(line_values)
+
+        return super().parse(line_values)
+
+
 class TelegramParserV2_2(TelegramParser):
+
     def parse(self, line_values):
         """Join lines for gas meter."""
 

dsmr_parser/protocol.py

@@ -8,13 +8,13 @@ from serial_asyncio import create_serial_connection
 
 from . import telegram_specifications
 from .exceptions import ParseError
-from .parsers import TelegramParser, TelegramParserV2_2
+from .parsers import TelegramParserV2_2, TelegramParserV4
 from .serial import (SERIAL_SETTINGS_V2_2, SERIAL_SETTINGS_V4,
                      is_end_of_telegram, is_start_of_telegram)
 
 
-def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
-    """Creates a DSMR asyncio protocol coroutine."""
+def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol."""
 
     if dsmr_version == '2.2':
         specifications = telegram_specifications.V2_2
@@ -22,16 +22,31 @@ def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
         serial_settings = SERIAL_SETTINGS_V2_2
     elif dsmr_version == '4':
         specifications = telegram_specifications.V4
-        telegram_parser = TelegramParser
+        telegram_parser = TelegramParserV4
         serial_settings = SERIAL_SETTINGS_V4
 
-    serial_settings['url'] = port
-
     protocol = partial(DSMRProtocol, loop, telegram_parser(specifications),
                        telegram_callback=telegram_callback)
 
-    conn = create_serial_connection(loop, protocol, **serial_settings)
+    return protocol, serial_settings
 
+
+def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol coroutine using serial port."""
+    protocol, serial_settings = create_dsmr_protocol(
+        dsmr_version, telegram_callback, loop=None)
+    serial_settings['url'] = port
+
+    conn = create_serial_connection(loop, protocol, **serial_settings)
+    return conn
+
+
+def create_tcp_dsmr_reader(host, port, dsmr_version,
+                           telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol coroutine using TCP connection."""
+    protocol, _ = create_dsmr_protocol(
+        dsmr_version, telegram_callback, loop=None)
+    conn = loop.create_connection(protocol, host, port)
     return conn
 
 
@@ -52,6 +67,8 @@ class DSMRProtocol(asyncio.Protocol):
         self.telegram = []
         # buffer to keep incomplete incoming data
         self.buffer = ''
+        # keep a lock until the connection is closed
+        self._closed = asyncio.Event()
 
     def connection_made(self, transport):
         """Just logging for now."""
@@ -67,9 +84,11 @@ class DSMRProtocol(asyncio.Protocol):
 
     def handle_lines(self):
         """Assemble incoming data into single lines."""
-        while "\r\n" in self.buffer:
-            line, self.buffer = self.buffer.split("\r\n", 1)
+        crlf = "\r\n"
+        while crlf in self.buffer:
+            line, self.buffer = self.buffer.split(crlf, 1)
             self.log.debug('got line: %s', line)
+            line += crlf  # add the trailing crlf again
 
             # Telegrams need to be complete because the values belong to a
             # particular reading and can also be related to eachother.
@@ -87,7 +106,11 @@ class DSMRProtocol(asyncio.Protocol):
 
     def connection_lost(self, exc):
         """Stop when connection is lost."""
-        self.log.error('disconnected')
+        if exc:
+            self.log.exception('disconnected due to exception')
+        else:
+            self.log.info('disconnected because of close/abort.')
+        self._closed.set()
 
     def handle_telegram(self, telegram):
         """Send off parsed telegram to handling callback."""
@@ -95,3 +118,8 @@ class DSMRProtocol(asyncio.Protocol):
 
         if self.telegram_callback:
             self.telegram_callback(telegram)
+
+    @asyncio.coroutine
+    def wait_closed(self):
+        """Wait until connection is closed."""
+        yield from self._closed.wait()

dsmr_parser/serial.py

@@ -1,11 +1,11 @@
 import asyncio
 import logging
-
 import serial
-
 import serial_asyncio
+
 from dsmr_parser.exceptions import ParseError
-from dsmr_parser.parsers import TelegramParser, TelegramParserV2_2
+from dsmr_parser.parsers import TelegramParser, TelegramParserV2_2, \
+    TelegramParserV4
 
 logger = logging.getLogger(__name__)
 
@@ -32,15 +32,20 @@ SERIAL_SETTINGS_V4 = {
 
 
 def is_start_of_telegram(line):
+    """
+    :type line: line
+    """
     return line.startswith('/')
 
 
 def is_end_of_telegram(line):
+    """
+    :type line: line
+    """
     return line.startswith('!')
 
 
 class SerialReader(object):
-
     PORT_KEY = 'port'
 
     def __init__(self, device, serial_settings, telegram_specification):
@@ -49,8 +54,11 @@ class SerialReader(object):
 
         if serial_settings is SERIAL_SETTINGS_V2_2:
             telegram_parser = TelegramParserV2_2
+        elif serial_settings is SERIAL_SETTINGS_V4:
+            telegram_parser = TelegramParserV4
         else:
             telegram_parser = TelegramParser
+
         self.telegram_parser = telegram_parser(telegram_specification)
 
     def read(self):
@@ -65,7 +73,7 @@ class SerialReader(object):
 
             while True:
                 line = serial_handle.readline()
-                line = line.decode('ascii')
+                line = line.decode('ascii')  # TODO move this to the parser?
 
                 # Telegrams need to be complete because the values belong to a
                 # particular reading and can also be related to eachother.
@@ -75,7 +83,12 @@ class SerialReader(object):
                 telegram.append(line)
 
                 if is_end_of_telegram(line):
-                    yield self.telegram_parser.parse(telegram)
+
+                    try:
+                        yield self.telegram_parser.parse(telegram)
+                    except ParseError as e:
+                        logger.error('Failed to parse telegram: %s', e)
+
                     telegram = []
 
 
@@ -119,7 +132,7 @@ class AsyncSerialReader(SerialReader):
                     parsed_telegram = self.telegram_parser.parse(telegram)
                     # push new parsed telegram onto queue
                     queue.put_nowait(parsed_telegram)
-                except ParseError:
-                    logger.exception("failed to parse telegram")
+                except ParseError as e:
+                    logger.warning('Failed to parse telegram: %s', e)
 
                 telegram = []

dsmr_parser/value_types.py

@@ -4,8 +4,9 @@ import pytz
 
 
 def timestamp(value):
-
     naive_datetime = datetime.datetime.strptime(value[:-1], '%y%m%d%H%M%S')
+
+    # TODO comment on this exception
     if len(value) == 13:
         is_dst = value[12] == 'S'  # assume format 160322150000W
     else:

setup.py

@@ -6,12 +6,13 @@ setup(
     author='Nigel Dokter',
     author_email='nigeldokter@gmail.com',
     url='https://github.com/ndokter/dsmr_parser',
-    version='0.4',
+    version='0.5',
     packages=find_packages(),
     install_requires=[
         'pyserial>=3,<4',
         'pyserial-asyncio<1',
-        'pytz'
+        'pytz',
+        'PyCRC>=1.2,<2'
     ],
     entry_points={
         'console_scripts': ['dsmr_console=dsmr_parser.__main__:console']

test/test_parse_v2_2.py

@@ -1,41 +1,42 @@
-"""Test parsing of a DSMR v2.2 telegram."""
+import unittest
 
 from dsmr_parser.parsers import TelegramParserV2_2
 from dsmr_parser import telegram_specifications
 from dsmr_parser import obis_references as obis
 
 TELEGRAM_V2_2 = [
-    "/ISk5\2MT382-1004",
-    "",
-    "0-0:96.1.1(00000000000000)",
-    "1-0:1.8.1(00001.001*kWh)",
-    "1-0:1.8.2(00001.001*kWh)",
-    "1-0:2.8.1(00001.001*kWh)",
-    "1-0:2.8.2(00001.001*kWh)",
-    "0-0:96.14.0(0001)",
-    "1-0:1.7.0(0001.01*kW)",
-    "1-0:2.7.0(0000.00*kW)",
-    "0-0:17.0.0(0999.00*kW)",
-    "0-0:96.3.10(1)",
-    "0-0:96.13.1()",
-    "0-0:96.13.0()",
-    "0-1:24.1.0(3)",
-    "0-1:96.1.0(000000000000)",
-    "0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)",
-    "(00001.001)",
-    "0-1:24.4.0(1)",
-    "!",
+    '/ISk5\2MT382-1004',
+    '',
+    '0-0:96.1.1(00000000000000)',
+    '1-0:1.8.1(00001.001*kWh)',
+    '1-0:1.8.2(00001.001*kWh)',
+    '1-0:2.8.1(00001.001*kWh)',
+    '1-0:2.8.2(00001.001*kWh)',
+    '0-0:96.14.0(0001)',
+    '1-0:1.7.0(0001.01*kW)',
+    '1-0:2.7.0(0000.00*kW)',
+    '0-0:17.0.0(0999.00*kW)',
+    '0-0:96.3.10(1)',
+    '0-0:96.13.1()',
+    '0-0:96.13.0()',
+    '0-1:24.1.0(3)',
+    '0-1:96.1.0(000000000000)',
+    '0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)',
+    '(00001.001)',
+    '0-1:24.4.0(1)',
+    '!',
 ]
 
 
-def test_parse():
-    """Test if telegram parsing results in correct results."""
+class TelegramParserV2_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v2.2 telegram. """
 
-    parser = TelegramParserV2_2(telegram_specifications.V2_2)
-    result = parser.parse(TELEGRAM_V2_2)
+    def test_parse(self):
+        parser = TelegramParserV2_2(telegram_specifications.V2_2)
+        result = parser.parse(TELEGRAM_V2_2)
 
-    assert float(result[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
-    assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+        assert float(result[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
+        assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
 
-    assert float(result[obis.GAS_METER_READING].value) == 1.001
-    assert result[obis.GAS_METER_READING].unit == 'm3'
+        assert float(result[obis.GAS_METER_READING].value) == 1.001
+        assert result[obis.GAS_METER_READING].unit == 'm3'

test/test_parse_v4_2.py

@@ -1,232 +1,261 @@
-"""Test parsing of a DSMR v4.2 telegram."""
-import datetime
 from decimal import Decimal
+import datetime
+import unittest
 
 import pytz
 
 from dsmr_parser import obis_references as obis
 from dsmr_parser import telegram_specifications
+from dsmr_parser.exceptions import InvalidChecksumError, ParseError
 from dsmr_parser.objects import CosemObject, MBusObject
-from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.parsers import TelegramParser, TelegramParserV4
 
 TELEGRAM_V4_2 = [
-    '1-3:0.2.8(42)',
-    '0-0:1.0.0(161113205757W)',
-    '0-0:96.1.1(1231231231231231231231231231231231)',
-    '1-0:1.8.1(001511.267*kWh)',
-    '1-0:1.8.2(001265.173*kWh)',
-    '1-0:2.8.1(000000.000*kWh)',
-    '1-0:2.8.2(000000.000*kWh)',
-    '0-0:96.14.0(0001)',
-    '1-0:1.7.0(00.235*kW)',
-    '1-0:2.7.0(00.000*kW)',
-    '0-0:96.7.21(00015)',
-    '0-0:96.7.9(00007)',
-    ('1-0:99.97.0(3)(0-0:96.7.19)(000103180420W)(0000237126*s)'
-     '(000101000001W)(2147483647*s)(000101000001W)(2147483647*s)'),
-    '1-0:32.32.0(00000)',
-    '1-0:52.32.0(00000)',
-    '1-0:72.32.0(00000)',
-    '1-0:32.36.0(00000)',
-    '1-0:52.36.0(00000)',
-    '1-0:72.36.0(00000)',
-    '0-0:96.13.1()',
-    '0-0:96.13.0()',
-    '1-0:31.7.0(000*A)',
-    '1-0:51.7.0(000*A)',
-    '1-0:71.7.0(000*A)',
-    '1-0:21.7.0(00.095*kW)',
-    '1-0:22.7.0(00.000*kW)',
-    '1-0:41.7.0(00.025*kW)',
-    '1-0:42.7.0(00.000*kW)',
-    '1-0:61.7.0(00.115*kW)',
-    '1-0:62.7.0(00.000*kW)',
-    '0-1:24.1.0(003)',
-    '0-1:96.1.0(3404856892390357246729543587524029)',
-    '0-1:24.2.1(161113200000W)(00915.219*m3)',
-    '!5D83',
+    '/KFM5KAIFA-METER\r\n',
+    '\r\n',
+    '1-3:0.2.8(42)\r\n',
+    '0-0:1.0.0(161113205757W)\r\n',
+    '0-0:96.1.1(3960221976967177082151037881335713)\r\n',
+    '1-0:1.8.1(001581.123*kWh)\r\n',
+    '1-0:1.8.2(001435.706*kWh)\r\n',
+    '1-0:2.8.1(000000.000*kWh)\r\n',
+    '1-0:2.8.2(000000.000*kWh)\r\n',
+    '0-0:96.14.0(0002)\r\n',
+    '1-0:1.7.0(02.027*kW)\r\n',
+    '1-0:2.7.0(00.000*kW)\r\n',
+    '0-0:96.7.21(00015)\r\n',
+    '0-0:96.7.9(00007)\r\n',
+    '1-0:99.97.0(3)(0-0:96.7.19)(000104180320W)(0000237126*s)(000101000001W)'
+    '(2147583646*s)(000102000003W)(2317482647*s)\r\n',
+    '1-0:32.32.0(00000)\r\n',
+    '1-0:52.32.0(00000)\r\n',
+    '1-0:72.32.0(00000)\r\n',
+    '1-0:32.36.0(00000)\r\n',
+    '1-0:52.36.0(00000)\r\n',
+    '1-0:72.36.0(00000)\r\n',
+    '0-0:96.13.1()\r\n',
+    '0-0:96.13.0()\r\n',
+    '1-0:31.7.0(000*A)\r\n',
+    '1-0:51.7.0(006*A)\r\n',
+    '1-0:71.7.0(002*A)\r\n',
+    '1-0:21.7.0(00.170*kW)\r\n',
+    '1-0:22.7.0(00.000*kW)\r\n',
+    '1-0:41.7.0(01.247*kW)\r\n',
+    '1-0:42.7.0(00.000*kW)\r\n',
+    '1-0:61.7.0(00.209*kW)\r\n',
+    '1-0:62.7.0(00.000*kW)\r\n',
+    '0-1:24.1.0(003)\r\n',
+    '0-1:96.1.0(4819243993373755377509728609491464)\r\n',
+    '0-1:24.2.1(161129200000W)(00981.443*m3)\r\n',
+    '!6796\r\n'
 ]
 
 
-def test_parse():
-    parser = TelegramParser(telegram_specifications.V4)
-    result = parser.parse(TELEGRAM_V4_2)
+class TelegramParserV4_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v4.2 telegram. """
 
-    # P1_MESSAGE_HEADER (1-3:0.2.8)
-    assert isinstance(result[obis.P1_MESSAGE_HEADER], CosemObject)
-    assert result[obis.P1_MESSAGE_HEADER].unit is None
-    assert isinstance(result[obis.P1_MESSAGE_HEADER].value, str)
-    assert result[obis.P1_MESSAGE_HEADER].value == '42'
+    def test_valid(self):
+        # No exception is raised.
+        TelegramParserV4.validate_telegram_checksum(
+            TELEGRAM_V4_2
+        )
 
-    # P1_MESSAGE_TIMESTAMP (0-0:1.0.0)
-    assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP], CosemObject)
-    assert result[obis.P1_MESSAGE_TIMESTAMP].unit is None
-    assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP].value, datetime.datetime)
-    assert result[obis.P1_MESSAGE_TIMESTAMP].value == \
-        datetime.datetime(2016, 11, 13, 19, 57, 57, tzinfo=pytz.UTC)
+    def test_invalid(self):
+        # Remove one the electricty used data value. This causes the checksum to
+        # not match anymore.
+        telegram = [line
+                    for line in TELEGRAM_V4_2
+                    if '1-0:1.8.1' not in line]
 
-    # ELECTRICITY_USED_TARIFF_1 (1-0:1.8.1)
-    assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1], CosemObject)
-    assert result[obis.ELECTRICITY_USED_TARIFF_1].unit == 'kWh'
-    assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1].value, Decimal)
-    assert result[obis.ELECTRICITY_USED_TARIFF_1].value == Decimal('1511.267')
+        with self.assertRaises(InvalidChecksumError):
+            TelegramParserV4.validate_telegram_checksum(telegram)
 
-    # ELECTRICITY_USED_TARIFF_2 (1-0:1.8.2)
-    assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2], CosemObject)
-    assert result[obis.ELECTRICITY_USED_TARIFF_2].unit == 'kWh'
-    assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2].value, Decimal)
-    assert result[obis.ELECTRICITY_USED_TARIFF_2].value == Decimal('1265.173')
+    def test_missing_checksum(self):
+        # Remove the checksum value causing a ParseError.
+        telegram = TELEGRAM_V4_2[:-1]
 
-    # ELECTRICITY_DELIVERED_TARIFF_1 (1-0:2.8.1)
-    assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1], CosemObject)
-    assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].unit == 'kWh'
-    assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value, Decimal)
-    assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value == Decimal('0')
+        with self.assertRaises(ParseError):
+            TelegramParserV4.validate_telegram_checksum(telegram)
 
-    # ELECTRICITY_DELIVERED_TARIFF_2 (1-0:2.8.2)
-    assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2], CosemObject)
-    assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].unit == 'kWh'
-    assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value, Decimal)
-    assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value == Decimal('0')
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V4)
+        result = parser.parse(TELEGRAM_V4_2)
 
-    # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
-    assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF], CosemObject)
-    assert result[obis.ELECTRICITY_ACTIVE_TARIFF].unit is None
-    assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF].value, str)
-    assert result[obis.ELECTRICITY_ACTIVE_TARIFF].value == '0001'
+        # P1_MESSAGE_HEADER (1-3:0.2.8)
+        assert isinstance(result[obis.P1_MESSAGE_HEADER], CosemObject)
+        assert result[obis.P1_MESSAGE_HEADER].unit is None
+        assert isinstance(result[obis.P1_MESSAGE_HEADER].value, str)
+        assert result[obis.P1_MESSAGE_HEADER].value == '42'
 
-    # EQUIPMENT_IDENTIFIER (0-0:96.1.1)
-    assert isinstance(result[obis.EQUIPMENT_IDENTIFIER], CosemObject)
-    assert result[obis.EQUIPMENT_IDENTIFIER].unit is None
-    assert isinstance(result[obis.EQUIPMENT_IDENTIFIER].value, str)
-    assert result[obis.EQUIPMENT_IDENTIFIER].value == '1231231231231231231231231231231231'
+        # P1_MESSAGE_TIMESTAMP (0-0:1.0.0)
+        assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP], CosemObject)
+        assert result[obis.P1_MESSAGE_TIMESTAMP].unit is None
+        assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP].value, datetime.datetime)
+        assert result[obis.P1_MESSAGE_TIMESTAMP].value == \
+            datetime.datetime(2016, 11, 13, 19, 57, 57, tzinfo=pytz.UTC)
 
-    # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
-    assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE], CosemObject)
-    assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
-    assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE].value, Decimal)
-    assert result[obis.CURRENT_ELECTRICITY_USAGE].value == Decimal('0.235')
+        # ELECTRICITY_USED_TARIFF_1 (1-0:1.8.1)
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1], CosemObject)
+        assert result[obis.ELECTRICITY_USED_TARIFF_1].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1].value, Decimal)
+        assert result[obis.ELECTRICITY_USED_TARIFF_1].value == Decimal('1581.123')
 
-    # CURRENT_ELECTRICITY_DELIVERY (1-0:2.7.0)
-    assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY], CosemObject)
-    assert result[obis.CURRENT_ELECTRICITY_DELIVERY].unit == 'kW'
-    assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY].value, Decimal)
-    assert result[obis.CURRENT_ELECTRICITY_DELIVERY].value == Decimal('0')
+        # ELECTRICITY_USED_TARIFF_2 (1-0:1.8.2)
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2], CosemObject)
+        assert result[obis.ELECTRICITY_USED_TARIFF_2].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2].value, Decimal)
+        assert result[obis.ELECTRICITY_USED_TARIFF_2].value == Decimal('1435.706')
 
-    # LONG_POWER_FAILURE_COUNT (96.7.9)
-    assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT], CosemObject)
-    assert result[obis.LONG_POWER_FAILURE_COUNT].unit is None
-    assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT].value, int)
-    assert result[obis.LONG_POWER_FAILURE_COUNT].value == 7
+        # ELECTRICITY_DELIVERED_TARIFF_1 (1-0:2.8.1)
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1], CosemObject)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value, Decimal)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value == Decimal('0')
 
-    # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
-    assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SAG_L1_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT].value, int)
-    assert result[obis.VOLTAGE_SAG_L1_COUNT].value == 0
+        # ELECTRICITY_DELIVERED_TARIFF_2 (1-0:2.8.2)
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2], CosemObject)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value, Decimal)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value == Decimal('0')
 
-    # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
-    assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SAG_L2_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT].value, int)
-    assert result[obis.VOLTAGE_SAG_L2_COUNT].value == 0
+        # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
+        assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF], CosemObject)
+        assert result[obis.ELECTRICITY_ACTIVE_TARIFF].unit is None
+        assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF].value, str)
+        assert result[obis.ELECTRICITY_ACTIVE_TARIFF].value == '0002'
 
-    # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
-    assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SAG_L3_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT].value, int)
-    assert result[obis.VOLTAGE_SAG_L3_COUNT].value == 0
+        # EQUIPMENT_IDENTIFIER (0-0:96.1.1)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER].value == '3960221976967177082151037881335713'
 
-    # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
-    assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SWELL_L1_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT].value, int)
-    assert result[obis.VOLTAGE_SWELL_L1_COUNT].value == 0
+        # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE], CosemObject)
+        assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE].value, Decimal)
+        assert result[obis.CURRENT_ELECTRICITY_USAGE].value == Decimal('2.027')
 
-    # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
-    assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SWELL_L2_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT].value, int)
-    assert result[obis.VOLTAGE_SWELL_L2_COUNT].value == 0
+        # CURRENT_ELECTRICITY_DELIVERY (1-0:2.7.0)
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY], CosemObject)
+        assert result[obis.CURRENT_ELECTRICITY_DELIVERY].unit == 'kW'
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY].value, Decimal)
+        assert result[obis.CURRENT_ELECTRICITY_DELIVERY].value == Decimal('0')
 
-    # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
-    assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT], CosemObject)
-    assert result[obis.VOLTAGE_SWELL_L3_COUNT].unit is None
-    assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT].value, int)
-    assert result[obis.VOLTAGE_SWELL_L3_COUNT].value == 0
+        # LONG_POWER_FAILURE_COUNT (96.7.9)
+        assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.LONG_POWER_FAILURE_COUNT].unit is None
+        assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT].value, int)
+        assert result[obis.LONG_POWER_FAILURE_COUNT].value == 7
 
-    # TEXT_MESSAGE_CODE (0-0:96.13.1)
-    assert isinstance(result[obis.TEXT_MESSAGE_CODE], CosemObject)
-    assert result[obis.TEXT_MESSAGE_CODE].unit is None
-    assert result[obis.TEXT_MESSAGE_CODE].value is None
+        # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L1_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L1_COUNT].value == 0
 
-    # TEXT_MESSAGE (0-0:96.13.0)
-    assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
-    assert result[obis.TEXT_MESSAGE].unit is None
-    assert result[obis.TEXT_MESSAGE].value is None
+        # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].value == 0
 
-    # DEVICE_TYPE (0-x:24.1.0)
-    assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
-    assert result[obis.DEVICE_TYPE].unit is None
-    assert isinstance(result[obis.DEVICE_TYPE].value, int)
-    assert result[obis.DEVICE_TYPE].value == 3
+        # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].value == 0
 
-    # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value == Decimal('0.095')
+        # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].value == 0
 
-    # INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE (1-0:41.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value == Decimal('0.025')
+        # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].value == 0
 
-    # INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE (1-0:61.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value == Decimal('0.115')
+        # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L3_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L3_COUNT].value == 0
 
-    # INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE (1-0:22.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value == Decimal('0')
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        assert isinstance(result[obis.TEXT_MESSAGE_CODE], CosemObject)
+        assert result[obis.TEXT_MESSAGE_CODE].unit is None
+        assert result[obis.TEXT_MESSAGE_CODE].value is None
 
-    # INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE (1-0:42.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value == Decimal('0')
+        # TEXT_MESSAGE (0-0:96.13.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.TEXT_MESSAGE].unit is None
+        assert result[obis.TEXT_MESSAGE].value is None
 
-    # INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE (1-0:62.7.0)
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE], CosemObject)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].unit == 'kW'
-    assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value, Decimal)
-    assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value == Decimal('0')
+        # DEVICE_TYPE (0-x:24.1.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.DEVICE_TYPE].value, int)
+        assert result[obis.DEVICE_TYPE].value == 3
 
-    # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
-    assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
-    assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
-    assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
-    assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '3404856892390357246729543587524029'
+        # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value == Decimal('0.170')
 
-    # HOURLY_GAS_METER_READING (0-1:24.2.1)
-    assert isinstance(result[obis.HOURLY_GAS_METER_READING], MBusObject)
-    assert result[obis.HOURLY_GAS_METER_READING].unit == 'm3'
-    assert isinstance(result[obis.HOURLY_GAS_METER_READING].value, Decimal)
-    assert result[obis.HOURLY_GAS_METER_READING].value == Decimal('915.219')
+        # INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE (1-0:41.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value == Decimal('1.247')
 
-    # POWER_EVENT_FAILURE_LOG (99.97.0)
-    # TODO to be implemented
+        # INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE (1-0:61.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value == Decimal('0.209')
 
-    # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
-    # TODO to be implemented
+        # INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE (1-0:22.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value == Decimal('0')
 
-    # ACTUAL_SWITCH_POSITION (0-0:96.3.10)
-    # TODO to be implemented
+        # INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE (1-0:42.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value == Decimal('0')
 
-    # VALVE_POSITION_GAS (0-x:24.4.0)
-    # TODO to be implemented
+        # INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE (1-0:62.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value == Decimal('0')
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '4819243993373755377509728609491464'
+
+        # HOURLY_GAS_METER_READING (0-1:24.2.1)
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING], MBusObject)
+        assert result[obis.HOURLY_GAS_METER_READING].unit == 'm3'
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING].value, Decimal)
+        assert result[obis.HOURLY_GAS_METER_READING].value == Decimal('981.443')
+
+        # POWER_EVENT_FAILURE_LOG (99.97.0)
+        # TODO to be implemented
+
+        # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
+        # TODO to be implemented
+
+        # ACTUAL_SWITCH_POSITION (0-0:96.3.10)
+        # TODO to be implemented
+
+        # VALVE_POSITION_GAS (0-x:24.4.0)
+        # TODO to be implemented

test/test_protocol.py

@@ -1,39 +1,58 @@
 """Test DSMR serial protocol."""
-
+import unittest
 from unittest.mock import Mock
 
-import pytest
 from dsmr_parser import obis_references as obis
 from dsmr_parser import telegram_specifications
 from dsmr_parser.parsers import TelegramParserV2_2
 from dsmr_parser.protocol import DSMRProtocol
 
-from .test_parse_v2_2 import TELEGRAM_V2_2
+
+TELEGRAM_V2_2 = [
+    "/ISk5\2MT382-1004",
+    "",
+    "0-0:96.1.1(00000000000000)",
+    "1-0:1.8.1(00001.001*kWh)",
+    "1-0:1.8.2(00001.001*kWh)",
+    "1-0:2.8.1(00001.001*kWh)",
+    "1-0:2.8.2(00001.001*kWh)",
+    "0-0:96.14.0(0001)",
+    "1-0:1.7.0(0001.01*kW)",
+    "1-0:2.7.0(0000.00*kW)",
+    "0-0:17.0.0(0999.00*kW)",
+    "0-0:96.3.10(1)",
+    "0-0:96.13.1()",
+    "0-0:96.13.0()",
+    "0-1:24.1.0(3)",
+    "0-1:96.1.0(000000000000)",
+    "0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)",
+    "(00001.001)",
+    "0-1:24.4.0(1)",
+    "!",
+]
 
 
-@pytest.fixture
-def protocol():
-    """DSMRprotocol instance with mocked telegram_callback."""
+class ProtocolTest(unittest.TestCase):
 
-    parser = TelegramParserV2_2
-    specification = telegram_specifications.V2_2
+    def setUp(self):
+        parser = TelegramParserV2_2
+        specification = telegram_specifications.V2_2
 
-    telegram_parser = parser(specification)
-    return DSMRProtocol(None, telegram_parser,
-                        telegram_callback=Mock())
+        telegram_parser = parser(specification)
+        self.protocol = DSMRProtocol(None, telegram_parser,
+                                     telegram_callback=Mock())
 
+    def test_complete_packet(self):
+        """Protocol should assemble incoming lines into complete packet."""
 
-def test_complete_packet(protocol):
-    """Protocol should assemble incoming lines into complete packet."""
+        for line in TELEGRAM_V2_2:
+            self.protocol.data_received(bytes(line + '\r\n', 'ascii'))
 
-    for line in TELEGRAM_V2_2:
-        protocol.data_received(bytes(line + '\r\n', 'ascii'))
+        telegram = self.protocol.telegram_callback.call_args_list[0][0][0]
+        assert isinstance(telegram, dict)
 
-    telegram = protocol.telegram_callback.call_args_list[0][0][0]
-    assert isinstance(telegram, dict)
+        assert float(telegram[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
+        assert telegram[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
 
-    assert float(telegram[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
-    assert telegram[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
-
-    assert float(telegram[obis.GAS_METER_READING].value) == 1.001
-    assert telegram[obis.GAS_METER_READING].unit == 'm3'
+        assert float(telegram[obis.GAS_METER_READING].value) == 1.001
+        assert telegram[obis.GAS_METER_READING].unit == 'm3'

tox.ini

@@ -4,12 +4,14 @@ envlist = py34,py35
 [testenv]
 deps=
   pytest
+  pytest-cov
   pylama
   pytest-asyncio
   pytest-catchlog
   pytest-mock
+  PyCRC
 commands=
-  py.test test {posargs}
+  py.test --cov=dsmr_parser test {posargs}
   pylama dsmr_parser test
 
 [pylama:pylint]