diff --git a/tests/client/test_AprsClient.py b/tests/client/test_AprsClient.py
index f1bfcf8..ac61978 100644
--- a/tests/client/test_AprsClient.py
+++ b/tests/client/test_AprsClient.py
@@ -9,15 +9,15 @@ from ogn.client.settings import APRS_APP_NAME, APRS_APP_VER, APRS_KEEPALIVE_TIME
 class AprsClientTest(unittest.TestCase):
     def test_create_aprs_login(self):
         basic_login = create_aprs_login('klaus', -1, 'myApp', '0.1')
-        self.assertEqual('user klaus pass -1 vers myApp 0.1\n', basic_login)
+        assert 'user klaus pass -1 vers myApp 0.1\n' == basic_login
 
         login_with_filter = create_aprs_login('klaus', -1, 'myApp', '0.1', 'r/48.0/11.0/100')
-        self.assertEqual('user klaus pass -1 vers myApp 0.1 filter r/48.0/11.0/100\n', login_with_filter)
+        assert 'user klaus pass -1 vers myApp 0.1 filter r/48.0/11.0/100\n' == login_with_filter
 
     def test_initialisation(self):
         client = AprsClient(aprs_user='testuser', aprs_filter='')
-        self.assertEqual(client.aprs_user, 'testuser')
-        self.assertEqual(client.aprs_filter, '')
+        assert client.aprs_user == 'testuser'
+        assert client.aprs_filter == ''
 
     @mock.patch('ogn.client.client.socket')
     def test_connect_full_feed(self, mock_socket):
@@ -42,7 +42,7 @@ class AprsClientTest(unittest.TestCase):
         client.disconnect()
         client.sock.shutdown.assert_called_once_with(0)
         client.sock.close.assert_called_once_with()
-        self.assertTrue(client._kill)
+        assert client._kill is True
 
     @mock.patch('ogn.client.client.socket')
     def test_run(self, mock_socket):
@@ -112,14 +112,14 @@ class AprsClientTest(unittest.TestCase):
         client.run(callback=mock_callback, autoreconnect=True)
 
         # After .disconnect(), client._kill should be True
-        self.assertTrue(client._kill)
-        self.assertEqual(mock_callback.call_count, 1)
+        assert client._kill is True
+        assert mock_callback.call_count == 1
 
         # After we reconnect, .run() should be able to run again
         mock_callback.reset_mock()
         client.connect()
         client.run(callback=mock_callback, autoreconnect=True)
-        self.assertEqual(mock_callback.call_count, 1)
+        assert mock_callback.call_count == 1
 
     @unittest.skip("Too much invalid APRS data on the live feed")
     def test_50_live_messages(self):
@@ -148,4 +148,3 @@ class AprsClientTest(unittest.TestCase):
             pass
         finally:
             client.disconnect()
-        self.assertTrue(True)
diff --git a/tests/parser/test_parse.py b/tests/parser/test_parse.py
index e544fd4..e596c31 100644
--- a/tests/parser/test_parse.py
+++ b/tests/parser/test_parse.py
@@ -17,7 +17,7 @@ class TestStringMethods(unittest.TestCase):
                     message = parse(line, datetime(2015, 4, 10, 17, 0))
                     self.assertFalse(message is None)
                     if message['aprs_type'] == 'position' or message['aprs_type'] == 'status':
-                        self.assertEqual(message['beacon_type'], beacon_type)
+                        assert message['beacon_type'] == beacon_type
                 except NotImplementedError as e:
                     print(e)
 
@@ -68,8 +68,8 @@ class TestStringMethods(unittest.TestCase):
 
     def test_generic_beacons(self):
         message = parse("EPZR>WTFDSTCALL,TCPIP*,qAC,GLIDERN1:>093456h this is a comment")
-        self.assertEqual(message['beacon_type'], 'unknown')
-        self.assertEqual(message['comment'], "this is a comment")
+        assert message['beacon_type'] == 'unknown'
+        assert message['comment'] == "this is a comment"
 
     def test_fail_parse_aprs_none(self):
         with self.assertRaises(TypeError):
@@ -87,11 +87,11 @@ class TestStringMethods(unittest.TestCase):
         # receiver beacons from chile have a APRS position message with a pure user comment
         message = parse("VITACURA1>APRS,TCPIP*,qAC,GLIDERN4:/201146h3322.79SI07034.80W&/A=002329 Vitacura Municipal Aerodrome, Club de Planeadores Vitacura")
 
-        self.assertEqual(message['user_comment'], "Vitacura Municipal Aerodrome, Club de Planeadores Vitacura")
+        assert message['user_comment'] == "Vitacura Municipal Aerodrome, Club de Planeadores Vitacura"
 
         message_with_id = parse("ALFALFAL>APRS,TCPIP*,qAC,GLIDERN4:/221830h3330.40SI07007.88W&/A=008659 Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs")
 
-        self.assertEqual(message_with_id['user_comment'], "Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs")
+        assert message_with_id['user_comment'] == "Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs"
 
     @mock.patch('ogn.parser.parse_module.createTimestamp')
     def test_default_reference_date(self, createTimestamp_mock):
@@ -111,8 +111,8 @@ class TestStringMethods(unittest.TestCase):
         valid_aprs_string = "FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 id0ADDA5BA -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5"
         message = parse(valid_aprs_string)
 
-        self.assertEqual(message['name'], 'FLRDDA5BA')
-        self.assertEqual(message['address'], 'DDA5BA')
+        assert message['name'] == 'FLRDDA5BA'
+        assert message['address'] == 'DDA5BA'
 
     def test_bad_naviter_format(self):
         with self.assertRaises(OgnParseError):
@@ -121,11 +121,11 @@ class TestStringMethods(unittest.TestCase):
     def test_no_receiver(self):
         result = parse("EDFW>OGNSDR:/102713h4949.02NI00953.88E&/A=000984")
 
