| # SPDX-License-Identifier: GPL-2.0+ | |
| # Copyright 2020 Google LLC | |
| # | |
| """Tests for the src_scan module | |
| This includes unit tests for scanning of the source code | |
| """ | |
| import copy | |
| import os | |
| import shutil | |
| import tempfile | |
| import unittest | |
| from unittest import mock | |
| from dtoc import src_scan | |
| from u_boot_pylib import test_util | |
| from u_boot_pylib import tools | |
| OUR_PATH = os.path.dirname(os.path.realpath(__file__)) | |
| EXPECT_WARN = {'rockchip_rk3288_grf': | |
| {'WARNING: the driver rockchip_rk3288_grf was not found in the driver list'}} | |
| class FakeNode: | |
| """Fake Node object for testing""" | |
| def __init__(self): | |
| self.name = None | |
| self.props = {} | |
| class FakeProp: | |
| """Fake Prop object for testing""" | |
| def __init__(self): | |
| self.name = None | |
| self.value = None | |
| # This is a test so is allowed to access private things in the module it is | |
| # testing | |
| # pylint: disable=W0212 | |
| class TestSrcScan(unittest.TestCase): | |
| """Tests for src_scan""" | |
| @classmethod | |
| def setUpClass(cls): | |
| tools.prepare_output_dir(None) | |
| @classmethod | |
| def tearDownClass(cls): | |
| tools.finalise_output_dir() | |
| def test_simple(self): | |
| """Simple test of scanning drivers""" | |
| scan = src_scan.Scanner(None, None) | |
| scan.scan_drivers() | |
| self.assertIn('sandbox_gpio', scan._drivers) | |
| self.assertIn('sandbox_gpio_alias', scan._driver_aliases) | |
| self.assertEqual('sandbox_gpio', | |
| scan._driver_aliases['sandbox_gpio_alias']) | |
| self.assertNotIn('sandbox_gpio_alias2', scan._driver_aliases) | |
| def test_additional(self): | |
| """Test with additional drivers to scan""" | |
| scan = src_scan.Scanner( | |
| None, [None, '', 'tools/dtoc/test/dtoc_test_scan_drivers.cxx']) | |
| scan.scan_drivers() | |
| self.assertIn('sandbox_gpio_alias2', scan._driver_aliases) | |
| self.assertEqual('sandbox_gpio', | |
| scan._driver_aliases['sandbox_gpio_alias2']) | |
| def test_unicode_error(self): | |
| """Test running dtoc with an invalid unicode file | |
| To be able to perform this test without adding a weird text file which | |
| would produce issues when using checkpatch.pl or patman, generate the | |
| file at runtime and then process it. | |
| """ | |
| driver_fn = '/tmp/' + next(tempfile._get_candidate_names()) | |
| with open(driver_fn, 'wb+') as fout: | |
| fout.write(b'\x81') | |
| scan = src_scan.Scanner(None, [driver_fn]) | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.scan_drivers() | |
| self.assertRegex(stdout.getvalue(), | |
| r"Skipping file '.*' due to unicode error\s*") | |
| def test_driver(self): | |
| """Test the Driver class""" | |
| i2c = 'I2C_UCLASS' | |
| compat = {'rockchip,rk3288-grf': 'ROCKCHIP_SYSCON_GRF', | |
| 'rockchip,rk3288-srf': None} | |
| drv1 = src_scan.Driver('fred', 'fred.c') | |
| drv2 = src_scan.Driver('mary', 'mary.c') | |
| drv3 = src_scan.Driver('fred', 'fred.c') | |
| drv1.uclass_id = i2c | |
| drv1.compat = compat | |
| drv2.uclass_id = i2c | |
| drv2.compat = compat | |
| drv3.uclass_id = i2c | |
| drv3.compat = compat | |
| self.assertEqual( | |
| "Driver(name='fred', used=False, uclass_id='I2C_UCLASS', " | |
| "compat={'rockchip,rk3288-grf': 'ROCKCHIP_SYSCON_GRF', " | |
| "'rockchip,rk3288-srf': None}, priv=)", str(drv1)) | |
| self.assertEqual(drv1, drv3) | |
| self.assertNotEqual(drv1, drv2) | |
| self.assertNotEqual(drv2, drv3) | |
| def test_scan_dirs(self): | |
| """Test scanning of source directories""" | |
| def add_file(fname): | |
| pathname = os.path.join(indir, fname) | |
| dirname = os.path.dirname(pathname) | |
| os.makedirs(dirname, exist_ok=True) | |
| tools.write_file(pathname, '', binary=False) | |
| fname_list.append(pathname) | |
| try: | |
| indir = tempfile.mkdtemp(prefix='dtoc.') | |
| fname_list = [] | |
| add_file('fname.c') | |
| add_file('.git/ignoreme.c') | |
| add_file('dir/fname2.c') | |
| add_file('build-sandbox/ignoreme2.c') | |
| # Mock out scan_driver and check that it is called with the | |
| # expected files | |
| with mock.patch.object(src_scan.Scanner, "scan_driver") as mocked: | |
| scan = src_scan.Scanner(indir, None) | |
| scan.scan_drivers() | |
| self.assertEqual(2, len(mocked.mock_calls)) | |
| self.assertEqual(mock.call(fname_list[0]), | |
| mocked.mock_calls[0]) | |
| # .git file should be ignored | |
| self.assertEqual(mock.call(fname_list[2]), | |
| mocked.mock_calls[1]) | |
| finally: | |
| shutil.rmtree(indir) | |
| def test_scan(self): | |
| """Test scanning of a driver""" | |
| fname = os.path.join(OUR_PATH, '..', '..', 'drivers/i2c/tegra_i2c.c') | |
| buff = tools.read_file(fname, False) | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver(fname, buff) | |
| self.assertIn('i2c_tegra', scan._drivers) | |
| drv = scan._drivers['i2c_tegra'] | |
| self.assertEqual('i2c_tegra', drv.name) | |
| self.assertEqual('UCLASS_I2C', drv.uclass_id) | |
| self.assertEqual( | |
| {'nvidia,tegra114-i2c': 'TYPE_114', | |
| 'nvidia,tegra124-i2c': 'TYPE_114', | |
| 'nvidia,tegra20-i2c': 'TYPE_STD', | |
| 'nvidia,tegra20-i2c-dvc': 'TYPE_DVC'}, drv.compat) | |
| self.assertEqual('i2c_bus', drv.priv) | |
| self.assertEqual(1, len(scan._drivers)) | |
| self.assertEqual({}, scan._warnings) | |
| def test_normalized_name(self): | |
| """Test operation of get_normalized_compat_name()""" | |
| prop = FakeProp() | |
| prop.name = 'compatible' | |
| prop.value = 'rockchip,rk3288-grf' | |
| node = FakeNode() | |
| node.props = {'compatible': prop} | |
| # get_normalized_compat_name() uses this to check for root node | |
| node.parent = FakeNode() | |
| scan = src_scan.Scanner(None, None) | |
| with test_util.capture_sys_output() as (stdout, _): | |
| name, aliases = scan.get_normalized_compat_name(node) | |
| self.assertEqual('rockchip_rk3288_grf', name) | |
| self.assertEqual([], aliases) | |
| self.assertEqual(1, len(scan._missing_drivers)) | |
| self.assertEqual({'rockchip_rk3288_grf'}, scan._missing_drivers) | |
| self.assertEqual('', stdout.getvalue().strip()) | |
| self.assertEqual(EXPECT_WARN, scan._warnings) | |
| i2c = 'I2C_UCLASS' | |
| compat = {'rockchip,rk3288-grf': 'ROCKCHIP_SYSCON_GRF', | |
| 'rockchip,rk3288-srf': None} | |
| drv = src_scan.Driver('fred', 'fred.c') | |
| drv.uclass_id = i2c | |
| drv.compat = compat | |
| scan._drivers['rockchip_rk3288_grf'] = drv | |
| scan._driver_aliases['rockchip_rk3288_srf'] = 'rockchip_rk3288_grf' | |
| with test_util.capture_sys_output() as (stdout, _): | |
| name, aliases = scan.get_normalized_compat_name(node) | |
| self.assertEqual('', stdout.getvalue().strip()) | |
| self.assertEqual('rockchip_rk3288_grf', name) | |
| self.assertEqual([], aliases) | |
| self.assertEqual(EXPECT_WARN, scan._warnings) | |
| prop.value = 'rockchip,rk3288-srf' | |
| with test_util.capture_sys_output() as (stdout, _): | |
| name, aliases = scan.get_normalized_compat_name(node) | |
| self.assertEqual('', stdout.getvalue().strip()) | |
| self.assertEqual('rockchip_rk3288_grf', name) | |
| self.assertEqual(['rockchip_rk3288_srf'], aliases) | |
| self.assertEqual(EXPECT_WARN, scan._warnings) | |
| def test_scan_errors(self): | |
| """Test detection of scanning errors""" | |
| buff = ''' | |
| static const struct udevice_id tegra_i2c_ids2[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(i2c_tegra) = { | |
| .name = "i2c_tegra", | |
| .id = UCLASS_I2C, | |
| .of_match = tegra_i2c_ids, | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| with self.assertRaises(ValueError) as exc: | |
| scan._parse_driver('file.c', buff) | |
| self.assertIn( | |
| "file.c: Unknown compatible var 'tegra_i2c_ids' (found: tegra_i2c_ids2)", | |
| str(exc.exception)) | |
| def test_of_match(self): | |
| """Test detection of of_match_ptr() member""" | |
| buff = ''' | |
| static const struct udevice_id tegra_i2c_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(i2c_tegra) = { | |
| .name = "i2c_tegra", | |
| .id = UCLASS_I2C, | |
| .of_match = of_match_ptr(tegra_i2c_ids), | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver('file.c', buff) | |
| self.assertIn('i2c_tegra', scan._drivers) | |
| drv = scan._drivers['i2c_tegra'] | |
| self.assertEqual('i2c_tegra', drv.name) | |
| self.assertEqual('', drv.phase) | |
| self.assertEqual([], drv.headers) | |
| def test_priv(self): | |
| """Test collection of struct info from drivers""" | |
| buff = ''' | |
| static const struct udevice_id test_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(testing) = { | |
| .name = "testing", | |
| .id = UCLASS_I2C, | |
| .of_match = test_ids, | |
| .priv_auto = sizeof(struct some_priv), | |
| .plat_auto = sizeof(struct some_plat), | |
| .per_child_auto = sizeof(struct some_cpriv), | |
| .per_child_plat_auto = sizeof(struct some_cplat), | |
| DM_PHASE(tpl) | |
| DM_HEADER(<i2c.h>) | |
| DM_HEADER(<asm/clk.h>) | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver('file.c', buff) | |
| self.assertIn('testing', scan._drivers) | |
| drv = scan._drivers['testing'] | |
| self.assertEqual('testing', drv.name) | |
| self.assertEqual('UCLASS_I2C', drv.uclass_id) | |
| self.assertEqual( | |
| {'nvidia,tegra114-i2c': 'TYPE_114'}, drv.compat) | |
| self.assertEqual('some_priv', drv.priv) | |
| self.assertEqual('some_plat', drv.plat) | |
| self.assertEqual('some_cpriv', drv.child_priv) | |
| self.assertEqual('some_cplat', drv.child_plat) | |
| self.assertEqual('tpl', drv.phase) | |
| self.assertEqual(['<i2c.h>', '<asm/clk.h>'], drv.headers) | |
| self.assertEqual(1, len(scan._drivers)) | |
| def test_uclass_scan(self): | |
| """Test collection of uclass-driver info""" | |
| buff = ''' | |
| UCLASS_DRIVER(i2c) = { | |
| .id = UCLASS_I2C, | |
| .name = "i2c", | |
| .flags = DM_UC_FLAG_SEQ_ALIAS, | |
| .priv_auto = sizeof(struct some_priv), | |
| .per_device_auto = sizeof(struct per_dev_priv), | |
| .per_device_plat_auto = sizeof(struct per_dev_plat), | |
| .per_child_auto = sizeof(struct per_child_priv), | |
| .per_child_plat_auto = sizeof(struct per_child_plat), | |
| .child_post_bind = i2c_child_post_bind, | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_uclass_driver('file.c', buff) | |
| self.assertIn('UCLASS_I2C', scan._uclass) | |
| drv = scan._uclass['UCLASS_I2C'] | |
| self.assertEqual('i2c', drv.name) | |
| self.assertEqual('UCLASS_I2C', drv.uclass_id) | |
| self.assertEqual('some_priv', drv.priv) | |
| self.assertEqual('per_dev_priv', drv.per_dev_priv) | |
| self.assertEqual('per_dev_plat', drv.per_dev_plat) | |
| self.assertEqual('per_child_priv', drv.per_child_priv) | |
| self.assertEqual('per_child_plat', drv.per_child_plat) | |
| self.assertEqual(1, len(scan._uclass)) | |
| drv2 = copy.deepcopy(drv) | |
| self.assertEqual(drv, drv2) | |
| drv2.priv = 'other_priv' | |
| self.assertNotEqual(drv, drv2) | |
| # The hashes only depend on the uclass ID, so should be equal | |
| self.assertEqual(drv.__hash__(), drv2.__hash__()) | |
| self.assertEqual("UclassDriver(name='i2c', uclass_id='UCLASS_I2C')", | |
| str(drv)) | |
| def test_uclass_scan_errors(self): | |
| """Test detection of uclass scanning errors""" | |
| buff = ''' | |
| UCLASS_DRIVER(i2c) = { | |
| .name = "i2c", | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| with self.assertRaises(ValueError) as exc: | |
| scan._parse_uclass_driver('file.c', buff) | |
| self.assertIn("file.c: Cannot parse uclass ID in driver 'i2c'", | |
| str(exc.exception)) | |
| def test_struct_scan(self): | |
| """Test collection of struct info""" | |
| buff = ''' | |
| /* some comment */ | |
| struct some_struct1 { | |
| struct i2c_msg *msgs; | |
| uint nmsgs; | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._basedir = os.path.join(OUR_PATH, '..', '..') | |
| scan._parse_structs('arch/arm/include/asm/file.h', buff) | |
| self.assertIn('some_struct1', scan._structs) | |
| struc = scan._structs['some_struct1'] | |
| self.assertEqual('some_struct1', struc.name) | |
| self.assertEqual('asm/file.h', struc.fname) | |
| buff = ''' | |
| /* another comment */ | |
| struct another_struct { | |
| int speed_hz; | |
| int max_transaction_bytes; | |
| }; | |
| ''' | |
| scan._parse_structs('include/file2.h', buff) | |
| self.assertIn('another_struct', scan._structs) | |
| struc = scan._structs['another_struct'] | |
| self.assertEqual('another_struct', struc.name) | |
| self.assertEqual('file2.h', struc.fname) | |
| self.assertEqual(2, len(scan._structs)) | |
| self.assertEqual("Struct(name='another_struct', fname='file2.h')", | |
| str(struc)) | |
| def test_struct_scan_errors(self): | |
| """Test scanning a header file with an invalid unicode file""" | |
| output = tools.get_output_filename('output.h') | |
| tools.write_file(output, b'struct this is a test \x81 of bad unicode') | |
| scan = src_scan.Scanner(None, None) | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.scan_header(output) | |
| self.assertIn('due to unicode error', stdout.getvalue()) | |
| def setup_dup_drivers(self, name, phase=''): | |
| """Set up for a duplcate test | |
| Returns: | |
| tuple: | |
| Scanner to use | |
| Driver record for first driver | |
| Text of second driver declaration | |
| Node for driver 1 | |
| """ | |
| driver1 = ''' | |
| static const struct udevice_id test_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(%s) = { | |
| .name = "testing", | |
| .id = UCLASS_I2C, | |
| .of_match = test_ids, | |
| %s | |
| }; | |
| ''' % (name, 'DM_PHASE(%s)' % phase if phase else '') | |
| driver2 = ''' | |
| static const struct udevice_id test_ids[] = { | |
| { .compatible = "nvidia,tegra114-dvc" }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(%s) = { | |
| .name = "testing", | |
| .id = UCLASS_RAM, | |
| .of_match = test_ids, | |
| }; | |
| ''' % name | |
| scan = src_scan.Scanner(None, None, phase) | |
| scan._parse_driver('file1.c', driver1) | |
| self.assertIn(name, scan._drivers) | |
| drv1 = scan._drivers[name] | |
| prop = FakeProp() | |
| prop.name = 'compatible' | |
| prop.value = 'nvidia,tegra114-i2c' | |
| node = FakeNode() | |
| node.name = 'testing' | |
| node.props = {'compatible': prop} | |
| # get_normalized_compat_name() uses this to check for root node | |
| node.parent = FakeNode() | |
| return scan, drv1, driver2, node | |
| def test_dup_drivers(self): | |
| """Test handling of duplicate drivers""" | |
| name = 'nvidia_tegra114_i2c' | |
| scan, drv1, driver2, node = self.setup_dup_drivers(name) | |
| self.assertEqual('', drv1.phase) | |
| # The driver should not have a duplicate yet | |
| self.assertEqual([], drv1.dups) | |
| scan._parse_driver('file2.c', driver2) | |
| # The first driver should now be a duplicate of the second | |
| drv2 = scan._drivers[name] | |
| self.assertEqual('', drv2.phase) | |
| self.assertEqual(1, len(drv2.dups)) | |
| self.assertEqual([drv1], drv2.dups) | |
| # There is no way to distinguish them, so we should expect a warning | |
| self.assertTrue(drv2.warn_dups) | |
| # We should see a warning | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.mark_used([node]) | |
| self.assertEqual( | |
| "Warning: Duplicate driver name 'nvidia_tegra114_i2c' (orig=file2.c, dups=file1.c)", | |
| stdout.getvalue().strip()) | |
| def test_dup_drivers_phase(self): | |
| """Test handling of duplicate drivers but with different phases""" | |
| name = 'nvidia_tegra114_i2c' | |
| scan, drv1, driver2, node = self.setup_dup_drivers(name, 'spl') | |
| scan._parse_driver('file2.c', driver2) | |
| self.assertEqual('spl', drv1.phase) | |
| # The second driver should now be a duplicate of the second | |
| self.assertEqual(1, len(drv1.dups)) | |
| drv2 = drv1.dups[0] | |
| # The phase is different, so we should not warn of dups | |
| self.assertFalse(drv1.warn_dups) | |
| # We should not see a warning | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.mark_used([node]) | |
| self.assertEqual('', stdout.getvalue().strip()) | |
| def test_sequence(self): | |
| """Test assignment of sequence numnbers""" | |
| scan = src_scan.Scanner(None, None, '') | |
| node = FakeNode() | |
| uc = src_scan.UclassDriver('UCLASS_I2C') | |
| node.uclass = uc | |
| node.driver = True | |
| node.seq = -1 | |
| node.path = 'mypath' | |
| uc.alias_num_to_node[2] = node | |
| # This should assign 3 (after the 2 that exists) | |
| seq = scan.assign_seq(node) | |
| self.assertEqual(3, seq) | |
| self.assertEqual({'mypath': 3}, uc.alias_path_to_num) | |
| self.assertEqual({2: node, 3: node}, uc.alias_num_to_node) | |
| def test_scan_warnings(self): | |
| """Test detection of scanning warnings""" | |
| buff = ''' | |
| static const struct udevice_id tegra_i2c_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(i2c_tegra) = { | |
| .name = "i2c_tegra", | |
| .id = UCLASS_I2C, | |
| .of_match = tegra_i2c_ids + 1, | |
| }; | |
| ''' | |
| # The '+ 1' above should generate a warning | |
| prop = FakeProp() | |
| prop.name = 'compatible' | |
| prop.value = 'rockchip,rk3288-grf' | |
| node = FakeNode() | |
| node.props = {'compatible': prop} | |
| # get_normalized_compat_name() uses this to check for root node | |
| node.parent = FakeNode() | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver('file.c', buff) | |
| self.assertEqual( | |
| {'i2c_tegra': | |
| {"file.c: Warning: unexpected suffix ' + 1' on .of_match line for compat 'tegra_i2c_ids'"}}, | |
| scan._warnings) | |
| tprop = FakeProp() | |
| tprop.name = 'compatible' | |
| tprop.value = 'nvidia,tegra114-i2c' | |
| tnode = FakeNode() | |
| tnode.props = {'compatible': tprop} | |
| # get_normalized_compat_name() uses this to check for root node | |
| tnode.parent = FakeNode() | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.get_normalized_compat_name(node) | |
| scan.get_normalized_compat_name(tnode) | |
| self.assertEqual('', stdout.getvalue().strip()) | |
| self.assertEqual(2, len(scan._missing_drivers)) | |
| self.assertEqual({'rockchip_rk3288_grf', 'nvidia_tegra114_i2c'}, | |
| scan._missing_drivers) | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.show_warnings() | |
| self.assertIn('rockchip_rk3288_grf', stdout.getvalue()) | |
| # This should show just the rockchip warning, since the tegra driver | |
| # is not in self._missing_drivers | |
| scan._missing_drivers.remove('nvidia_tegra114_i2c') | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.show_warnings() | |
| self.assertIn('rockchip_rk3288_grf', stdout.getvalue()) | |
| self.assertNotIn('tegra_i2c_ids', stdout.getvalue()) | |
| # Do a similar thing with used drivers. By marking the tegra driver as | |
| # used, the warning related to that driver will be shown | |
| drv = scan._drivers['i2c_tegra'] | |
| drv.used = True | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.show_warnings() | |
| self.assertIn('rockchip_rk3288_grf', stdout.getvalue()) | |
| self.assertIn('tegra_i2c_ids', stdout.getvalue()) | |
| # Add a warning to make sure multiple warnings are shown | |
| scan._warnings['i2c_tegra'].update( | |
| scan._warnings['nvidia_tegra114_i2c']) | |
| del scan._warnings['nvidia_tegra114_i2c'] | |
| with test_util.capture_sys_output() as (stdout, _): | |
| scan.show_warnings() | |
| self.assertEqual('''i2c_tegra: WARNING: the driver nvidia_tegra114_i2c was not found in the driver list | |
| : file.c: Warning: unexpected suffix ' + 1' on .of_match line for compat 'tegra_i2c_ids' | |
| rockchip_rk3288_grf: WARNING: the driver rockchip_rk3288_grf was not found in the driver list | |
| ''', | |
| stdout.getvalue()) | |
| self.assertIn('tegra_i2c_ids', stdout.getvalue()) | |
| def scan_uclass_warning(self): | |
| """Test a missing .uclass in the driver""" | |
| buff = ''' | |
| static const struct udevice_id tegra_i2c_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(i2c_tegra) = { | |
| .name = "i2c_tegra", | |
| .of_match = tegra_i2c_ids, | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver('file.c', buff) | |
| self.assertEqual( | |
| {'i2c_tegra': {'Missing .uclass in file.c'}}, | |
| scan._warnings) | |
| def scan_compat_warning(self): | |
| """Test a missing .compatible in the driver""" | |
| buff = ''' | |
| static const struct udevice_id tegra_i2c_ids[] = { | |
| { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, | |
| { } | |
| }; | |
| U_BOOT_DRIVER(i2c_tegra) = { | |
| .name = "i2c_tegra", | |
| .id = UCLASS_I2C, | |
| }; | |
| ''' | |
| scan = src_scan.Scanner(None, None) | |
| scan._parse_driver('file.c', buff) | |
| self.assertEqual( | |
| {'i2c_tegra': {'Missing .compatible in file.c'}}, | |
| scan._warnings) |