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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
import pytest
from unittest import mock
from chirp import bitwise
from chirp import chirp_common
from chirp import directory
from chirp import errors
from tests import base
class TestCaseEdges(base.DriverTest):
def test_inherits_from_registered(self):
if self.rf.has_sub_devices:
devs = self.radio.get_sub_devices()
else:
devs = [self.radio]
for dev in devs:
directory.registered_class(dev.__class__)
def test_longname(self):
m = self.get_mem()
m.name = ("X" * 256) # Should be longer than any radio can handle
m.name = self.radio.filter_name(m.name)
self.radio.set_memory(m)
n = self.radio.get_memory(m.number)
self.assertEqualMem(m, n)
def test_badname(self):
m = self.get_mem()
ascii = "".join([chr(x) for x in range(ord(" "), ord("~")+1)])
for i in range(0, len(ascii), 4):
m.name = self.radio.filter_name(ascii[i:i+4])
self.radio.set_memory(m)
n = self.radio.get_memory(m.number)
self.assertEqualMem(m, n)
def test_bandedges(self):
m = self.get_mem()
min_step = min(self.rf.has_tuning_step and
self.rf.valid_tuning_steps or [10])
for low, high in self.rf.valid_bands:
for freq in (low, high - int(min_step * 1000)):
try:
m.freq = freq
except chirp_common.ImmutableValueError:
self.skipTest('Test memory has immutable freq')
if self.radio.validate_memory(m):
# Radio doesn't like it, so skip
continue
self.radio.set_memory(m)
n = self.radio.get_memory(m.number)
self.assertEqualMem(m, n)
def test_oddsteps(self):
odd_steps = {
145000000: [145856250, 145862500],
445000000: [445856250, 445862500],
862000000: [862731250, 862737500],
}
m = self.get_mem()
for low, high in self.rf.valid_bands:
for band, totest in list(odd_steps.items()):
if band < low or band > high:
continue
for testfreq in totest:
step = chirp_common.required_step(testfreq)
if step not in self.rf.valid_tuning_steps:
continue
try:
m.freq = testfreq
except chirp_common.ImmutableValueError:
self.skipTest('Test channel has immutable freq')
m.tuning_step = step
self.radio.set_memory(m)
n = self.radio.get_memory(m.number)
# Some radios have per-band required modes, which we
# don't care about testing here
self.assertEqualMem(m, n, ignore=['tuning_step',
'mode'])
def test_empty_to_not(self):
firstband = self.rf.valid_bands[0]
testfreq = firstband[0]
for loc in range(*self.rf.memory_bounds):
m = self.radio.get_memory(loc)
if m.empty:
m.empty = False
m.freq = testfreq
self.radio.set_memory(m)
m = self.radio.get_memory(loc)
self.assertEqual(testfreq, m.freq,
'Radio returned an unexpected frequency when'
'setting previously-empty location %i' % loc)
break
def test_delete_memory(self):
for loc in range(*self.rf.memory_bounds):
m = self.radio.get_memory(loc)
if 'empty' in m.immutable:
# This memory is not deletable
continue
if not m.empty:
m.empty = True
self.radio.set_memory(m)
m = self.radio.get_memory(loc)
self.assertTrue(m.empty,
'Radio returned non-empty memory when asked '
'to delete location %i' % loc)
break
def test_redelete_memory(self):
m = self.get_mem()
if 'empty' in m.immutable:
self.skipTest('Test memory is not deletable')
# Delete this memory
m.empty = True
self.radio.set_memory(m)
# Try to delete it again
self.radio.set_memory(m)
# Make sure it appears deleted
m2 = self.radio.get_memory(m.number)
self.assertTrue(m2.empty)
def test_get_set_specials(self):
if not self.rf.valid_special_chans:
self.skipTest('Radio has no specials')
lo, hi = self.rf.memory_bounds
for name in self.rf.valid_special_chans:
m1 = self.radio.get_memory(name)
# Flip to non-empty, but only touch it if it's false because some
# radios have empty in the immutable set.
if m1.empty:
m1.empty = False
self.assertIsInstance(m1.number, int,
('Special memory %s number %r is not an '
'integer') % (name, m1.number))
try:
del m1.extra
except AttributeError:
pass
if m1.freq > 130000000 and m1.freq < 500000000:
m1.freq += 5000
elif m1.freq == 0:
# If the memory was empty before, we likely need to pick
# a valid frequency. Use the bottom of the first supported
# band.
m1.freq = self.rf.valid_bands[0][0]
try:
self.radio.set_memory(m1)
except errors.RadioError:
# If the radio raises RadioError, assume we're editing a
# special channel that is not editable
continue
m2 = self.radio.get_memory(name)
self.assertEqualMem(m1, m2, ignore=['name'])
self.assertFalse(
lo < m1.number < hi,
'Special memory %s maps into memory bounds at %i' % (
name, m1.number))
def test_check_regular_not_special(self):
lo, hi = self.rf.memory_bounds
for i in range(lo, hi + 1):
m = self.radio.get_memory(i)
self.assertEqual('', m.extd_number,
'Non-special memory %i should not have '
'extd_number set to %r' % (i, m.extd_number))
self.assertIsInstance(m.number, int,
'Memory number %r is not an integer' %
m.number)
def test_get_memory_name_trailing_whitespace(self):
if self.radio.MODEL == 'KG-UV8E':
self.skipTest('The UV8E driver is so broken it does not even '
'parse its own test image cleanly')
for i in range(*self.rf.memory_bounds):
m = self.radio.get_memory(i)
self.assertEqual(m.name.rstrip(), m.name,
'Radio returned a memory with trailing '
'whitespace in the name')
def test_memory_name_stripped(self):
if ' ' not in self.rf.valid_characters:
self.skipTest('Radio does not support space characters')
m1 = self.get_mem()
m1.name = 'FOO '
self.radio.set_memory(m1)
m2 = self.radio.get_memory(m1.number)
self.assertEqual(m2.name.rstrip(), m2.name,
'Radio set and returned a memory with trailing '
'whitespace in the name')
class TestBitwiseStrict(base.DriverTest):
def setUp(self):
pass
def _raise(self, message):
raise SyntaxError(message)
@pytest.mark.xfail(strict=False)
@mock.patch.object(bitwise.Processor, 'assert_negative_seek',
side_effect=_raise)
def test_bitwise_negative_seek(self, mock_assert):
super().setUp()
@pytest.mark.xfail(strict=False)
@mock.patch.object(bitwise.Processor, 'assert_unnecessary_seek',
side_effect=_raise)
def test_bitwise_unnecessary_seek(self, mock_assert):
super().setUp()
@mock.patch.object(bitwise.LOG, 'error')
def test_bitwise_errors(self, mock_log):
super().setUp()
self.assertFalse(mock_log.called,
[x[0][0] for x in mock_log.call_args_list])
|