-        self.assertEqual(result['aprs_type'], 'position')
-        self.assertEqual(result['beacon_type'], 'receiver')
-        self.assertEqual(result['name'], 'EDFW')
-        self.assertEqual(result['dstcall'], 'OGNSDR')
-        self.assertEqual(result['receiver_name'], None)
+        assert result['aprs_type'] == 'position'
+        assert result['beacon_type'] == 'receiver'
+        assert result['name'] == 'EDFW'
+        assert result['dstcall'] == 'OGNSDR'
+        assert result['receiver_name'] is None
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_aprs.py b/tests/parser/test_parse_aprs.py
index a649d4b..b22c4cb 100644
--- a/tests/parser/test_parse_aprs.py
+++ b/tests/parser/test_parse_aprs.py
@@ -15,26 +15,26 @@ class TestStringMethods(unittest.TestCase):
     def test_basic(self):
         message = parse_aprs("FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 this is a comment")
 
-        self.assertEqual(message['aprs_type'], 'position')
-        self.assertEqual(message['name'], "FLRDDA5BA")
-        self.assertEqual(message['dstcall'], "APRS")
-        self.assertEqual(message['receiver_name'], "LFMX")
-        self.assertEqual(message['timestamp'].strftime('%H:%M:%S'), "16:08:29")
+        assert message['aprs_type'] == 'position'
+        assert message['name'] == "FLRDDA5BA"
+        assert message['dstcall'] == "APRS"
+        assert message['receiver_name'] == "LFMX"
+        assert message['timestamp'].strftime('%H:%M:%S') == "16:08:29"
         self.assertAlmostEqual(message['latitude'], 44.25683, 5)
-        self.assertEqual(message['symboltable'], '/')
+        assert message['symboltable'] == '/'
         self.assertAlmostEqual(message['longitude'], 6.0005, 5)
-        self.assertEqual(message['symbolcode'], '\'')
-        self.assertEqual(message['track'], 342)
-        self.assertEqual(message['ground_speed'], 49 * KNOTS_TO_MS / KPH_TO_MS)
+        assert message['symbolcode'] == '\''
+        assert message['track'] == 342
+        assert message['ground_speed'] == 49 * KNOTS_TO_MS / KPH_TO_MS
         self.assertAlmostEqual(message['altitude'], 5524 * FEETS_TO_METER, 5)
-        self.assertEqual(message['comment'], "this is a comment")
+        assert message['comment'] == "this is a comment"
 
     def test_v024(self):
         # higher precision datum format introduced
         raw_message = "FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 !W26! id21400EA9 -2454fpm +0.9rot 19.5dB 0e -6.6kHz gps1x1 s6.02 h44 rDF0C56"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position')
+        assert message['aprs_type'] == 'position'
         self.assertAlmostEqual(message['latitude'] - 44.2568 - 1 / 30000, 2 / 1000 / 60, 10)
         self.assertAlmostEqual(message['longitude'] - 6.0005, 6 / 1000 / 60, 10)
 
@@ -43,70 +43,70 @@ class TestStringMethods(unittest.TestCase):
         raw_message = "EPZR>APRS,TCPIP*,qAC,GLIDERN1:>093456h this is a comment"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'status')
-        self.assertEqual(message['name'], "EPZR")
-        self.assertEqual(message['receiver_name'], "GLIDERN1")
-        self.assertEqual(message['timestamp'].strftime('%H:%M:%S'), "09:34:56")
-        self.assertEqual(message['comment'], "this is a comment")
+        assert message['aprs_type'] == 'status'
+        assert message['name'] == "EPZR"
+        assert message['receiver_name'] == "GLIDERN1"
+        assert message['timestamp'].strftime('%H:%M:%S') == "09:34:56"
+        assert message['comment'] == "this is a comment"
 
     def test_v026(self):
         # from 0.2.6 the ogn comment of a receiver beacon is just optional
         raw_message = "Ulrichamn>APRS,TCPIP*,qAC,GLIDERN1:/085616h5747.30NI01324.77E&/A=001322"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position')
-        self.assertEqual(message['comment'], '')
+        assert message['aprs_type'] == 'position'
+        assert message['comment'] == ''
 
     def test_v026_relay(self):
         # beacons can be relayed
         raw_message = "FLRFFFFFF>OGNAVI,NAV07220E*,qAS,NAVITER:/092002h1000.00S/01000.00W'000/000/A=003281 !W00! id2820FFFFFF +300fpm +1.7rot"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position')
-        self.assertEqual(message['relay'], "NAV07220E")
+        assert message['aprs_type'] == 'position'
+        assert message['relay'] == "NAV07220E"
 
     def test_v027_ddhhmm(self):
         # beacons can have hhmmss or ddhhmm timestamp
         raw_message = "ICA4B0678>APRS,qAS,LSZF:/301046z4729.50N/00812.89E'227/091/A=002854 !W01! id054B0678 +040fpm +0.0rot 19.0dB 0e +1.5kHz gps1x1"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position')
-        self.assertEqual(message['timestamp'].strftime('%d %H:%M'), "30 10:46")
+        assert message['aprs_type'] == 'position'
+        assert message['timestamp'].strftime('%d %H:%M') == "30 10:46"
 
     def test_v028_fanet_position_weather(self):
         # with v0.2.8 fanet devices can report weather data
         raw_message = 'FNTFC9002>OGNFNT,qAS,LSXI2:/163051h4640.33N/00752.21E_187/004g007t075h78b63620 29.0dB -8.0kHz'
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position_weather')
-        self.assertEqual(message['wind_direction'], 187)
-        self.assertEqual(message['wind_speed'], 4 * KNOTS_TO_MS / KPH_TO_MS)
-        self.assertEqual(message['wind_speed_peak'], 7 * KNOTS_TO_MS / KPH_TO_MS)
-        self.assertEqual(message['temperature'], fahrenheit_to_celsius(75))
-        self.assertEqual(message['humidity'], 78 * 0.01)
-        self.assertEqual(message['barometric_pressure'], 63620)
+        assert message['aprs_type'] == 'position_weather'
+        assert message['wind_direction'] == 187
+        assert message['wind_speed'] == 4 * KNOTS_TO_MS / KPH_TO_MS
+        assert message['wind_speed_peak'] == 7 * KNOTS_TO_MS / KPH_TO_MS
+        assert message['temperature'] == fahrenheit_to_celsius(75)
+        assert message['humidity'] == 78 * 0.01
+        assert message['barometric_pressure'] == 63620
 
