FilesExpand file tree

 develop

/

test_slcan.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

128 lines (106 loc) · 4.15 KB

 develop

/

test_slcan.py

Copy path

Top

File metadata and controls

• Code
• Blame

128 lines (106 loc) · 4.15 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

#!/usr/bin/env python

# coding: utf-8

import unittest

import can

class slcanTestCase(unittest.TestCase):

def setUp(self):

self.bus = can.Bus("loop://", bustype="slcan", sleep_after_open=0)

self.serial = self.bus.serialPortOrig

self.serial.read(self.serial.in_waiting)

def tearDown(self):

self.bus.shutdown()

def test_recv_extended(self):

self.serial.write(b"T12ABCDEF2AA55\r")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

self.assertEqual(msg.arbitration_id, 0x12ABCDEF)

self.assertEqual(msg.is_extended_id, True)

self.assertEqual(msg.is_remote_frame, False)

self.assertEqual(msg.dlc, 2)

self.assertSequenceEqual(msg.data, [0xAA, 0x55])

def test_send_extended(self):

msg = can.Message(

arbitration_id=0x12ABCDEF, is_extended_id=True, data=[0xAA, 0x55]

)

self.bus.send(msg)

data = self.serial.read(self.serial.in_waiting)

self.assertEqual(data, b"T12ABCDEF2AA55\r")

def test_recv_standard(self):

self.serial.write(b"t4563112233\r")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

self.assertEqual(msg.arbitration_id, 0x456)

self.assertEqual(msg.is_extended_id, False)

self.assertEqual(msg.is_remote_frame, False)

self.assertEqual(msg.dlc, 3)

self.assertSequenceEqual(msg.data, [0x11, 0x22, 0x33])

def test_send_standard(self):

msg = can.Message(

arbitration_id=0x456, is_extended_id=False, data=[0x11, 0x22, 0x33]

)

self.bus.send(msg)

data = self.serial.read(self.serial.in_waiting)

self.assertEqual(data, b"t4563112233\r")

def test_recv_standard_remote(self):

self.serial.write(b"r1238\r")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

self.assertEqual(msg.arbitration_id, 0x123)

self.assertEqual(msg.is_extended_id, False)

self.assertEqual(msg.is_remote_frame, True)

self.assertEqual(msg.dlc, 8)

def test_send_standard_remote(self):

msg = can.Message(

arbitration_id=0x123, is_extended_id=False, is_remote_frame=True, dlc=8

)

self.bus.send(msg)

data = self.serial.read(self.serial.in_waiting)

self.assertEqual(data, b"r1238\r")

def test_recv_extended_remote(self):

self.serial.write(b"R12ABCDEF6\r")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

self.assertEqual(msg.arbitration_id, 0x12ABCDEF)

self.assertEqual(msg.is_extended_id, True)

self.assertEqual(msg.is_remote_frame, True)

self.assertEqual(msg.dlc, 6)

def test_send_extended_remote(self):

msg = can.Message(

arbitration_id=0x12ABCDEF, is_extended_id=True, is_remote_frame=True, dlc=6

)

self.bus.send(msg)

data = self.serial.read(self.serial.in_waiting)

self.assertEqual(data, b"R12ABCDEF6\r")

def test_partial_recv(self):

self.serial.write(b"T12ABCDEF")

msg = self.bus.recv(0)

self.assertIsNone(msg)

self.serial.write(b"2AA55\rT12")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

self.assertEqual(msg.arbitration_id, 0x12ABCDEF)

self.assertEqual(msg.is_extended_id, True)

self.assertEqual(msg.is_remote_frame, False)

self.assertEqual(msg.dlc, 2)

self.assertSequenceEqual(msg.data, [0xAA, 0x55])

msg = self.bus.recv(0)

self.assertIsNone(msg)

self.serial.write(b"ABCDEF2AA55\r")

msg = self.bus.recv(0)

self.assertIsNotNone(msg)

def test_version(self):

self.serial.write(b"V1013\r")

hw_ver, sw_ver = self.bus.get_version(0)

self.assertEqual(hw_ver, 10)

self.assertEqual(sw_ver, 13)

hw_ver, sw_ver = self.bus.get_version(0)

self.assertIsNone(hw_ver)

self.assertIsNone(sw_ver)

def test_serial_number(self):

self.serial.write(b"NA123\r")

sn = self.bus.get_serial_number(0)

self.assertEqual(sn, "A123")

sn = self.bus.get_serial_number(0)

self.assertIsNone(sn)

if __name__ == "__main__":

unittest.main()