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
129
130
131
|
import logging
import random
import time
from unittest import mock
from chirp import chirp_common
from chirp import errors
from chirp.wxui import serialtrace
from tests import base
LOG = logging.getLogger(__name__)
class SerialException(Exception):
pass
class SerialNone(serialtrace.SerialTrace):
def flush(self):
pass
def inWaiting(self):
return len(self.read(256))
def read(self, size=None):
return b""
def write(self, data):
if not isinstance(data, bytes):
raise TypeError('Radio wrote non-bytes to serial')
def setBaudrate(self, rate):
pass
def setTimeout(self, timeout):
pass
def setParity(self, parity):
pass
def __str__(self):
return self.__class__.__name__.replace("Serial", "")
class SerialError(SerialNone):
def read(self, size=None):
raise SerialException("Foo")
def write(self, data):
raise SerialException("Bar")
class SerialGarbage(SerialNone):
def read(self, size=None):
if size is None:
size = random.randint(0, 128)
buf = []
for i in range(0, size):
buf.append(i % 256)
return bytes(buf)
class SerialShortGarbage(SerialNone):
def read(self, size=None):
if size is None:
size = random.randint(0, 128)
return b'\x01' * (size - 1)
class TestCaseClone(base.DriverTest):
def setUp(self):
super().setUp()
self.live = isinstance(self.radio, chirp_common.LiveRadio)
self.clone = isinstance(self.radio, chirp_common.CloneModeRadio)
if not self.clone and not self.live:
self.skipTest('Does not support clone')
real_time = time.time
def fake_time():
return real_time() * 1000
self.patches = []
self.use_patch(mock.patch('time.sleep'))
self.use_patch(mock.patch('time.time',
side_effect=fake_time))
def _test_with_serial(self, serial):
# The base case sets us up with a file, so re-init with our serial.
# The radio must not read (or fail) with unexpected/error serial
# behavior on init.
LOG.info('Initializing radio with fake serial; Radio should not fail')
orig_mmap = self.parent._mmap
try:
cls = self.RADIO_CLASS.detect_from_serial(serial)
if cls and cls != self.RADIO_CLASS:
self.fail('Radio detection did not return self')
except NotImplementedError:
pass
except errors.RadioError:
pass
except SerialException:
pass
self.radio = self.RADIO_CLASS(serial)
self.radio._mmap = orig_mmap
self.radio.status_fn = lambda s: True
msg = ('Clone should have failed and raised an exception '
'that inherits from RadioError')
with self.assertRaises(errors.RadioError, msg=msg):
self.radio.sync_in()
msg = ('Clone should have failed and raised an exception '
'that inherits from RadioError')
with self.assertRaises(errors.RadioError, msg=msg):
self.radio.sync_out()
def test_clone_serial_error(self):
self._test_with_serial(SerialError())
def test_clone_serial_none(self):
self._test_with_serial(SerialNone())
def test_clone_serial_garbage(self):
self._test_with_serial(SerialGarbage())
def test_clone_serial_short_garbage(self):
self._test_with_serial(SerialShortGarbage())
|