-        self.assertEqual(message['comment'], '29.0dB -8.0kHz')
+        assert message['comment'] == '29.0dB -8.0kHz'
 
     def test_GXAirCom_fanet_position_weather_rainfall(self):
         raw_message = 'FNT08F298>OGNFNT,qAS,DREIFBERG:/082654h4804.90N/00845.74E_273/005g008t057r123p234h90b10264 0.0dB'
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position_weather')
-        self.assertEqual(message['rainfall_1h'], 123 / 100 * INCH_TO_MM)
-        self.assertEqual(message['rainfall_24h'], 234 / 100 * INCH_TO_MM)
+        assert message['aprs_type'] == 'position_weather'
+        assert message['rainfall_1h'] == 123 / 100 * INCH_TO_MM
+        assert message['rainfall_24h'] == 234 / 100 * INCH_TO_MM
 
     def test_v028_fanet_position_weather_empty(self):
         raw_message = 'FNT010115>OGNFNT,qAS,DB7MJ:/065738h4727.72N/01012.83E_.../...g...t... 27.8dB -13.8kHz'
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['aprs_type'], 'position_weather')
-        self.assertIsNone(message['wind_direction'])
-        self.assertIsNone(message['wind_speed'])
-        self.assertIsNone(message['wind_speed_peak'])
-        self.assertIsNone(message['temperature'])
-        self.assertIsNone(message['humidity'])
-        self.assertIsNone(message['barometric_pressure'])
+        assert message['aprs_type'] == 'position_weather'
+        assert message['wind_direction'] is None
+        assert message['wind_speed'] is None
+        assert message['wind_speed_peak'] is None
+        assert message['temperature'] is None
+        assert message['humidity'] is None
+        assert message['barometric_pressure'] is None
 
     def test_negative_altitude(self):
         # some devices can report negative altitudes
@@ -120,7 +120,7 @@ class TestStringMethods(unittest.TestCase):
         raw_message = "FLRDDEEF1>OGCAPT,qAS,CAPTURS:/065511h4837.63N/00233.79E'000/000"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['altitude'], None)
+        assert message['altitude'] is None
 
     def test_invalid_coordinates(self):
         # sometimes the coordinates leave their valid range: -90<=latitude<=90 or -180<=longitude<=180
@@ -145,19 +145,19 @@ class TestStringMethods(unittest.TestCase):
         raw_message = "# bad configured ogn receiver"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['comment'], raw_message)
-        self.assertEqual(message['aprs_type'], 'comment')
+        assert message['comment'] == raw_message
+        assert message['aprs_type'] == 'comment'
 
     def test_server_comment(self):
         raw_message = "# aprsc 2.1.4-g408ed49 17 Mar 2018 09:30:36 GMT GLIDERN1 37.187.40.234:10152"
         message = parse_aprs(raw_message)
 
-        self.assertEqual(message['version'], '2.1.4-g408ed49')
-        self.assertEqual(message['timestamp'], datetime(2018, 3, 17, 9, 30, 36))
-        self.assertEqual(message['server'], 'GLIDERN1')
-        self.assertEqual(message['ip_address'], '37.187.40.234')
-        self.assertEqual(message['port'], '10152')
-        self.assertEqual(message['aprs_type'], 'server')
+        assert message['version'] == '2.1.4-g408ed49'
+        assert message['timestamp'] == datetime(2018, 3, 17, 9, 30, 36)
+        assert message['server'] == 'GLIDERN1'
+        assert message['ip_address'] == '37.187.40.234'
+        assert message['port'] == '10152'
+        assert message['aprs_type'] == 'server'
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_fanet.py b/tests/parser/test_parse_fanet.py
index 1b3ca97..d7ed566 100644
--- a/tests/parser/test_parse_fanet.py
+++ b/tests/parser/test_parse_fanet.py
@@ -8,24 +8,24 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = FanetParser().parse_position("id1E1103CE -02fpm")
 
-        self.assertEqual(message['address_type'], 2)
-        self.assertEqual(message['aircraft_type'], 7)
+        assert message['address_type'] == 2
+        assert message['aircraft_type'] == 7
         self.assertFalse(message['stealth'])
-        self.assertEqual(message['address'], "1103CE")
+        assert message['address'] == "1103CE"
         self.assertAlmostEqual(message['climb_rate'], -2 * FPM_TO_MS, 0.1)
 
     def test_pseudo_status_comment(self):
         message = FanetParser().parse_position("")
 
-        self.assertEqual(message, {})
+        assert message == {}
 
     def test_v028_status(self):
         message = FanetParser().parse_status('Name="Juerg Zweifel" 15.0dB -17.1kHz 1e')
 
-        self.assertEqual(message['fanet_name'], "Juerg Zweifel")
-        self.assertEqual(message['signal_quality'], 15.0)
-        self.assertEqual(message['frequency_offset'], -17.1)
-        self.assertEqual(message['error_count'], 1)
+        assert message['fanet_name'] == "Juerg Zweifel"
+        assert message['signal_quality'] == 15.0
+        assert message['frequency_offset'] == -17.1
+        assert message['error_count'] == 1
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_flarm.py b/tests/parser/test_parse_flarm.py
index 19e72ff..271b4a6 100644
--- a/tests/parser/test_parse_flarm.py
+++ b/tests/parser/test_parse_flarm.py
@@ -8,27 +8,27 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = FlarmParser().parse_position("id21A8CBA8 -039fpm +0.1rot 3.5dB 2e -8.7kHz gps1x2 s6.09 h43 rDF0267")
 
-        self.assertEqual(message['address_type'], 1)
-        self.assertEqual(message['aircraft_type'], 8)
+        assert message['address_type'] == 1
+        assert message['aircraft_type'] == 8
         self.assertFalse(message['stealth'])
         self.assertFalse(message['no-tracking'])
-        self.assertEqual(message['address'], "A8CBA8")
+        assert message['address'] == "A8CBA8"
         self.assertAlmostEqual(message['climb_rate'], -39 * FPM_TO_MS, 2)
