TestProtocolsCan.test_create_data() - Code Metrics - s-s-boika/obdlib - Measure and Improve Code Quality continuously with Scrutinizer

TestProtocolsCan.test_create_data() A
last analyzed 2017-02-09 09:22 UTC

↳ Parent: TestProtocolsCan

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	8
Bugs	0	Features	0

Metric	Value
c	8
b	0
f	0
dl	0
loc	57
rs	9.6818
cc	1

How to fix Long Method

import unittest
import sys

if sys.version_info[0] < 3:
    import mock
else:
    import unittest.mock as mock
import obdlib.obd.protocols.can_protocols as p_can


class TestProtocolsCan(unittest.TestCase):
    def setUp(self):
        self.pc = p_can.ProtocolsCan(6)

    def test___get_bits(self):
        bits = self.pc._ProtocolsCan__get_bits(6)
        self.assertEqual(bits, 11)

    def test___digit(self):
        digit = self.pc._ProtocolsCan__digit('A')
        self.assertEqual(digit, 10)

    def test___last_bytes(self):
        expected = 12
        self.pc.frame_start = 4
        last = self.pc._ProtocolsCan__last_bytes(4)
        self.assertEqual(last, expected)

    def test___align_frame(self):
        frame = self.pc._ProtocolsCan__align_frame(['7E8064100FFFFFFFFFC'])
        self.assertIn('000007E8064100FFFFFFFFFC', frame)

    def test___get_single_data(self):
        data = self.pc._ProtocolsCan__get_single_data('000007E8064100FFFFFFFFFC')
        self.assertEqual(data, 'FFFFFFFF')

    def test___get_frame_params(self):
        params = self.pc._ProtocolsCan__get_frame_params('000007E8064100FFFFFFFFFC')
        self.assertIsInstance(params, tuple)
        self.assertEqual(params[0], 'E8')  # ECU
        self.assertEqual(params[1], 0)  # Frame type
        self.assertEqual(params[2], 41)  # Mode

    @mock.patch('sys.stdout')
    def test_create_data(self, mock_out):
        # NO DATA
        response = ['NODATA']
        data = self.pc.create_data(response)
        self.assertEqual(len(data), 0)

        # If error 7F...
        response = ['7F0112']
        data = self.pc.create_data(response)
        self.assertEqual(len(data), 0)

        # If raw_data
        #
        # Single frame 11 bits
        response = [
            '7E8064100FFFFFFFFFC'
        ]
        data = self.pc.create_data(response)
        self.assertEqual(data, {'E8': 'FFFFFFFF'})

        # Single frame 29 bits
        response = [
            '18DAF110064100FFFFFFFFFC'
        ]
        pc = p_can.ProtocolsCan(7)
        data = pc.create_data(response)
        self.assertEqual(data, {'10': 'FFFFFFFF'})

        # Multi line frame 11 bits
        response = [
            '7E81013490401353630',
            '7E82200000000000031',
            '7E82132383934394143'
        ]
        data = self.pc.create_data(response)
        self.assertEqual(data, {'E8': '134904013536303238393439414300000000000031'})

        # Multi line frame 29 bits
        pc = p_can.ProtocolsCan(7)
        response = [
            '18DAF1101013490401353630',
            '18DAF1102200000000000031',
            '18DAF1102132383934394143'
        ]
        data = pc.create_data(response)
        self.assertEqual(data, {'10': '134904013536303238393439414300000000000031'})

        # Single frame 11 bits BUT 2 ECU's
        response = [
            '7E8064100FFFFFFFFFC',
            '7E9064100FFFFFF00FC'
        ]
        data = self.pc.create_data(response)
        self.assertEqual(data, {
            'E8': 'FFFFFFFF',
            'E9': 'FFFFFF00'
        })


suite = unittest.TestLoader().loadTestsFromTestCase(TestProtocolsCan)
unittest.TextTestRunner(verbosity=2).run(suite)


