import collections
import os
import struct
-import sys
import tempfile
import unittest
-from dtoc import dtb_platdata
from dtb_platdata import conv_name_to_c
from dtb_platdata import get_compat_name
from dtb_platdata import get_value
from dtb_platdata import tab_to
+from dtoc import dtb_platdata
from dtoc import fdt
from dtoc import fdt_util
from patman import test_util
from patman import tools
-our_path = os.path.dirname(os.path.realpath(__file__))
+OUR_PATH = os.path.dirname(os.path.realpath(__file__))
HEADER = '''/*
}
'''
+# This is a test so is allowed to access private things in the module it is
+# testing
+# pylint: disable=W0212
def get_dtb_file(dts_fname, capture_stderr=False):
"""Compile a .dts file to a .dtb
Args:
- dts_fname: Filename of .dts file in the current directory
- capture_stderr: True to capture and discard stderr output
+ dts_fname (str): Filename of .dts file in the current directory
+ capture_stderr (bool): True to capture and discard stderr output
Returns:
- Filename of compiled file in output directory
+ str: Filename of compiled file in output directory
"""
- return fdt_util.EnsureCompiled(os.path.join(our_path, dts_fname),
+ return fdt_util.EnsureCompiled(os.path.join(OUR_PATH, dts_fname),
capture_stderr=capture_stderr)
@classmethod
def tearDownClass(cls):
- tools._RemoveOutputDir()
+ tools.FinaliseOutputDir()
- def _WritePythonString(self, fname, data):
+ @staticmethod
+ def _write_python_string(fname, data):
"""Write a string with tabs expanded as done in this Python file
Args:
- fname: Filename to write to
- data: Raw string to convert
+ fname (str): Filename to write to
+ data (str): Raw string to convert
"""
data = data.replace('\t', '\\t')
- with open(fname, 'w') as fd:
- fd.write(data)
+ with open(fname, 'w') as fout:
+ fout.write(data)
- def _CheckStrings(self, expected, actual):
+ def _check_strings(self, expected, actual):
"""Check that a string matches its expected value
If the strings do not match, they are written to the /tmp directory in
easy comparison and update of the tests.
Args:
- expected: Expected string
- actual: Actual string
+ expected (str): Expected string
+ actual (str): Actual string
"""
if expected != actual:
- self._WritePythonString('/tmp/binman.expected', expected)
- self._WritePythonString('/tmp/binman.actual', actual)
+ self._write_python_string('/tmp/binman.expected', expected)
+ self._write_python_string('/tmp/binman.actual', actual)
print('Failures written to /tmp/binman.{expected,actual}')
- self.assertEquals(expected, actual)
+ self.assertEqual(expected, actual)
+ @staticmethod
+ def run_test(args, dtb_file, output):
+ """Run a test using dtoc
- def run_test(self, args, dtb_file, output):
+ Args:
+ args (list of str): List of arguments for dtoc
+ dtb_file (str): Filename of .dtb file
+ output (str): Filename of output file
+ """
dtb_platdata.run_steps(args, dtb_file, False, output, True)
def test_name(self):
prop = Prop(['rockchip,rk3399-sdhci-5.1', 'arasan,sdhci-5.1', 'third'])
node = Node({'compatible': prop})
self.assertEqual((['rockchip_rk3399_sdhci_5_1',
- 'arasan_sdhci_5_1', 'third']),
+ 'arasan_sdhci_5_1', 'third']),
get_compat_name(node))
def test_empty_file(self):
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_sandbox_i2c_test {
};
struct dtd_sandbox_pmic_test {
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /i2c@0 index 0 */
static struct dtd_sandbox_i2c_test dtv_i2c_at_0 = {
};
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_sandbox_gpio {
\tconst char *\tgpio_bank_name;
\tbool\t\tgpio_controller;
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /gpios@0 index 0 */
static struct dtd_sandbox_gpio dtv_gpios_at_0 = {
\t.gpio_bank_name\t\t= "a",
"""Test output from a device tree file with an invalid driver"""
dtb_file = get_dtb_file('dtoc_test_invalid_driver.dts')
output = tools.GetOutputFilename('output')
- with test_util.capture_sys_output() as (stdout, stderr):
+ with test_util.capture_sys_output() as _:
dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_invalid {
};
''', data)
- with test_util.capture_sys_output() as (stdout, stderr):
+ with test_util.capture_sys_output() as _:
dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /spl-test index 0 */
static struct dtd_invalid dtv_spl_test = {
};
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_source {
\tstruct phandle_2_arg clocks[4];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /phandle2-target index 0 */
static struct dtd_target dtv_phandle2_target = {
\t.intval\t\t\t= 0x1,
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_source {
\tstruct phandle_0_arg clocks[1];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /phandle-target index 1 */
static struct dtd_target dtv_phandle_target = {
};
dtb_platdata.run_steps(['platdata'], dtb_file, False, output, True)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /phandle2-target index 0 */
static struct dtd_target dtv_phandle2_target = {
\t.intval\t\t\t= 0x1,
dtb_file = get_dtb_file('dtoc_test_phandle_bad.dts',
capture_stderr=True)
output = tools.GetOutputFilename('output')
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Cannot parse 'clocks' in node 'phandle-source'",
- str(e.exception))
+ str(exc.exception))
def test_phandle_bad2(self):
"""Test a phandle target missing its #*-cells property"""
dtb_file = get_dtb_file('dtoc_test_phandle_bad2.dts',
capture_stderr=True)
output = tools.GetOutputFilename('output')
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'phandle-target' has no cells property",
- str(e.exception))
+ str(exc.exception))
def test_addresses64(self):
"""Test output from a node with a 'reg' property with na=2, ns=2"""
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678},
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_test1 {
\tfdt32_t\t\treg[2];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678},
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x123400000000, 0x5678},
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_test1 {
\tfdt64_t\t\treg[2];
};
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x567800000000},
# Capture stderr since dtc will emit warnings for this file
dtb_file = get_dtb_file('dtoc_test_bad_reg.dts', capture_stderr=True)
output = tools.GetOutputFilename('output')
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'spl-test' reg property is not an int",
- str(e.exception))
+ str(exc.exception))
def test_bad_reg2(self):
"""Test that a reg property with an invalid cell count is detected"""
# Capture stderr since dtc will emit warnings for this file
dtb_file = get_dtb_file('dtoc_test_bad_reg2.dts', capture_stderr=True)
output = tools.GetOutputFilename('output')
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
- self.assertIn("Node 'spl-test' reg property has 3 cells which is not a multiple of na + ns = 1 + 1)",
- str(e.exception))
+ self.assertIn(
+ "Node 'spl-test' reg property has 3 cells which is not a multiple of na + ns = 1 + 1)",
+ str(exc.exception))
def test_add_prop(self):
"""Test that a subequent node can add a new property to a struct"""
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(HEADER + '''
+ self._check_strings(HEADER + '''
struct dtd_sandbox_spl_test {
\tfdt32_t\t\tintarray;
\tfdt32_t\t\tintval;
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
- self._CheckStrings(C_HEADER + '''
+ self._check_strings(C_HEADER + '''
/* Node /spl-test index 0 */
static struct dtd_sandbox_spl_test dtv_spl_test = {
\t.intval\t\t\t= 0x1,
''' + C_EMPTY_POPULATE_PHANDLE_DATA, data)
- def testStdout(self):
+ def test_stdout(self):
"""Test output to stdout"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- with test_util.capture_sys_output() as (stdout, stderr):
+ with test_util.capture_sys_output() as _:
self.run_test(['struct'], dtb_file, '-')
- def testNoCommand(self):
+ def test_no_command(self):
"""Test running dtoc without a command"""
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test([], '', '')
self.assertIn("Please specify a command: struct, platdata",
- str(e.exception))
+ str(exc.exception))
- def testBadCommand(self):
+ def test_bad_command(self):
"""Test running dtoc with an invalid command"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output')
- with self.assertRaises(ValueError) as e:
+ with self.assertRaises(ValueError) as exc:
self.run_test(['invalid-cmd'], dtb_file, output)
self.assertIn("Unknown command 'invalid-cmd': (use: struct, platdata)",
- str(e.exception))
+ str(exc.exception))
- def testScanDrivers(self):
+ @staticmethod
+ def test_scan_drivers():
"""Test running dtoc with additional drivers to scan"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output')
- with test_util.capture_sys_output() as (stdout, stderr):
- dtb_platdata.run_steps(['struct'], dtb_file, False, output, True,
- [None, '', 'tools/dtoc/dtoc_test_scan_drivers.cxx'])
+ with test_util.capture_sys_output() as _:
+ dtb_platdata.run_steps(
+ ['struct'], dtb_file, False, output, True,
+ [None, '', 'tools/dtoc/dtoc_test_scan_drivers.cxx'])
- def testUnicodeError(self):
+ @staticmethod
+ def test_unicode_error():
"""Test running dtoc with an invalid unicode file
To be able to perform this test without adding a weird text file which
dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output')
driver_fn = '/tmp/' + next(tempfile._get_candidate_names())
- with open(driver_fn, 'wb+') as df:
- df.write(b'\x81')
+ with open(driver_fn, 'wb+') as fout:
+ fout.write(b'\x81')
- with test_util.capture_sys_output() as (stdout, stderr):
+ with test_util.capture_sys_output() as _:
dtb_platdata.run_steps(['struct'], dtb_file, False, output, True,
- [driver_fn])
+ [driver_fn])
- def testDriver(self):
+ def test_driver(self):
"""Test the Driver class"""
drv1 = dtb_platdata.Driver('fred')
drv2 = dtb_platdata.Driver('mary')
projects / u-boot.git / commitdiff