mirror of
https://github.com/kk7ds/chirp
synced 2026-08-13 17:51:36 -04:00
300 lines
10 KiB
Python
300 lines
10 KiB
Python
# Copyright 2013 Dan Smith <dsmith@danplanet.com>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from unittest import mock
|
|
|
|
from tests.unit import base
|
|
from chirp import chirp_common
|
|
from chirp.drivers import icf
|
|
|
|
|
|
class TestBaseMapping(base.BaseTest):
|
|
CLS = chirp_common.MemoryMapping
|
|
|
|
def test_mapping(self):
|
|
model = chirp_common.MappingModel(None, 'Foo')
|
|
mapping = self.CLS(model, 1, 'Foo')
|
|
self.assertEqual(str(mapping), 'Foo')
|
|
self.assertEqual(mapping.get_name(), 'Foo')
|
|
self.assertEqual(mapping.get_index(), 1)
|
|
self.assertEqual(repr(mapping), '%s-1' % self.CLS.__name__)
|
|
self.assertEqual(mapping._model, model)
|
|
|
|
def test_mapping_eq(self):
|
|
mapping1 = self.CLS(None, 1, 'Foo')
|
|
mapping2 = self.CLS(None, 1, 'Bar')
|
|
mapping3 = self.CLS(None, 2, 'Foo')
|
|
|
|
self.assertEqual(mapping1, mapping2)
|
|
self.assertNotEqual(mapping1, mapping3)
|
|
|
|
|
|
class TestBaseBank(TestBaseMapping):
|
|
CLS = chirp_common.Bank
|
|
|
|
|
|
class _TestBaseClass(base.BaseTest):
|
|
ARGS = tuple()
|
|
|
|
def setUp(self):
|
|
super(_TestBaseClass, self).setUp()
|
|
self.model = self.CLS(*self.ARGS)
|
|
|
|
def _test_base(self, method, *args):
|
|
self.assertRaises(NotImplementedError,
|
|
getattr(self.model, method), *args)
|
|
|
|
|
|
class TestBaseMappingModel(_TestBaseClass):
|
|
CLS = chirp_common.MappingModel
|
|
ARGS = tuple([None, 'Foo'])
|
|
|
|
def test_base_class(self):
|
|
methods = [('get_num_mappings', ()),
|
|
('get_mappings', ()),
|
|
('add_memory_to_mapping', (None, None)),
|
|
('remove_memory_from_mapping', (None, None)),
|
|
('get_mapping_memories', (None,)),
|
|
('get_memory_mappings', (None,)),
|
|
]
|
|
for method, args in methods:
|
|
self._test_base(method, *args)
|
|
|
|
def test_get_name(self):
|
|
self.assertEqual(self.model.get_name(), 'Foo')
|
|
|
|
|
|
class TestBaseBankModel(TestBaseMappingModel):
|
|
ARGS = tuple([None])
|
|
CLS = chirp_common.BankModel
|
|
|
|
def test_get_name(self):
|
|
self.assertEqual(self.model.get_name(), 'Banks')
|
|
|
|
|
|
class TestBaseMappingModelIndexInterface(_TestBaseClass):
|
|
CLS = chirp_common.MappingModelIndexInterface
|
|
|
|
def test_base_class(self):
|
|
methods = [('get_index_bounds', ()),
|
|
('get_memory_index', (None, None)),
|
|
('set_memory_index', (None, None, None)),
|
|
('get_next_mapping_index', (None,)),
|
|
]
|
|
for method, args in methods:
|
|
self._test_base(method, *args)
|
|
|
|
|
|
class TestIcomBanks(TestBaseMapping):
|
|
def test_icom_bank(self):
|
|
bank = icf.IcomBank(None, 1, 'Foo')
|
|
# IcomBank has an index attribute used by IcomBankModel
|
|
self.assertTrue(hasattr(bank, 'index'))
|
|
|
|
|
|
class TestIcomBankModel(base.BaseTest):
|
|
CLS = icf.IcomBankModel
|
|
|
|
def _get_rf(self):
|
|
rf = chirp_common.RadioFeatures()
|
|
rf.memory_bounds = (1, 10)
|
|
return rf
|
|
|
|
def setUp(self):
|
|
super(TestIcomBankModel, self).setUp()
|
|
|
|
class FakeRadio(icf.IcomCloneModeRadio):
|
|
_num_banks = 10
|
|
_bank_index_bounds = (0, 10)
|
|
|
|
def get_features(the_radio):
|
|
return self._get_rf()
|
|
|
|
def _set_bank(self, number, index):
|
|
pass
|
|
|
|
def _get_bank(self, number):
|
|
pass
|
|
|
|
def _get_bank_index(self, number):
|
|
pass
|
|
|
|
def _set_bank_index(self, number, index):
|
|
pass
|
|
|
|
def get_memory(self, number):
|
|
pass
|
|
|
|
self._radio = FakeRadio(None)
|
|
self._model = self.CLS(self._radio)
|
|
for a in ('_set_bank', '_get_bank', '_set_bank_index',
|
|
'_get_bank_index', 'get_memory'):
|
|
m = mock.patch.object(self._radio, a)
|
|
m.start()
|
|
self.mocks.append(m)
|
|
|
|
def test_get_num_mappings(self):
|
|
self.assertEqual(self._model.get_num_mappings(), 10)
|
|
|
|
def test_get_mappings(self):
|
|
banks = self._model.get_mappings()
|
|
self.assertEqual(len(banks), 10)
|
|
i = 0
|
|
for bank in banks:
|
|
index = chr(ord("A") + i)
|
|
self.assertEqual(bank.get_index(), index)
|
|
self.assertEqual(bank.get_name(), 'BANK-%s' % index)
|
|
self.assertEqual(bank.index, i)
|
|
i += 1
|
|
|
|
def test_add_memory_to_mapping(self):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
banks = self._model.get_mappings()
|
|
bank = banks[2]
|
|
self._model.add_memory_to_mapping(mem, bank)
|
|
self._radio._set_bank.assert_called_once_with(5, 2)
|
|
|
|
def _setup_test_remove_memory_from_mapping(self, curbank):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
banks = self._model.get_mappings()
|
|
bank = banks[2]
|
|
self._radio._get_bank.return_value = curbank
|
|
return mem, bank
|
|
|
|
def test_remove_memory_from_mapping(self):
|
|
mem, bank = self._setup_test_remove_memory_from_mapping(2)
|
|
self._model.remove_memory_from_mapping(mem, bank)
|
|
self._radio._get_bank.assert_called_once_with(5)
|
|
self._radio._set_bank.assert_called_once_with(5, None)
|
|
|
|
def test_remove_memory_from_mapping_wrong_bank(self):
|
|
mem, bank = self._setup_test_remove_memory_from_mapping(3)
|
|
self.assertRaises(Exception,
|
|
self._model.remove_memory_from_mapping, mem, bank)
|
|
|
|
def test_remove_memory_from_mapping_no_bank(self):
|
|
mem, bank = self._setup_test_remove_memory_from_mapping(None)
|
|
self.assertRaises(Exception,
|
|
self._model.remove_memory_from_mapping, mem, bank)
|
|
|
|
def test_get_mapping_memories(self):
|
|
banks = self._model.get_mappings()
|
|
expected = []
|
|
_get_bank = []
|
|
for i in range(1, 10):
|
|
should_include = bool(i % 2)
|
|
_get_bank.append(
|
|
should_include and banks[1].index or None)
|
|
if should_include:
|
|
expected.append(i)
|
|
self._radio._get_bank.side_effect = _get_bank
|
|
self._radio.get_memory.side_effect = expected
|
|
members = self._model.get_mapping_memories(banks[1])
|
|
self.assertEqual(members, expected)
|
|
self._radio.get_memory.assert_has_calls([
|
|
mock.call(i) for i in range(1, 10) if i % 2])
|
|
self._radio._get_bank.assert_has_calls([
|
|
mock.call(i) for i in range(1, 10)])
|
|
|
|
def test_get_memory_mappings(self):
|
|
banks = self._model.get_mappings()
|
|
mem1 = chirp_common.Memory()
|
|
mem1.number = 5
|
|
mem2 = chirp_common.Memory()
|
|
mem2.number = 6
|
|
self._radio._get_bank.side_effect = [2, None]
|
|
self.assertEqual(self._model.get_memory_mappings(mem1)[0], banks[2])
|
|
self.assertEqual(self._model.get_memory_mappings(mem2), [])
|
|
self._radio._get_bank.assert_has_calls([
|
|
mock.call(mem1.number), mock.call(mem2.number)])
|
|
|
|
|
|
class TestIcomIndexedBankModel(TestIcomBankModel):
|
|
CLS = icf.IcomIndexedBankModel
|
|
|
|
def _get_rf(self):
|
|
rf = super(TestIcomIndexedBankModel, self)._get_rf()
|
|
rf.has_bank_index = True
|
|
return rf
|
|
|
|
def test_get_index_bounds(self):
|
|
self.assertEqual(self._model.get_index_bounds(), (0, 10))
|
|
|
|
def test_get_memory_index(self):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
self._radio._get_bank_index.return_value = 1
|
|
self.assertEqual(self._model.get_memory_index(mem, None), 1)
|
|
self._radio._get_bank_index.assert_called_once_with(mem.number)
|
|
|
|
def test_set_memory_index(self):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
banks = self._model.get_mappings()
|
|
with mock.patch.object(self._model, 'get_memory_mappings') as m:
|
|
m.return_value = [banks[3]]
|
|
self._model.set_memory_index(mem, banks[3], 1)
|
|
m.assert_called_once_with(mem)
|
|
self._radio._set_bank_index.assert_called_once_with(mem.number, 1)
|
|
|
|
def test_set_memory_index_bad_bank(self):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
banks = self._model.get_mappings()
|
|
with mock.patch.object(self._model, 'get_memory_mappings') as m:
|
|
m.return_value = [banks[4]]
|
|
self.assertRaises(Exception,
|
|
self._model.set_memory_index, mem, banks[3], 1)
|
|
m.assert_called_once_with(mem)
|
|
|
|
def test_set_memory_index_bad_index(self):
|
|
mem = chirp_common.Memory()
|
|
mem.number = 5
|
|
banks = self._model.get_mappings()
|
|
with mock.patch.object(self._model, 'get_memory_mappings') as m:
|
|
m.return_value = [banks[3]]
|
|
self.assertRaises(Exception,
|
|
self._model.set_memory_index, mem, banks[3], 99)
|
|
m.assert_called_once_with(mem)
|
|
|
|
def test_get_next_mapping_index(self):
|
|
banks = self._model.get_mappings()
|
|
bank_exp_calls = []
|
|
index_exp_calls = []
|
|
bank_returns = []
|
|
index_returns = []
|
|
for i in range(*self._radio.get_features().memory_bounds):
|
|
bank_returns.append((i % 2) and banks[1].index)
|
|
bank_exp_calls.append(mock.call(i))
|
|
if bool(i % 2):
|
|
index_returns.append(i)
|
|
index_exp_calls.append(mock.call(i))
|
|
idx = 0
|
|
for i in range(*self._radio.get_features().memory_bounds):
|
|
bank_exp_calls.append(mock.call(i))
|
|
bank_returns.append((i % 2) and banks[2].index)
|
|
if i % 2:
|
|
index_exp_calls.append(mock.call(i))
|
|
index_returns.append(idx)
|
|
idx += 1
|
|
|
|
self._radio._get_bank.side_effect = bank_returns
|
|
self._radio._get_bank_index.side_effect = index_returns
|
|
self.assertEqual(self._model.get_next_mapping_index(banks[1]), 0)
|
|
self.assertEqual(self._model.get_next_mapping_index(banks[2]), 5)
|
|
self._radio._get_bank.assert_has_calls(bank_exp_calls)
|
|
self._radio._get_bank_index.assert_has_calls(index_exp_calls)
|