1			import unittest
2			import sys
3
4			if sys.version_info[0] < 3:
5			import mock
6			else:
7			import unittest.mock as mock
8			import obdlib.obd.protocols.can_protocols as p_can
9
10
11			class TestProtocolsCan(unittest.TestCase):
12			def setUp(self):
13			self.pc = p_can.ProtocolsCan(6)
14
15			def test___get_bits(self):
16			bits = self.pc._ProtocolsCan__get_bits(6)
17			self.assertEqual(bits, 11)
18
19			def test___digit(self):
20			digit = self.pc._ProtocolsCan__digit('A')
21			self.assertEqual(digit, 10)
22
23			def test___last_bytes(self):
24			expected = 12
25			self.pc.frame_start = 4
26			last = self.pc._ProtocolsCan__last_bytes(4)
27			self.assertEqual(last, expected)
28
29			def test___align_frame(self):
30			frame = self.pc._ProtocolsCan__align_frame(['7E8064100FFFFFFFFFC'])
31			self.assertIn('000007E8064100FFFFFFFFFC', frame)
32
33			def test___get_single_data(self):
34			data = self.pc._ProtocolsCan__get_single_data('000007E8064100FFFFFFFFFC')
35			self.assertEqual(data, 'FFFFFFFF')
36
37			def test___get_frame_params(self):
38			params = self.pc._ProtocolsCan__get_frame_params('000007E8064100FFFFFFFFFC')
39			self.assertIsInstance(params, tuple)
40			self.assertEqual(params[0], 'E8') # ECU
41			self.assertEqual(params[1], 0) # Frame type
42			self.assertEqual(params[2], 41) # Mode
43
44			@mock.patch('sys.stdout')
45			def test_create_data(self, mock_out):
46			# NO DATA
47			response = ['NODATA']
48			data = self.pc.create_data(response)
49			self.assertEqual(len(data), 0)
50
51			# If error 7F...
52			response = ['7F0112']
53			data = self.pc.create_data(response)
54			self.assertEqual(len(data), 0)
55
56			# If raw_data
57			#
58			# Single frame 11 bits
59			response = [
60			'7E8064100FFFFFFFFFC'
61			]
62			data = self.pc.create_data(response)
63			self.assertEqual(data, {'E8': 'FFFFFFFF'})
64
65			# Single frame 29 bits
66			response = [
67			'18DAF110064100FFFFFFFFFC'
68			]
69			pc = p_can.ProtocolsCan(7)
70			data = pc.create_data(response)
71			self.assertEqual(data, {'10': 'FFFFFFFF'})
72
73			# Multi line frame 11 bits
74			response = [
75			'7E81013490401353630',
76			'7E82200000000000031',
77			'7E82132383934394143'
78			]
79			data = self.pc.create_data(response)
80			self.assertEqual(data, {'E8': '134904013536303238393439414300000000000031'})
81
82			# Multi line frame 29 bits
83			pc = p_can.ProtocolsCan(7)
84			response = [
85			'18DAF1101013490401353630',
86			'18DAF1102200000000000031',
87			'18DAF1102132383934394143'
88			]
89			data = pc.create_data(response)
90			self.assertEqual(data, {'10': '134904013536303238393439414300000000000031'})
91
92			# Single frame 11 bits BUT 2 ECU's
93			response = [
94			'7E8064100FFFFFFFFFC',
95			'7E9064100FFFFFF00FC'
96			]
97			data = self.pc.create_data(response)
98			self.assertEqual(data, {
99			'E8': 'FFFFFFFF',
100			'E9': 'FFFFFF00'
101			})
102
103
104			suite = unittest.TestLoader().loadTestsFromTestCase(TestProtocolsCan)
105			unittest.TextTestRunner(verbosity=2).run(suite)
106

s-s-boika / obdlib

TestProtocolsCan.test_create_data() A last analyzed 2017-02-09 09:22 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

TestProtocolsCan.test_create_data() A
last analyzed 2017-02-09 09:22 UTC