-        self.assertEqual(message['turn_rate'], 0.1 * HPM_TO_DEGS)
-        self.assertEqual(message['signal_quality'], 3.5)
-        self.assertEqual(message['error_count'], 2)
-        self.assertEqual(message['frequency_offset'], -8.7)
-        self.assertEqual(message['gps_quality'], {'horizontal': 1, 'vertical': 2})
-        self.assertEqual(message['software_version'], 6.09)
-        self.assertEqual(message['hardware_version'], 67)
-        self.assertEqual(message['real_address'], "DF0267")
+        assert message['turn_rate'] == 0.1 * HPM_TO_DEGS
+        assert message['signal_quality'] == 3.5
+        assert message['error_count'] == 2
+        assert message['frequency_offset'] == -8.7
+        assert message['gps_quality'] == {'horizontal': 1, 'vertical': 2}
+        assert message['software_version'] == 6.09
+        assert message['hardware_version'] == 67
+        assert message['real_address'] == "DF0267"
 
     def test_position_comment_relevant_keys_only(self):
         # return only keys where we got informations
         message = FlarmParser().parse_position("id21A8CBA8")
 
         self.assertIsNotNone(message)
-        self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
+        assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_generic.py b/tests/parser/test_parse_generic.py
index 01f6516..505b3fa 100644
--- a/tests/parser/test_parse_generic.py
+++ b/tests/parser/test_parse_generic.py
@@ -6,10 +6,10 @@ from ogn.parser.aprs_comment.generic_parser import GenericParser
 class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = GenericParser().parse_position("id0123456789 weather is good, climbing with 123fpm")
-        self.assertTrue('comment' in message)
+        assert 'comment' in message
 
         message = GenericParser().parse_status("id0123456789 weather is good, climbing with 123fpm")
-        self.assertTrue('comment' in message)
+        assert 'comment' in message
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_inreach.py b/tests/parser/test_parse_inreach.py
index 1f7c252..79a0265 100644
--- a/tests/parser/test_parse_inreach.py
+++ b/tests/parser/test_parse_inreach.py
@@ -5,16 +5,16 @@ from ogn.parser.aprs_comment.inreach_parser import InreachParser
 class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = InreachParser().parse_position("id300434060496190 inReac True")
-        self.assertEqual(message['address'], "300434060496190")
-        self.assertEqual(message['model'], 'inReac')
-        self.assertEqual(message['status'], True)
-        self.assertEqual(message['pilot_name'], None)
+        assert message['address'] == "300434060496190"
+        assert message['model'] == 'inReac'
+        assert message['status'] is True
+        assert message['pilot_name'] is None
 
         message = InreachParser().parse_position("id300434060496190 inReac True Jim Bob")
-        self.assertEqual(message['address'], "300434060496190")
-        self.assertEqual(message['model'], 'inReac')
-        self.assertEqual(message['status'], True)
-        self.assertEqual(message['pilot_name'], "Jim Bob")
+        assert message['address'] == "300434060496190"
+        assert message['model'] == 'inReac'
+        assert message['status'] is True
+        assert message['pilot_name'] == "Jim Bob"
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_lt24.py b/tests/parser/test_parse_lt24.py
index 663dd5f..2692971 100644
--- a/tests/parser/test_parse_lt24.py
+++ b/tests/parser/test_parse_lt24.py
@@ -8,9 +8,9 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = LT24Parser().parse_position("id25387 +123fpm GPS")
 
-        self.assertEqual(message['lt24_id'], "25387")
+        assert message['lt24_id'] == "25387"
         self.assertAlmostEqual(message['climb_rate'], 123 * FPM_TO_MS, 2)
-        self.assertEqual(message['source'], 'GPS')
+        assert message['source'] == 'GPS'
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_microtrak.py b/tests/parser/test_parse_microtrak.py
index 4c43c36..484d09f 100644
--- a/tests/parser/test_parse_microtrak.py
+++ b/tests/parser/test_parse_microtrak.py
@@ -7,18 +7,18 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = MicrotrakParser().parse_position("id21A8CBA8")
 
-        self.assertEqual(message['address_type'], 1)
-        self.assertEqual(message['aircraft_type'], 8)
+        assert message['address_type'] == 1
+        assert message['aircraft_type'] == 8
         self.assertFalse(message['stealth'])
         self.assertFalse(message['no-tracking'])
-        self.assertEqual(message['address'], "A8CBA8")
+        assert message['address'] == "A8CBA8"
 
     def test_position_comment_relevant_keys_only(self):
         # return only keys where we got informations
         message = MicrotrakParser().parse_position("id21A8CBA8")
 
         self.assertIsNotNone(message)
-        self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
+        assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_naviter.py b/tests/parser/test_parse_naviter.py
index d085465..18ecb11 100644
--- a/tests/parser/test_parse_naviter.py
+++ b/tests/parser/test_parse_naviter.py
@@ -15,15 +15,15 @@ class TestStringMethods(unittest.TestCase):
         # bits 6-11: address type (namespace is extended from 2 to 6 bits to avoid collisions with other tracking providers)
         # bits 12-15: reserved for use at a later time
         # bits 16-39: device id (24-bit device identifier, same as in APRS header)
-        self.assertEqual(message['stealth'], False)
-        self.assertEqual(message['do_not_track'], False)
-        self.assertEqual(message['aircraft_type'], 1)
-        self.assertEqual(message['address_type'], 4)
-        self.assertEqual(message['reserved'], 0)
-        self.assertEqual(message['address'], "042121")
+        assert message['stealth'] is False
+        assert message['do_not_track'] is False
+        assert message['aircraft_type'] == 1
+        assert message['address_type'] == 4
+        assert message['reserved'] == 0
+        assert message['address'] == "042121"
 
         self.assertAlmostEqual(message['climb_rate'], 123 * FPM_TO_MS, 2)
