Initial Commit

1 files changed, 151 insertions, 0 deletions

diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..d04e516
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1,151 @@
+import glob
+import logging
+import os
+import re
+import shutil
+import sys
+import tempfile
+import unittest
+
+import six
+
+from chirp import directory
+
+from tests import run_tests
+
+
+LOG = logging.getLogger('testadapter')
+
+
+class TestAdapterMeta(type):
+    def __new__(cls, name, parents, dct):
+        return super(TestAdapterMeta, cls).__new__(cls, name, parents, dct)
+
+
+class TestAdapter(unittest.TestCase):
+    RADIO_CLASS = None
+    SOURCE_IMAGE = None
+    RADIO_INST = None
+    testwrapper = None
+
+    def shortDescription(self):
+        test = self.id().split('.')[-1].replace('test_', '').replace('_', ' ')
+        return 'Testing %s %s' % (self.RADIO_CLASS.get_name(), test)
+
+    @classmethod
+    def setUpClass(cls):
+        if not cls.testwrapper:
+            # Initialize the radio once per class invocation to save
+            # bitwise parse time
+            # Do this for things like Generic_CSV, that demand it
+            _base, ext = os.path.splitext(cls.SOURCE_IMAGE)
+            cls.testimage = tempfile.mktemp(ext)
+            shutil.copy(cls.SOURCE_IMAGE, cls.testimage)
+            cls.testwrapper = run_tests.TestWrapper(cls.RADIO_CLASS,
+                                                    cls.testimage)
+
+    @classmethod
+    def tearDownClass(cls):
+        os.remove(cls.testimage)
+
+    def _runtest(self, test):
+        tw = run_tests.TestWrapper(self.RADIO_CLASS,
+                                   self.testimage,
+                                   dst=self.RADIO_INST)
+        testcase = test(tw)
+        testcase.prepare()
+        try:
+            failures = testcase.run()
+            if failures:
+                raise failures[0]
+        except run_tests.TestCrashError as e:
+            raise e.get_original_exception()
+        except run_tests.TestSkippedError as e:
+            raise unittest.SkipTest(str(e))
+        finally:
+            testcase.cleanup()
+
+    def test_copy_all(self):
+        self._runtest(run_tests.TestCaseCopyAll)
+
+    def test_brute_force(self):
+        self._runtest(run_tests.TestCaseBruteForce)
+
+    def test_edges(self):
+        self._runtest(run_tests.TestCaseEdges)
+
+    def test_settings(self):
+        self._runtest(run_tests.TestCaseSettings)
+
+    def test_banks(self):
+        self._runtest(run_tests.TestCaseBanks)
+
+    def test_detect(self):
+        self._runtest(run_tests.TestCaseDetect)
+
+    def test_clone(self):
+        self._runtest(run_tests.TestCaseClone)
+
+
+def _get_sub_devices(rclass, testimage):
+    try:
+        tw = run_tests.TestWrapper(rclass, None)
+    except Exception as e:
+        tw = run_tests.TestWrapper(rclass, testimage)
+
+    rf = tw.do("get_features")
+    if rf.has_sub_devices:
+        return tw.do("get_sub_devices")
+    else:
+        return [rclass]
+
+
+class RadioSkipper(unittest.TestCase):
+    def test_is_supported_by_environment(self):
+        raise unittest.SkipTest('Running in py3 and driver is not supported')
+
+
+def load_tests(loader, tests, pattern, suite=None):
+    if not suite:
+        suite = unittest.TestSuite()
+
+    base = os.path.dirname(os.path.abspath(__file__))
+    base = os.path.join(base, 'images')
+    images = glob.glob(os.path.join(base, "*"))
+    tests = {img: os.path.splitext(os.path.basename(img))[0] for img in images}
+
+    if pattern == 'test*.py':
+        # This default is meaningless for us
+        pattern = None
+
+    for image, test in tests.items():
+        try:
+            rclass = directory.get_radio(test)
+        except Exception:
+            if six.PY3 and 'CHIRP_DEBUG' in os.environ:
+                LOG.error('Failed to load %s' % test)
+                continue
+            raise
+        for device in _get_sub_devices(rclass, image):
+            class_name = 'TestCase_%s' % (
+                ''.join(filter(lambda c: c.isalnum(),
+                               device.get_name())))
+            if isinstance(device, type):
+                dst = None
+            else:
+                dst = device
+                device = device.__class__
+            tc = TestAdapterMeta(
+                class_name, (TestAdapter,), dict(RADIO_CLASS=device,
+                                                 SOURCE_IMAGE=image,
+                                                 RADIO_INST=dst))
+            tests = loader.loadTestsFromTestCase(tc)
+
+            if pattern:
+                tests = [t for t in tests
+                         if re.search(pattern, '%s.%s' % (class_name,
+                                                          t._testMethodName))]
+
+            suite.addTests(tests)
+
+    return suite