GitHub-Mirror/u-boot
2
0
Fork 0
mirror of https://github.com/Fishwaldo/u-boot.git synced 2025-03-31 19:41:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

dtoc: Tidy up pylint warnings in test

Browse source 
Tidy up this file to reduce the number of pylint warnings.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2020-12-28 20:34:47 -07:00
parent 97e8684c84
commit 67b5ec54a5
1 changed files with 85 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

156
tools/dtoc/test_dtoc.py
View file

@ -12,21 +12,20 @@ tool.
import collections import collections
import os import os
import struct import struct
import sys
import tempfile import tempfile
import unittest import unittest
from dtoc import dtb_platdata
from dtb_platdata import conv_name_to_c from dtb_platdata import conv_name_to_c
from dtb_platdata import get_compat_name from dtb_platdata import get_compat_name
from dtb_platdata import get_value from dtb_platdata import get_value
from dtb_platdata import tab_to from dtb_platdata import tab_to
from dtoc import dtb_platdata
from dtoc import fdt from dtoc import fdt
from dtoc import fdt_util from dtoc import fdt_util
from patman import test_util from patman import test_util
from patman import tools from patman import tools
our_path = os.path.dirname(os.path.realpath(__file__)) OUR_PATH = os.path.dirname(os.path.realpath(__file__))
HEADER = '''/* HEADER = '''/*
@ -56,18 +55,21 @@ C_EMPTY_POPULATE_PHANDLE_DATA = '''void dm_populate_phandle_data(void) {
} }
''' '''
# 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): def get_dtb_file(dts_fname, capture_stderr=False):
"""Compile a .dts file to a .dtb """Compile a .dts file to a .dtb
Args: Args:
dts_fname: Filename of .dts file in the current directory dts_fname (str): Filename of .dts file in the current directory
capture_stderr: True to capture and discard stderr output capture_stderr (bool): True to capture and discard stderr output
Returns: 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) capture_stderr=capture_stderr)
@ -80,20 +82,21 @@ class TestDtoc(unittest.TestCase):
@classmethod @classmethod
def tearDownClass(cls): 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 """Write a string with tabs expanded as done in this Python file
Args: Args:
fname: Filename to write to fname (str): Filename to write to
data: Raw string to convert data (str): Raw string to convert
""" """
data = data.replace('\t', '\\t') data = data.replace('\t', '\\t')
with open(fname, 'w') as fd: with open(fname, 'w') as fout:
fd.write(data) fout.write(data)
def _CheckStrings(self, expected, actual): def _check_strings(self, expected, actual):
"""Check that a string matches its expected value """Check that a string matches its expected value
If the strings do not match, they are written to the /tmp directory in If the strings do not match, they are written to the /tmp directory in
@ -101,17 +104,24 @@ class TestDtoc(unittest.TestCase):
easy comparison and update of the tests. easy comparison and update of the tests.
Args: Args:
expected: Expected string expected (str): Expected string
actual: Actual string actual (str): Actual string
""" """
if expected != actual: if expected != actual:
self._WritePythonString('/tmp/binman.expected', expected) self._write_python_string('/tmp/binman.expected', expected)
self._WritePythonString('/tmp/binman.actual', actual) self._write_python_string('/tmp/binman.actual', actual)
print('Failures written to /tmp/binman.{expected,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) dtb_platdata.run_steps(args, dtb_file, False, output, True)
def test_name(self): def test_name(self):
@ -160,7 +170,7 @@ class TestDtoc(unittest.TestCase):
prop = Prop(['rockchip,rk3399-sdhci-5.1', 'arasan,sdhci-5.1', 'third']) prop = Prop(['rockchip,rk3399-sdhci-5.1', 'arasan,sdhci-5.1', 'third'])
node = Node({'compatible': prop}) node = Node({'compatible': prop})
self.assertEqual((['rockchip_rk3399_sdhci_5_1', self.assertEqual((['rockchip_rk3399_sdhci_5_1',
'arasan_sdhci_5_1', 'third']), 'arasan_sdhci_5_1', 'third']),
get_compat_name(node)) get_compat_name(node))
def test_empty_file(self): def test_empty_file(self):
@ -185,7 +195,7 @@ class TestDtoc(unittest.TestCase):
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_sandbox_i2c_test { struct dtd_sandbox_i2c_test {
}; };
struct dtd_sandbox_pmic_test { struct dtd_sandbox_pmic_test {
@ -209,7 +219,7 @@ struct dtd_sandbox_spl_test {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /i2c@0 index 0 */ /* Node /i2c@0 index 0 */
static struct dtd_sandbox_i2c_test dtv_i2c_at_0 = { static struct dtd_sandbox_i2c_test dtv_i2c_at_0 = {
}; };
@ -293,7 +303,7 @@ U_BOOT_DEVICE(spl_test3) = {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_sandbox_gpio { struct dtd_sandbox_gpio {
\tconst char *\tgpio_bank_name; \tconst char *\tgpio_bank_name;
\tbool\t\tgpio_controller; \tbool\t\tgpio_controller;
@ -304,7 +314,7 @@ struct dtd_sandbox_gpio {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /gpios@0 index 0 */ /* Node /gpios@0 index 0 */
static struct dtd_sandbox_gpio dtv_gpios_at_0 = { static struct dtd_sandbox_gpio dtv_gpios_at_0 = {
\t.gpio_bank_name\t\t= "a", \t.gpio_bank_name\t\t= "a",
@ -326,20 +336,20 @@ void dm_populate_phandle_data(void) {
"""Test output from a device tree file with an invalid driver""" """Test output from a device tree file with an invalid driver"""
dtb_file = get_dtb_file('dtoc_test_invalid_driver.dts') dtb_file = get_dtb_file('dtoc_test_invalid_driver.dts')
output = tools.GetOutputFilename('output') 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) dtb_platdata.run_steps(['struct'], dtb_file, False, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_invalid { struct dtd_invalid {
}; };
''', data) ''', 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) dtb_platdata.run_steps(['platdata'], dtb_file, False, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /spl-test index 0 */ /* Node /spl-test index 0 */
static struct dtd_invalid dtv_spl_test = { static struct dtd_invalid dtv_spl_test = {
}; };
@ -361,7 +371,7 @@ void dm_populate_phandle_data(void) {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_source { struct dtd_source {
\tstruct phandle_2_arg clocks[4]; \tstruct phandle_2_arg clocks[4];
}; };
@ -373,7 +383,7 @@ struct dtd_target {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /phandle2-target index 0 */ /* Node /phandle2-target index 0 */
static struct dtd_target dtv_phandle2_target = { static struct dtd_target dtv_phandle2_target = {
\t.intval\t\t\t= 0x1, \t.intval\t\t\t= 0x1,
@ -445,7 +455,7 @@ void dm_populate_phandle_data(void) {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_source { struct dtd_source {
\tstruct phandle_0_arg clocks[1]; \tstruct phandle_0_arg clocks[1];
}; };
@ -461,7 +471,7 @@ struct dtd_target {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /phandle-target index 1 */ /* Node /phandle-target index 1 */
static struct dtd_target dtv_phandle_target = { static struct dtd_target dtv_phandle_target = {
}; };
@ -495,7 +505,7 @@ void dm_populate_phandle_data(void) {
dtb_platdata.run_steps(['platdata'], dtb_file, False, output, True) dtb_platdata.run_steps(['platdata'], dtb_file, False, output, True)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /phandle2-target index 0 */ /* Node /phandle2-target index 0 */
static struct dtd_target dtv_phandle2_target = { static struct dtd_target dtv_phandle2_target = {
\t.intval\t\t\t= 0x1, \t.intval\t\t\t= 0x1,
@ -565,20 +575,20 @@ void dm_populate_phandle_data(void) {
dtb_file = get_dtb_file('dtoc_test_phandle_bad.dts', dtb_file = get_dtb_file('dtoc_test_phandle_bad.dts',
capture_stderr=True) capture_stderr=True)
output = tools.GetOutputFilename('output') output = tools.GetOutputFilename('output')
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
self.assertIn("Cannot parse 'clocks' in node 'phandle-source'", self.assertIn("Cannot parse 'clocks' in node 'phandle-source'",
str(e.exception)) str(exc.exception))
def test_phandle_bad2(self): def test_phandle_bad2(self):
"""Test a phandle target missing its #*-cells property""" """Test a phandle target missing its #*-cells property"""
dtb_file = get_dtb_file('dtoc_test_phandle_bad2.dts', dtb_file = get_dtb_file('dtoc_test_phandle_bad2.dts',
capture_stderr=True) capture_stderr=True)
output = tools.GetOutputFilename('output') output = tools.GetOutputFilename('output')
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'phandle-target' has no cells property", self.assertIn("Node 'phandle-target' has no cells property",
str(e.exception)) str(exc.exception))
def test_addresses64(self): def test_addresses64(self):
"""Test output from a node with a 'reg' property with na=2, ns=2""" """Test output from a node with a 'reg' property with na=2, ns=2"""
@ -587,7 +597,7 @@ void dm_populate_phandle_data(void) {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_test1 { struct dtd_test1 {
\tfdt64_t\t\treg[2]; \tfdt64_t\t\treg[2];
}; };
@ -602,7 +612,7 @@ struct dtd_test3 {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */ /* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = { static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678}, \t.reg\t\t\t= {0x1234, 0x5678},
@ -645,7 +655,7 @@ U_BOOT_DEVICE(test3) = {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_test1 { struct dtd_test1 {
\tfdt32_t\t\treg[2]; \tfdt32_t\t\treg[2];
}; };
@ -657,7 +667,7 @@ struct dtd_test2 {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */ /* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = { static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x5678}, \t.reg\t\t\t= {0x1234, 0x5678},
@ -689,7 +699,7 @@ U_BOOT_DEVICE(test2) = {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_test1 { struct dtd_test1 {
\tfdt64_t\t\treg[2]; \tfdt64_t\t\treg[2];
}; };
@ -704,7 +714,7 @@ struct dtd_test3 {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */ /* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = { static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x123400000000, 0x5678}, \t.reg\t\t\t= {0x123400000000, 0x5678},
@ -747,7 +757,7 @@ U_BOOT_DEVICE(test3) = {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_test1 { struct dtd_test1 {
\tfdt64_t\t\treg[2]; \tfdt64_t\t\treg[2];
}; };
@ -762,7 +772,7 @@ struct dtd_test3 {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /test1 index 0 */ /* Node /test1 index 0 */
static struct dtd_test1 dtv_test1 = { static struct dtd_test1 dtv_test1 = {
\t.reg\t\t\t= {0x1234, 0x567800000000}, \t.reg\t\t\t= {0x1234, 0x567800000000},
@ -803,20 +813,21 @@ U_BOOT_DEVICE(test3) = {
# Capture stderr since dtc will emit warnings for this file # Capture stderr since dtc will emit warnings for this file
dtb_file = get_dtb_file('dtoc_test_bad_reg.dts', capture_stderr=True) dtb_file = get_dtb_file('dtoc_test_bad_reg.dts', capture_stderr=True)
output = tools.GetOutputFilename('output') output = tools.GetOutputFilename('output')
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'spl-test' reg property is not an int", self.assertIn("Node 'spl-test' reg property is not an int",
str(e.exception)) str(exc.exception))
def test_bad_reg2(self): def test_bad_reg2(self):
"""Test that a reg property with an invalid cell count is detected""" """Test that a reg property with an invalid cell count is detected"""
# Capture stderr since dtc will emit warnings for this file # Capture stderr since dtc will emit warnings for this file
dtb_file = get_dtb_file('dtoc_test_bad_reg2.dts', capture_stderr=True) dtb_file = get_dtb_file('dtoc_test_bad_reg2.dts', capture_stderr=True)
output = tools.GetOutputFilename('output') output = tools.GetOutputFilename('output')
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output) 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)", self.assertIn(
str(e.exception)) "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): def test_add_prop(self):
"""Test that a subequent node can add a new property to a struct""" """Test that a subequent node can add a new property to a struct"""
@ -825,7 +836,7 @@ U_BOOT_DEVICE(test3) = {
self.run_test(['struct'], dtb_file, output) self.run_test(['struct'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(HEADER + ''' self._check_strings(HEADER + '''
struct dtd_sandbox_spl_test { struct dtd_sandbox_spl_test {
\tfdt32_t\t\tintarray; \tfdt32_t\t\tintarray;
\tfdt32_t\t\tintval; \tfdt32_t\t\tintval;
@ -835,7 +846,7 @@ struct dtd_sandbox_spl_test {
self.run_test(['platdata'], dtb_file, output) self.run_test(['platdata'], dtb_file, output)
with open(output) as infile: with open(output) as infile:
data = infile.read() data = infile.read()
self._CheckStrings(C_HEADER + ''' self._check_strings(C_HEADER + '''
/* Node /spl-test index 0 */ /* Node /spl-test index 0 */
static struct dtd_sandbox_spl_test dtv_spl_test = { static struct dtd_sandbox_spl_test dtv_spl_test = {
\t.intval\t\t\t= 0x1, \t.intval\t\t\t= 0x1,
@ -860,37 +871,40 @@ U_BOOT_DEVICE(spl_test2) = {
''' + C_EMPTY_POPULATE_PHANDLE_DATA, data) ''' + C_EMPTY_POPULATE_PHANDLE_DATA, data)
def testStdout(self): def test_stdout(self):
"""Test output to stdout""" """Test output to stdout"""
dtb_file = get_dtb_file('dtoc_test_simple.dts') 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, '-') self.run_test(['struct'], dtb_file, '-')
def testNoCommand(self): def test_no_command(self):
"""Test running dtoc without a command""" """Test running dtoc without a command"""
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as exc:
self.run_test([], '', '') self.run_test([], '', '')
self.assertIn("Please specify a command: struct, platdata", 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""" """Test running dtoc with an invalid command"""
dtb_file = get_dtb_file('dtoc_test_simple.dts') dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output') 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.run_test(['invalid-cmd'], dtb_file, output)
self.assertIn("Unknown command 'invalid-cmd': (use: struct, platdata)", 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""" """Test running dtoc with additional drivers to scan"""
dtb_file = get_dtb_file('dtoc_test_simple.dts') dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output') 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, True, dtb_platdata.run_steps(
[None, '', 'tools/dtoc/dtoc_test_scan_drivers.cxx']) ['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 """Test running dtoc with an invalid unicode file
To be able to perform this test without adding a weird text file which To be able to perform this test without adding a weird text file which
@ -900,14 +914,14 @@ U_BOOT_DEVICE(spl_test2) = {
dtb_file = get_dtb_file('dtoc_test_simple.dts') dtb_file = get_dtb_file('dtoc_test_simple.dts')
output = tools.GetOutputFilename('output') output = tools.GetOutputFilename('output')
driver_fn = '/tmp/' + next(tempfile._get_candidate_names()) driver_fn = '/tmp/' + next(tempfile._get_candidate_names())
with open(driver_fn, 'wb+') as df: with open(driver_fn, 'wb+') as fout:
df.write(b'\x81') 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, 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""" """Test the Driver class"""
drv1 = dtb_platdata.Driver('fred') drv1 = dtb_platdata.Driver('fred')
drv2 = dtb_platdata.Driver('mary') drv2 = dtb_platdata.Driver('mary')