-        self.assertEqual(message['turn_rate'], 0.5 * HPM_TO_DEGS)
+        assert message['turn_rate'] == 0.5 * HPM_TO_DEGS
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_ogn_aircraft.py b/tests/parser/test_parse_ogn_aircraft.py
index 96f297c..3abc74c 100644
--- a/tests/parser/test_parse_ogn_aircraft.py
+++ b/tests/parser/test_parse_ogn_aircraft.py
@@ -6,57 +6,57 @@ from ogn.parser.aprs_comment.ogn_parser import OgnParser
 
 class TestStringMethods(unittest.TestCase):
     def test_invalid_token(self):
-        self.assertEqual(OgnParser().parse_aircraft_beacon("notAValidToken"), None)
+        assert OgnParser().parse_aircraft_beacon("notAValidToken") is None
 
     def test_basic(self):
         message = OgnParser().parse_aircraft_beacon("id0ADDA5BA -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
 
-        self.assertEqual(message['address_type'], 2)
-        self.assertEqual(message['aircraft_type'], 2)
+        assert message['address_type'] == 2
+        assert message['aircraft_type'] == 2
         self.assertFalse(message['stealth'])
         self.assertFalse(message['no-tracking'])
-        self.assertEqual(message['address'], "DDA5BA")
+        assert message['address'] == "DDA5BA"
         self.assertAlmostEqual(message['climb_rate'], -454 * FPM_TO_MS, 2)
-        self.assertEqual(message['turn_rate'], -1.1 * HPM_TO_DEGS)
-        self.assertEqual(message['signal_quality'], 8.8)
-        self.assertEqual(message['error_count'], 0)
-        self.assertEqual(message['frequency_offset'], 51.2)
-        self.assertEqual(message['gps_quality'], {'horizontal': 4, 'vertical': 5})
-        self.assertEqual(len(message['proximity']), 3)
-        self.assertEqual(message['proximity'][0], '1084')
-        self.assertEqual(message['proximity'][1], 'B597')
-        self.assertEqual(message['proximity'][2], 'B598')
+        assert message['turn_rate'] == -1.1 * HPM_TO_DEGS
+        assert message['signal_quality'] == 8.8
+        assert message['error_count'] == 0
+        assert message['frequency_offset'] == 51.2
+        assert message['gps_quality'] == {'horizontal': 4, 'vertical': 5}
+        assert len(message['proximity']) == 3
+        assert message['proximity'][0] == '1084'
+        assert message['proximity'][1] == 'B597'
+        assert message['proximity'][2] == 'B598'
 
     def test_no_tracking(self):
         message = OgnParser().parse_aircraft_beacon("id0ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
         self.assertFalse(message['no-tracking'])
 
         message = OgnParser().parse_aircraft_beacon("id4ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
-        self.assertTrue(message['no-tracking'])
+        assert message['no-tracking'] is True
 
     def test_stealth(self):
         message = OgnParser().parse_aircraft_beacon("id0ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
-        self.assertFalse(message['stealth'])
+        assert message['stealth'] is False
 
         message = OgnParser().parse_aircraft_beacon("id8ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
-        self.assertTrue(message['stealth'])
+        assert message['stealth'] is True
 
     def test_v024(self):
         message = OgnParser().parse_aircraft_beacon("id21400EA9 -2454fpm +0.9rot 19.5dB 0e -6.6kHz gps1x1 s6.02 h0A rDF0C56")
 
-        self.assertEqual(message['software_version'], 6.02)
-        self.assertEqual(message['hardware_version'], 10)
-        self.assertEqual(message['real_address'], "DF0C56")
+        assert message['software_version'] == 6.02
+        assert message['hardware_version'] == 10
+        assert message['real_address'] == "DF0C56"
 
     def test_v024_ogn_tracker(self):
         message = OgnParser().parse_aircraft_beacon("id07353800 +020fpm -14.0rot FL004.43 38.5dB 0e -2.9kHz")
 
-        self.assertEqual(message['flightlevel'], 4.43)
+        assert message['flightlevel'] == 4.43
 
     def test_v025(self):
         message = OgnParser().parse_aircraft_beacon("id06DDE28D +535fpm +3.8rot 11.5dB 0e -1.0kHz gps2x3 s6.01 h0C +7.4dBm")
 
-        self.assertEqual(message['signal_power'], 7.4)
+        assert message['signal_power'] == 7.4
 
     def test_v026(self):
         # from 0.2.6 it is sufficent we have only the ID, climb and turn rate or just the ID
@@ -71,7 +71,7 @@ class TestStringMethods(unittest.TestCase):
         message = OgnParser().parse_aircraft_beacon("id093D0930")
 
         self.assertIsNotNone(message)
-        self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
+        assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_ogn_receiver.py b/tests/parser/test_parse_ogn_receiver.py
index 6824661..927f093 100644
--- a/tests/parser/test_parse_ogn_receiver.py
+++ b/tests/parser/test_parse_ogn_receiver.py
@@ -5,53 +5,53 @@ from ogn.parser.aprs_comment.ogn_parser import OgnParser
 
 class TestStringMethods(unittest.TestCase):
     def test_fail_validation(self):
-        self.assertEqual(OgnParser().parse_receiver_beacon("notAValidToken"), None)
+        assert OgnParser().parse_receiver_beacon("notAValidToken") is None
 
     def test_v021(self):
         message = OgnParser().parse_receiver_beacon("v0.2.1 CPU:0.8 RAM:25.6/458.9MB NTP:0.1ms/+2.3ppm +51.9C RF:+26-1.4ppm/-0.25dB")
 
-        self.assertEqual(message['version'], "0.2.1")
-        self.assertEqual(message['cpu_load'], 0.8)
-        self.assertEqual(message['free_ram'], 25.6)
-        self.assertEqual(message['total_ram'], 458.9)
-        self.assertEqual(message['ntp_error'], 0.1)
-        self.assertEqual(message['rt_crystal_correction'], 2.3)
-        self.assertEqual(message['cpu_temp'], 51.9)
+        assert message['version'] == "0.2.1"
+        assert message['cpu_load'] == 0.8
+        assert message['free_ram'] == 25.6
+        assert message['total_ram'] == 458.9
+        assert message['ntp_error'] == 0.1
+        assert message['rt_crystal_correction'] == 2.3
+        assert message['cpu_temp'] == 51.9
 
-        self.assertEqual(message['rec_crystal_correction'], 26)
-        self.assertEqual(message['rec_crystal_correction_fine'], -1.4)
-        self.assertEqual(message['rec_input_noise'], -0.25)
+        assert message['rec_crystal_correction'] == 26
+        assert message['rec_crystal_correction_fine'] == -1.4
+        assert message['rec_input_noise'] == -0.25
 
     def test_v022(self):
         message = OgnParser().parse_receiver_beacon("v0.2.2.x86 CPU:0.5 RAM:669.9/887.7MB NTP:1.0ms/+6.2ppm +52.0C RF:+0.06dB")
-        self.assertEqual(message['platform'], 'x86')
+        assert message['platform'] == 'x86'
 
     def test_v025(self):
         message = OgnParser().parse_receiver_beacon("v0.2.5.RPI-GPU CPU:0.8 RAM:287.3/458.7MB NTP:1.0ms/-6.4ppm 5.016V 0.534A +51.9C RF:+55+0.4ppm/-0.67dB/+10.8dB@10km[57282]")
-        self.assertEqual(message['voltage'], 5.016)
-        self.assertEqual(message['amperage'], 0.534)
-        self.assertEqual(message['senders_signal'], 10.8)
-        self.assertEqual(message['senders_messages'], 57282)
+        assert message['voltage'] == 5.016
+        assert message['amperage'] == 0.534
+        assert message['senders_signal'] == 10.8
+        assert message['senders_messages'] == 57282
 
         message = OgnParser().parse_receiver_beacon("v0.2.5.ARM CPU:0.4 RAM:638.0/970.5MB NTP:0.2ms/-1.1ppm +65.5C 14/16Acfts[1h] RF:+45+0.0ppm/+3.88dB/+24.0dB@10km[143717]/+26.7dB@10km[68/135]")
-        self.assertEqual(message['senders_visible'], 14)
-        self.assertEqual(message['senders_total'], 16)
-        self.assertEqual(message['senders_signal'], 24.0)
-        self.assertEqual(message['senders_messages'], 143717)
-        self.assertEqual(message['good_senders_signal'], 26.7)
-        self.assertEqual(message['good_senders'], 68)
-        self.assertEqual(message['good_and_bad_senders'], 135)
+        assert message['senders_visible'] == 14
+        assert message['senders_total'] == 16
+        assert message['senders_signal'] == 24.0
+        assert message['senders_messages'] == 143717
+        assert message['good_senders_signal'] == 26.7
+        assert message['good_senders'] == 68
+        assert message['good_and_bad_senders'] == 135
 
     def test_v028(self):
         message = OgnParser().parse_receiver_beacon("v0.2.8.RPI-GPU CPU:0.3 RAM:744.5/968.2MB NTP:3.6ms/+2.0ppm +68.2C 3/3Acfts[1h] Lat:1.6s RF:-8+67.8ppm/+10.33dB/+1.3dB@10km[30998]/+10.4dB@10km[3/5]")
-        self.assertEqual(message['latency'], 1.6)
+        assert message['latency'] == 1.6
 
     def test_relevant_keys_only(self):
         # return only keys where we got informations
         message = OgnParser().parse_receiver_beacon("v0.2.5.ARM CPU:0.4 RAM:638.0/970.5MB NTP:0.2ms/-1.1ppm")
 
         self.assertIsNotNone(message)
-        self.assertEqual(sorted(message.keys()), sorted(['version', 'platform', 'cpu_load', 'free_ram', 'total_ram', 'ntp_error', 'rt_crystal_correction']))
+        assert sorted(message.keys()) == sorted(['version', 'platform', 'cpu_load', 'free_ram', 'total_ram', 'ntp_error', 'rt_crystal_correction'])
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_receiver.py b/tests/parser/test_parse_receiver.py
index 563a9b2..0b079f1 100644
--- a/tests/parser/test_parse_receiver.py
+++ b/tests/parser/test_parse_receiver.py
@@ -7,7 +7,7 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = ReceiverParser().parse_position("Antenna: chinese, on a pylon, 20 meter above ground")
 
-        self.assertEqual(message['user_comment'], "Antenna: chinese, on a pylon, 20 meter above ground")
+        assert message['user_comment'] == "Antenna: chinese, on a pylon, 20 meter above ground"
 
     def test_position_comment_empty(self):
         message = ReceiverParser().parse_position("")
@@ -17,24 +17,24 @@ class TestStringMethods(unittest.TestCase):
     def test_status_comment(self):
         message = ReceiverParser().parse_status("v0.2.7.RPI-GPU CPU:0.7 RAM:770.2/968.2MB NTP:1.8ms/-3.3ppm +55.7C 7/8Acfts[1h] RF:+54-1.1ppm/-0.16dB/+7.1dB@10km[19481]/+16.8dB@10km[7/13]")
 
-        self.assertEqual(message['version'], "0.2.7")
-        self.assertEqual(message['platform'], 'RPI-GPU')
-        self.assertEqual(message['cpu_load'], 0.7)
-        self.assertEqual(message['free_ram'], 770.2)
-        self.assertEqual(message['total_ram'], 968.2)
-        self.assertEqual(message['ntp_error'], 1.8)
-        self.assertEqual(message['rt_crystal_correction'], -3.3)
-        self.assertEqual(message['cpu_temp'], 55.7)
-        self.assertEqual(message['senders_visible'], 7)
-        self.assertEqual(message['senders_total'], 8)
-        self.assertEqual(message['rec_crystal_correction'], 54)
-        self.assertEqual(message['rec_crystal_correction_fine'], -1.1)
-        self.assertEqual(message['rec_input_noise'], -0.16)
-        self.assertEqual(message['senders_signal'], 7.1)
-        self.assertEqual(message['senders_messages'], 19481)
-        self.assertEqual(message['good_senders_signal'], 16.8)
-        self.assertEqual(message['good_senders'], 7)
-        self.assertEqual(message['good_and_bad_senders'], 13)
+        assert message['version'] == "0.2.7"
+        assert message['platform'] == 'RPI-GPU'
+        assert message['cpu_load'] == 0.7
+        assert message['free_ram'] == 770.2
+        assert message['total_ram'] == 968.2
+        assert message['ntp_error'] == 1.8
+        assert message['rt_crystal_correction'] == -3.3
+        assert message['cpu_temp'] == 55.7
+        assert message['senders_visible'] == 7
+        assert message['senders_total'] == 8
+        assert message['rec_crystal_correction'] == 54
+        assert message['rec_crystal_correction_fine'] == -1.1
+        assert message['rec_input_noise'] == -0.16
+        assert message['senders_signal'] == 7.1
+        assert message['senders_messages'] == 19481
+        assert message['good_senders_signal'] == 16.8
+        assert message['good_senders'] == 7
+        assert message['good_and_bad_senders'] == 13
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_safesky.py b/tests/parser/test_parse_safesky.py
index 7b6444e..b3e3342 100644
--- a/tests/parser/test_parse_safesky.py
+++ b/tests/parser/test_parse_safesky.py
@@ -8,12 +8,12 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         # "SKY3E5906>OGNSKY,qAS,SafeSky:/072555h5103.47N/00524.81E'065/031/A=001250 !W05! id1C3E5906 +010fpm gps6x1"
         message = SafeskyParser().parse_position("id1C3E5906 +010fpm gps6x1")
-        self.assertEqual(message['address'], '3E5906')
-        self.assertEqual(message['address_type'], 0)
-        self.assertEqual(message['aircraft_type'], 7)
+        assert message['address'] == '3E5906'
+        assert message['address_type'] == 0
+        assert message['aircraft_type'] == 7
         self.assertFalse(message['stealth'])
         self.assertAlmostEqual(message['climb_rate'], 10 * FPM_TO_MS, 2)
-        self.assertEqual(message['gps_quality'], {'horizontal': 6, 'vertical': 1})
+        assert message['gps_quality'] == {'horizontal': 6, 'vertical': 1}
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_skylines.py b/tests/parser/test_parse_skylines.py
index 55d4628..e0908d2 100644
--- a/tests/parser/test_parse_skylines.py
+++ b/tests/parser/test_parse_skylines.py
@@ -8,7 +8,7 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = SkylinesParser().parse_position("id2816 -015fpm")
 
-        self.assertEqual(message['skylines_id'], "2816")
+        assert message['skylines_id'] == "2816"
         self.assertAlmostEqual(message['climb_rate'], -15 * FPM_TO_MS, 2)
 
 
diff --git a/tests/parser/test_parse_spider.py b/tests/parser/test_parse_spider.py
index 27bb338..be4e75a 100644
--- a/tests/parser/test_parse_spider.py
+++ b/tests/parser/test_parse_spider.py
@@ -7,10 +7,10 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = SpiderParser().parse_position("id300234060668560 +30dB K23W 3D")
 
-        self.assertEqual(message['spider_id'], "300234060668560")
-        self.assertEqual(message['signal_power'], 30)
-        self.assertEqual(message['spider_registration'], "K23W")
-        self.assertEqual(message['gps_quality'], "3D")
+        assert message['spider_id'] == "300234060668560"
+        assert message['signal_power'] == 30
+        assert message['spider_registration'] == "K23W"
+        assert message['gps_quality'] == "3D"
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_spot.py b/tests/parser/test_parse_spot.py
index 76fe669..7dfcb2a 100644
--- a/tests/parser/test_parse_spot.py
+++ b/tests/parser/test_parse_spot.py
@@ -7,9 +7,9 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = SpotParser().parse_position("id0-2860357 SPOT3 GOOD")
 
-        self.assertEqual(message['spot_id'], "0-2860357")
-        self.assertEqual(message['model'], 'SPOT3')
-        self.assertEqual(message['status'], "GOOD")
+        assert message['spot_id'] == "0-2860357"
+        assert message['model'] == 'SPOT3'
+        assert message['status'] == "GOOD"
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_parse_telnet.py b/tests/parser/test_parse_telnet.py
index 4f60a74..f30266d 100644
--- a/tests/parser/test_parse_telnet.py
+++ b/tests/parser/test_parse_telnet.py
@@ -20,33 +20,33 @@ class TestStringMethods(unittest.TestCase):
 
         message = parse('0.181sec:868.394MHz:   1:2:DDA411 103010: [ +50.86800, +12.15279]deg  988m  +0.1m/s  25.7m/s 085.4deg  -3.5deg/sec 5 03x04m 01f_-12.61kHz  5.8/15.5dB/2 10e   30.9km 099.5deg  +1.1deg + ?     R     B8949')
 
-        self.assertEqual(message['pps_offset'], 0.181)
-        self.assertEqual(message['frequency'], 868.394)
-        self.assertEqual(message['aircraft_type'], 1)
-        self.assertEqual(message['address_type'], 2)
-        self.assertEqual(message['address'], 'DDA411')
-        self.assertEqual(message['timestamp'], datetime(2015, 1, 1, 10, 30, 10))
-        self.assertEqual(message['latitude'], 50.868)
-        self.assertEqual(message['longitude'], 12.15279)
-        self.assertEqual(message['altitude'], 988)
-        self.assertEqual(message['climb_rate'], 0.1)
-        self.assertEqual(message['ground_speed'], 25.7)
-        self.assertEqual(message['track'], 85.4)
-        self.assertEqual(message['turn_rate'], -3.5)
-        self.assertEqual(message['magic_number'], 5)  # the '5' is a magic number... 1 if ground_speed is 0.0m/s an 3 or 5 if airborne. Do you have an idea what it is?
-        self.assertEqual(message['gps_status'], '03x04')
-        self.assertEqual(message['channel'], 1)
-        self.assertEqual(message['flarm_timeslot'], True)
-        self.assertEqual(message['ogn_timeslot'], False)
-        self.assertEqual(message['frequency_offset'], -12.61)
-        self.assertEqual(message['decode_quality'], 5.8)
-        self.assertEqual(message['signal_quality'], 15.5)
-        self.assertEqual(message['demodulator_type'], 2)
-        self.assertEqual(message['error_count'], 10)
-        self.assertEqual(message['distance'], 30.9)
-        self.assertEqual(message['bearing'], 99.5)
-        self.assertEqual(message['phi'], 1.1)
-        self.assertEqual(message['multichannel'], True)
+        assert message['pps_offset'] == 0.181
+        assert message['frequency'] == 868.394
+        assert message['aircraft_type'] == 1
+        assert message['address_type'] == 2
+        assert message['address'] == 'DDA411'
+        assert message['timestamp'] == datetime(2015, 1, 1, 10, 30, 10)
+        assert message['latitude'] == 50.868
+        assert message['longitude'] == 12.15279
+        assert message['altitude'] == 988
+        assert message['climb_rate'] == 0.1
+        assert message['ground_speed'] == 25.7
+        assert message['track'] == 85.4
+        assert message['turn_rate'] == -3.5
+        assert message['magic_number'] == 5  # the '5' is a magic number... 1 if ground_speed is 0.0m/s an 3 or 5 if airborne. Do you have an idea what it is?
+        assert message['gps_status'] == '03x04'
+        assert message['channel'] == 1
+        assert message['flarm_timeslot'] is True
+        assert message['ogn_timeslot'] is False
+        assert message['frequency_offset'] == -12.61
+        assert message['decode_quality'] == 5.8
+        assert message['signal_quality'] == 15.5
+        assert message['demodulator_type'] == 2
+        assert message['error_count'] == 10
+        assert message['distance'] == 30.9
+        assert message['bearing'] == 99.5
+        assert message['phi'] == 1.1
+        assert message['multichannel'] is True
 
     def test_telnet_parse_corrupt(self):
         message = parse('0.397sec:868.407MHz:  sA:1:784024 205656: [  +5.71003, +20.48951]deg 34012m +14.5m/s 109.7m/s 118.5deg +21.0deg/sec 0 27x40m 01_o +7.03kHz 17.2/27.0dB/2 12e 4719.5km 271.1deg  -8.5deg   ?     R     B34067')
diff --git a/tests/parser/test_parse_tracker.py b/tests/parser/test_parse_tracker.py
index 9b69271..b874f46 100644
--- a/tests/parser/test_parse_tracker.py
+++ b/tests/parser/test_parse_tracker.py
@@ -8,39 +8,39 @@ class TestStringMethods(unittest.TestCase):
     def test_position_comment(self):
         message = TrackerParser().parse_position("id072FD00F -058fpm +1.1rot FL003.12 32.8dB 0e -0.8kHz gps3x5 +12.7dBm")
 
-        self.assertEqual(message['address_type'], 3)
-        self.assertEqual(message['aircraft_type'], 1)
+        assert message['address_type'] == 3
+        assert message['aircraft_type'] == 1
         self.assertFalse(message['stealth'])
-        self.assertEqual(message['address'], "2FD00F")
+        assert message['address'] == "2FD00F"
         self.assertAlmostEqual(message['climb_rate'], -58 * FPM_TO_MS, 2)
-        self.assertEqual(message['turn_rate'], 1.1 * HPM_TO_DEGS)
-        self.assertEqual(message['flightlevel'], 3.12)
-        self.assertEqual(message['signal_quality'], 32.8)
-        self.assertEqual(message['error_count'], 0)
-        self.assertEqual(message['frequency_offset'], -0.8)
-        self.assertEqual(message['gps_quality'], {'horizontal': 3, 'vertical': 5})
-        self.assertEqual(message['signal_power'], 12.7)
+        assert message['turn_rate'] == 1.1 * HPM_TO_DEGS
+        assert message['flightlevel'] == 3.12
+        assert message['signal_quality'] == 32.8
+        assert message['error_count'] == 0
+        assert message['frequency_offset'] == -0.8
+        assert message['gps_quality'] == {'horizontal': 3, 'vertical': 5}
+        assert message['signal_power'] == 12.7
 
     def test_status_comment(self):
         message = TrackerParser().parse_status("h00 v00 9sat/1 164m 1002.6hPa +20.2degC 0% 3.34V 14/-110.5dBm 1/min")
 
-        self.assertEqual(message['hardware_version'], 0)
-        self.assertEqual(message['software_version'], 0)
-        self.assertEqual(message['gps_satellites'], 9)
-        self.assertEqual(message['gps_quality'], 1)
-        self.assertEqual(message['gps_altitude'], 164)
-        self.assertEqual(message['pressure'], 1002.6)
-        self.assertEqual(message['temperature'], 20.2)
-        self.assertEqual(message['humidity'], 0)
-        self.assertEqual(message['voltage'], 3.34)
-        self.assertEqual(message['transmitter_power'], 14)
-        self.assertEqual(message['noise_level'], -110.5)
-        self.assertEqual(message['relays'], 1)
+        assert message['hardware_version'] == 0
+        assert message['software_version'] == 0
+        assert message['gps_satellites'] == 9
+        assert message['gps_quality'] == 1
+        assert message['gps_altitude'] == 164
+        assert message['pressure'] == 1002.6
+        assert message['temperature'] == 20.2
+        assert message['humidity'] == 0
+        assert message['voltage'] == 3.34
+        assert message['transmitter_power'] == 14
+        assert message['noise_level'] == -110.5
+        assert message['relays'] == 1
 
     def test_status_comment_comment(self):
         message = TrackerParser().parse_status("Pilot=Pawel Hard=DIY/STM32")
 
-        self.assertEqual(message['comment'], "Pilot=Pawel Hard=DIY/STM32")
+        assert message['comment'] == "Pilot=Pawel Hard=DIY/STM32"
 
 
 if __name__ == '__main__':
diff --git a/tests/parser/test_utils.py b/tests/parser/test_utils.py
index 405e1a2..ca1d245 100644
--- a/tests/parser/test_utils.py
+++ b/tests/parser/test_utils.py
@@ -11,7 +11,7 @@ class TestStringMethods(unittest.TestCase):
     def proceed_test_data(self, test_data={}):
         for test in test_data:
             timestamp = createTimestamp(test[0], reference_timestamp=test[1])
-            self.assertEqual(timestamp, test[2])
+            assert timestamp == test[2]
 
     def test_createTimestamp_hhmmss(self):
         test_data = [