Convert this file to snake case and update all files which use it.
Signed-off-by: Simon Glass <sjg@chromium.org>
"""
tmpdir = tempfile.mkdtemp(prefix='binmanf.')
print(f"- clone git repo '{git_repo}' to '{tmpdir}'")
- tools.Run('git', 'clone', '--depth', '1', git_repo, tmpdir)
+ tools.run('git', 'clone', '--depth', '1', git_repo, tmpdir)
print(f"- build target '{make_target}'")
- tools.Run('make', '-C', tmpdir, '-j', f'{multiprocessing.cpu_count()}',
+ tools.run('make', '-C', tmpdir, '-j', f'{multiprocessing.cpu_count()}',
make_target)
fname = os.path.join(tmpdir, bintool_path)
if not os.path.exists(fname):
str: Filename of fetched file to copy to a suitable directory
str: Name of temp directory to remove, or None
"""
- fname, tmpdir = tools.Download(url)
- tools.Run('chmod', 'a+x', fname)
+ fname, tmpdir = tools.download(url)
+ tools.run('chmod', 'a+x', fname)
return fname, tmpdir
@classmethod
"""
args = ['sudo', 'apt', 'install', '-y', package]
print('- %s' % ' '.join(args))
- tools.Run(*args)
+ tools.run(*args)
return True
@staticmethod
Args:
fake_download (function): Function to call instead of
- tools.Download()
+ tools.download()
method (bintool.FETCH_...: Fetch method to use
Returns:
"""
btest = Bintool.create('_testing')
col = terminal.Color()
- with unittest.mock.patch.object(tools, 'Download',
+ with unittest.mock.patch.object(tools, 'download',
side_effect=fake_download):
with test_util.capture_sys_output() as (stdout, _):
btest.fetch_tool(method, col, False)
def test_fetch_url_err(self):
"""Test an error while fetching a tool from a URL"""
def fail_download(url):
- """Take the tools.Download() function by raising an exception"""
+ """Take the tools.download() function by raising an exception"""
raise urllib.error.URLError('my error')
stdout = self.check_fetch_url(fail_download, bintool.FETCH_ANY)
def test_fetch_method(self):
"""Test fetching using a particular method"""
def fail_download(url):
- """Take the tools.Download() function by raising an exception"""
+ """Take the tools.download() function by raising an exception"""
raise urllib.error.URLError('my error')
stdout = self.check_fetch_url(fail_download, bintool.FETCH_BIN)
def test_fetch_pass_fail(self):
"""Test fetching multiple tools with some passing and some failing"""
def handle_download(_):
- """Take the tools.Download() function by writing a file"""
+ """Take the tools.download() function by writing a file"""
if self.seq:
raise urllib.error.URLError('not found')
self.seq += 1
- tools.WriteFile(fname, expected)
+ tools.write_file(fname, expected)
return fname, dirname
expected = b'this is a test'
self.seq = 0
with unittest.mock.patch.object(bintool, 'DOWNLOAD_DESTDIR', destdir):
- with unittest.mock.patch.object(tools, 'Download',
+ with unittest.mock.patch.object(tools, 'download',
side_effect=handle_download):
with test_util.capture_sys_output() as (stdout, _):
Bintool.fetch_tools(bintool.FETCH_ANY, ['_testing'] * 2)
self.assertTrue(os.path.exists(dest_fname))
- data = tools.ReadFile(dest_fname)
+ data = tools.read_file(dest_fname)
self.assertEqual(expected, data)
lines = stdout.getvalue().splitlines()
tmpdir = cmd[2]
self.fname = os.path.join(tmpdir, 'pathname')
if write_file:
- tools.WriteFile(self.fname, b'hello')
+ tools.write_file(self.fname, b'hello')
btest = Bintool.create('_testing')
col = terminal.Color()
self.fname = None
with unittest.mock.patch.object(bintool, 'DOWNLOAD_DESTDIR',
self._indir):
- with unittest.mock.patch.object(tools, 'Run', side_effect=fake_run):
+ with unittest.mock.patch.object(tools, 'run', side_effect=fake_run):
with test_util.capture_sys_output() as (stdout, _):
btest.fetch_tool(bintool.FETCH_BUILD, col, False)
fname = os.path.join(self._indir, '_testing')
btest = Bintool.create('_testing')
btest.install = True
col = terminal.Color()
- with unittest.mock.patch.object(tools, 'Run', return_value=None):
+ with unittest.mock.patch.object(tools, 'run', return_value=None):
with test_util.capture_sys_output() as _:
result = btest.fetch_tool(bintool.FETCH_BIN, col, False)
self.assertEqual(bintool.FETCHED, result)
def test_all_bintools(self):
"""Test that all bintools can handle all available fetch types"""
def handle_download(_):
- """Take the tools.Download() function by writing a file"""
- tools.WriteFile(fname, expected)
+ """Take the tools.download() function by writing a file"""
+ tools.write_file(fname, expected)
return fname, dirname
def fake_run(*cmd):
# See Bintool.build_from_git()
tmpdir = cmd[2]
self.fname = os.path.join(tmpdir, 'pathname')
- tools.WriteFile(self.fname, b'hello')
+ tools.write_file(self.fname, b'hello')
expected = b'this is a test'
dirname = os.path.join(self._indir, 'download_dir')
os.mkdir(dirname)
fname = os.path.join(dirname, 'downloaded')
- with unittest.mock.patch.object(tools, 'Run', side_effect=fake_run):
- with unittest.mock.patch.object(tools, 'Download',
+ with unittest.mock.patch.object(tools, 'run', side_effect=fake_run):
+ with unittest.mock.patch.object(tools, 'download',
side_effect=handle_download):
with test_util.capture_sys_output() as _:
for name in Bintool.get_tool_list():
if result is not True and result is not None:
result_fname, _ = result
self.assertTrue(os.path.exists(result_fname))
- data = tools.ReadFile(result_fname)
+ data = tools.read_file(result_fname)
self.assertEqual(expected, data)
os.remove(result_fname)
bytes: Compressed data
"""
with tempfile.NamedTemporaryFile(prefix='comp.tmp',
- dir=tools.GetOutputDir()) as tmp:
- tools.WriteFile(tmp.name, indata)
+ dir=tools.get_output_dir()) as tmp:
+ tools.write_file(tmp.name, indata)
args = ['--no-frame-crc', '-B4', '-5', '-c', tmp.name]
return self.run_cmd(*args, binary=True)
bytes: Decompressed data
"""
with tempfile.NamedTemporaryFile(prefix='decomp.tmp',
- dir=tools.GetOutputDir()) as inf:
- tools.WriteFile(inf.name, indata)
+ dir=tools.get_output_dir()) as inf:
+ tools.write_file(inf.name, indata)
args = ['-cd', inf.name]
return self.run_cmd(*args, binary=True)
bytes: Compressed data
"""
with tempfile.NamedTemporaryFile(prefix='comp.tmp',
- dir=tools.GetOutputDir()) as inf:
- tools.WriteFile(inf.name, indata)
+ dir=tools.get_output_dir()) as inf:
+ tools.write_file(inf.name, indata)
with tempfile.NamedTemporaryFile(prefix='compo.otmp',
- dir=tools.GetOutputDir()) as outf:
+ dir=tools.get_output_dir()) as outf:
args = ['e', inf.name, outf.name, '-lc1', '-lp0', '-pb0', '-d8']
self.run_cmd(*args, binary=True)
- return tools.ReadFile(outf.name)
+ return tools.read_file(outf.name)
def decompress(self, indata):
"""Decompress data with lzma_alone
bytes: Decompressed data
"""
with tempfile.NamedTemporaryFile(prefix='decomp.tmp',
- dir=tools.GetOutputDir()) as inf:
- tools.WriteFile(inf.name, indata)
+ dir=tools.get_output_dir()) as inf:
+ tools.write_file(inf.name, indata)
with tempfile.NamedTemporaryFile(prefix='compo.otmp',
- dir=tools.GetOutputDir()) as outf:
+ dir=tools.get_output_dir()) as outf:
args = ['d', inf.name, outf.name]
self.run_cmd(*args, binary=True)
- return tools.ReadFile(outf.name, binary=True)
+ return tools.read_file(outf.name, binary=True)
def fetch(self, method):
"""Fetch handler for lzma_alone
Returns:
String with required padding (at least one 0x00 byte) at the end
"""
- val = tools.ToBytes(instr)
+ val = tools.to_bytes(instr)
pad_len = align_int(len(val) + 1, FILENAME_ALIGN)
- return val + tools.GetBytes(0, pad_len - len(val))
+ return val + tools.get_bytes(0, pad_len - len(val))
class CbfsFile(object):
FILE_ATTR_TAG_COMPRESSION, ATTR_COMPRESSION_LEN,
self.compress, self.memlen)
elif self.ftype == TYPE_EMPTY:
- data = tools.GetBytes(self.erase_byte, self.size)
+ data = tools.get_bytes(self.erase_byte, self.size)
else:
raise ValueError('Unknown type %#x when writing\n' % self.ftype)
if attr:
# possible.
raise ValueError("Internal error: CBFS file '%s': Requested offset %#x but current output position is %#x" %
(self.name, self.cbfs_offset, offset))
- pad = tools.GetBytes(pad_byte, pad_len)
+ pad = tools.get_bytes(pad_byte, pad_len)
hdr_len += pad_len
# This is the offset of the start of the file's data,
Usage is something like:
cbw = CbfsWriter(size)
- cbw.add_file_raw('u-boot', tools.ReadFile('u-boot.bin'))
+ cbw.add_file_raw('u-boot', tools.read_file('u-boot.bin'))
...
data, cbfs_offset = cbw.get_data_and_offset()
if fd.tell() > offset:
raise ValueError('No space for data before offset %#x (current offset %#x)' %
(offset, fd.tell()))
- fd.write(tools.GetBytes(self._erase_byte, offset - fd.tell()))
+ fd.write(tools.get_bytes(self._erase_byte, offset - fd.tell()))
def _pad_to(self, fd, offset):
"""Write out pad bytes and/or an empty file until a given offset
def setUpClass(cls):
# Create a temporary directory for test files
cls._indir = tempfile.mkdtemp(prefix='cbfs_util.')
- tools.SetInputDirs([cls._indir])
+ tools.set_input_dirs([cls._indir])
# Set up some useful data files
TestCbfs._make_input_file('u-boot.bin', U_BOOT_DATA)
# Set up a temporary output directory, used by the tools library when
# compressing files
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
cls.cbfstool = bintool.Bintool.create('cbfstool')
cls.have_cbfstool = cls.cbfstool.is_present()
if cls._indir:
shutil.rmtree(cls._indir)
cls._indir = None
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
@classmethod
def _make_input_file(cls, fname, contents):
Full pathname of file created
"""
pathname = os.path.join(cls._indir, fname)
- tools.WriteFile(pathname, contents)
+ tools.write_file(pathname, contents)
return pathname
def _check_hdr(self, data, size, offset=0, arch=cbfs_util.ARCHITECTURE_X86):
base = [(1 << 32) - size + b for b in base]
self.cbfstool.add_raw(
cbfs_fname, 'u-boot',
- tools.GetInputFilename(compress and 'compress' or 'u-boot.bin'),
+ tools.get_input_filename(compress and 'compress' or 'u-boot.bin'),
compress[0] if compress else None,
base[0] if base else None)
self.cbfstool.add_raw(
cbfs_fname, 'u-boot-dtb',
- tools.GetInputFilename(compress and 'compress' or 'u-boot.dtb'),
+ tools.get_input_filename(compress and 'compress' or 'u-boot.dtb'),
compress[1] if compress else None,
base[1] if base else None)
return cbfs_fname
"""
if not self.have_cbfstool or not self.have_lz4:
return
- expect = tools.ReadFile(cbfstool_fname)
+ expect = tools.read_file(cbfstool_fname)
if expect != data:
- tools.WriteFile('/tmp/expect', expect)
- tools.WriteFile('/tmp/actual', data)
+ tools.write_file('/tmp/expect', expect)
+ tools.write_file('/tmp/actual', data)
print('diff -y <(xxd -g1 /tmp/expect) <(xxd -g1 /tmp/actual) | colordiff')
self.fail('cbfstool produced a different result')
size = 0xb0
cbw = CbfsWriter(size)
- cbw.add_file_stage('u-boot', tools.ReadFile(elf_fname))
+ cbw.add_file_stage('u-boot', tools.read_file(elf_fname))
data = cbw.get_data()
cbfs = self._check_hdr(data, size)
raise ValueError('Must specify exactly one entry path to write with -f')
entry = image.FindEntryPath(entry_paths[0])
data = entry.ReadData(decomp, alt_format)
- tools.WriteFile(output_fname, data)
+ tools.write_file(output_fname, data)
tout.Notice("Wrote %#x bytes to file '%s'" % (len(data), output_fname))
return
fname = os.path.join(fname, 'root')
tout.Notice("Write entry '%s' size %x to '%s'" %
(entry.GetPath(), len(data), fname))
- tools.WriteFile(fname, data)
+ tools.write_file(fname, data)
return einfos
if len(entry_paths) != 1:
raise ValueError('Must specify exactly one entry path to write with -f')
entry = image.FindEntryPath(entry_paths[0])
- data = tools.ReadFile(input_fname)
+ data = tools.read_file(input_fname)
tout.Notice("Read %#x bytes from file '%s'" % (len(data), input_fname))
WriteEntryToImage(image, entry, data, do_compress=do_compress,
allow_resize=allow_resize, write_map=write_map)
if os.path.exists(fname):
tout.Notice("Write entry '%s' from file '%s'" %
(entry.GetPath(), fname))
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
ReplaceOneEntry(image, entry, data, do_compress, allow_resize)
else:
tout.Warning("Skipping entry '%s' from missing file '%s'" %
# output into a file in our output directly. Then scan it for use
# in binman.
dtb_fname = fdt_util.EnsureCompiled(dtb_fname)
- fname = tools.GetOutputFilename('u-boot.dtb.out')
- tools.WriteFile(fname, tools.ReadFile(dtb_fname))
+ fname = tools.get_output_filename('u-boot.dtb.out')
+ tools.write_file(fname, tools.read_file(dtb_fname))
dtb = fdt.FdtScan(fname)
node = _FindBinmanNode(dtb)
global state
if args.full_help:
- tools.PrintFullHelp(
+ tools.print_full_help(
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README.rst')
)
return 0
if args.cmd in ['ls', 'extract', 'replace', 'tool']:
try:
tout.Init(args.verbosity)
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
if args.cmd == 'ls':
ListEntries(args.image, args.paths)
allow_resize=not args.fix_size, write_map=args.map)
if args.cmd == 'tool':
- tools.SetToolPaths(args.toolpath)
+ tools.set_tool_paths(args.toolpath)
if args.list:
bintool.Bintool.list_all()
elif args.fetch:
except:
raise
finally:
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
return 0
elf_params = None
# runtime.
use_expanded = not args.no_expanded
try:
- tools.SetInputDirs(args.indir)
- tools.PrepareOutputDir(args.outdir, args.preserve)
- tools.SetToolPaths(args.toolpath)
+ tools.set_input_dirs(args.indir)
+ tools.prepare_output_dir(args.outdir, args.preserve)
+ tools.set_tool_paths(args.toolpath)
state.SetEntryArgs(args.entry_arg)
state.SetThreads(args.threads)
# Write the updated FDTs to our output files
for dtb_item in state.GetAllFdts():
- tools.WriteFile(dtb_item._fname, dtb_item.GetContents())
+ tools.write_file(dtb_item._fname, dtb_item.GetContents())
if elf_params:
data = state.GetFdtForEtype('u-boot-dtb').GetContents()
# Use this to debug the time take to pack the image
#state.TimingShow()
finally:
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
finally:
tout.Uninit()
key: Name of symbol
value: Hex value of symbol
"""
- stdout = tools.Run('objdump', '-t', fname)
+ stdout = tools.run('objdump', '-t', fname)
lines = stdout.splitlines()
if patterns:
re_syms = re.compile('|'.join(patterns))
entry: Entry to process
section: Section which can be used to lookup symbol values
"""
- fname = tools.GetInputFilename(elf_fname)
+ fname = tools.get_input_filename(elf_fname)
syms = GetSymbols(fname, ['image', 'binman'])
if not syms:
return
# text section at the start
# -m32: Build for 32-bit x86
# -T...: Specifies the link script, which sets the start address
- cc, args = tools.GetTargetCompileTool('cc')
+ cc, args = tools.get_target_compile_tool('cc')
args += ['-static', '-nostdlib', '-Wl,--build-id=none', '-m32', '-T',
lds_file, '-o', elf_fname, s_file]
stdout = command.Output(cc, *args)
raise ValueError("Not enough space in '%s' for data length %#x (%d); size is %#x (%d)" %
(infile, len(insert), len(insert), size, size))
- data = tools.ReadFile(infile)
+ data = tools.read_file(infile)
newdata = data[:syms[start_sym].offset]
- newdata += insert + tools.GetBytes(0, size - len(insert))
+ newdata += insert + tools.get_bytes(0, size - len(insert))
newdata += data[syms[end_sym].offset:]
- tools.WriteFile(outfile, newdata)
+ tools.write_file(outfile, newdata)
tout.Info('Written to offset %#x' % syms[start_sym].offset)
"""
def __init__(self, contents_size):
self.contents_size = contents_size
- self.data = tools.GetBytes(ord('a'), contents_size)
+ self.data = tools.get_bytes(ord('a'), contents_size)
def GetPath(self):
return 'entry_path'
if 'MAKEFLAGS' in os.environ:
del os.environ['MAKEFLAGS']
try:
- tools.Run('make', '-C', target_dir, '-f',
+ tools.run('make', '-C', target_dir, '-f',
os.path.join(testdir, 'Makefile'), 'SRC=%s/' % testdir)
except ValueError as e:
# The test system seems to suppress this in a strange way
@classmethod
def setUpClass(cls):
cls._indir = tempfile.mkdtemp(prefix='elf.')
- tools.SetInputDirs(['.'])
+ tools.set_input_dirs(['.'])
BuildElfTestFiles(cls._indir)
@classmethod
section = FakeSection(sym_value=None)
elf_fname = self.ElfTestFile('u_boot_binman_syms')
syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
- self.assertEqual(tools.GetBytes(255, 20) + tools.GetBytes(ord('a'), 4),
+ self.assertEqual(tools.get_bytes(255, 20) + tools.get_bytes(ord('a'), 4),
entry.data)
def testDebug(self):
# Make an Elf file and then convert it to a fkat binary file. This
# should produce the original data.
elf.MakeElf(elf_fname, expected_text, expected_data)
- objcopy, args = tools.GetTargetCompileTool('objcopy')
+ objcopy, args = tools.get_target_compile_tool('objcopy')
args += ['-O', 'binary', elf_fname, bin_fname]
stdout = command.Output(objcopy, *args)
with open(bin_fname, 'rb') as fd:
expected_data = b'wxyz'
elf_fname = os.path.join(outdir, 'elf')
elf.MakeElf(elf_fname, expected_text, expected_data)
- data = tools.ReadFile(elf_fname)
+ data = tools.read_file(elf_fname)
load = 0xfef20000
entry = load + 2
offset = elf.GetSymbolFileOffset(fname, ['embed_start', 'embed_end'])
start = offset['embed_start'].offset
end = offset['embed_end'].offset
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
embed_data = data[start:end]
expect = struct.pack('<III', 0x1234, 0x5678, 0)
self.assertEqual(expect, embed_data)
from binman import comp_util
from dtoc import fdt_util
from patman import tools
-from patman.tools import ToHex, ToHexSize
+from patman.tools import to_hex, to_hex_size
from patman import tout
modules = {}
self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
self.align = fdt_util.GetInt(self._node, 'align')
- if tools.NotPowerOfTwo(self.align):
+ if tools.not_power_of_two(self.align):
raise ValueError("Node '%s': Alignment %s must be a power of two" %
(self._node.path, self.align))
if self.section and self.align is None:
self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
self.align_size = fdt_util.GetInt(self._node, 'align-size')
- if tools.NotPowerOfTwo(self.align_size):
+ if tools.not_power_of_two(self.align_size):
self.Raise("Alignment size %s must be a power of two" %
self.align_size)
self.align_end = fdt_util.GetInt(self._node, 'align-end')
# Don't let the data shrink. Pad it if necessary
if size_ok and new_size < self.contents_size:
- data += tools.GetBytes(0, self.contents_size - new_size)
+ data += tools.get_bytes(0, self.contents_size - new_size)
if not size_ok:
tout.Debug("Entry '%s' size change from %s to %s" % (
- self._node.path, ToHex(self.contents_size),
- ToHex(new_size)))
+ self._node.path, to_hex(self.contents_size),
+ to_hex(new_size)))
self.SetContents(data)
return size_ok
def ResetForPack(self):
"""Reset offset/size fields so that packing can be done again"""
self.Detail('ResetForPack: offset %s->%s, size %s->%s' %
- (ToHex(self.offset), ToHex(self.orig_offset),
- ToHex(self.size), ToHex(self.orig_size)))
+ (to_hex(self.offset), to_hex(self.orig_offset),
+ to_hex(self.size), to_hex(self.orig_size)))
self.pre_reset_size = self.size
self.offset = self.orig_offset
self.size = self.orig_size
New section offset pointer (after this entry)
"""
self.Detail('Packing: offset=%s, size=%s, content_size=%x' %
- (ToHex(self.offset), ToHex(self.size),
+ (to_hex(self.offset), to_hex(self.size),
self.contents_size))
if self.offset is None:
if self.offset_unset:
self.Raise('No offset set with offset-unset: should another '
'entry provide this correct offset?')
- self.offset = tools.Align(offset, self.align)
+ self.offset = tools.align(offset, self.align)
needed = self.pad_before + self.contents_size + self.pad_after
- needed = tools.Align(needed, self.align_size)
+ needed = tools.align(needed, self.align_size)
size = self.size
if not size:
size = needed
new_offset = self.offset + size
- aligned_offset = tools.Align(new_offset, self.align_end)
+ aligned_offset = tools.align(new_offset, self.align_end)
if aligned_offset != new_offset:
size = aligned_offset - self.offset
new_offset = aligned_offset
# Check that the alignment is correct. It could be wrong if the
# and offset or size values were provided (i.e. not calculated), but
# conflict with the provided alignment values
- if self.size != tools.Align(self.size, self.align_size):
+ if self.size != tools.align(self.size, self.align_size):
self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
(self.size, self.size, self.align_size, self.align_size))
- if self.offset != tools.Align(self.offset, self.align):
+ if self.offset != tools.align(self.offset, self.align):
self.Raise("Offset %#x (%d) does not match align %#x (%d)" %
(self.offset, self.offset, self.align, self.align))
self.Detail(' - packed: offset=%#x, size=%#x, content_size=%#x, next_offset=%x' %
bytes content of the entry, excluding any padding. If the entry is
compressed, the compressed data is returned
"""
- self.Detail('GetData: size %s' % ToHexSize(self.data))
+ self.Detail('GetData: size %s' % to_hex_size(self.data))
return self.data
def GetPaddedData(self, data=None):
fname (str): Filename of faked file
"""
if self.allow_fake and not pathlib.Path(fname).is_file():
- outfname = tools.GetOutputFilename(os.path.basename(fname))
+ outfname = tools.get_output_filename(os.path.basename(fname))
with open(outfname, "wb") as out:
out.truncate(1024)
self.faked = True
class TestEntry(unittest.TestCase):
def setUp(self):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
def tearDown(self):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def GetNode(self):
binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
self._fip_flags = fdt_util.GetInt64(self._node, 'fip-hdr-flags', 0)
self._fip_align = fdt_util.GetInt(self._node, 'fip-align', 1)
- if tools.NotPowerOfTwo(self._fip_align):
+ if tools.not_power_of_two(self._fip_align):
raise ValueError("Node '%s': FIP alignment %s must be a power of two" %
(self._node.path, self._fip_align))
self.ReadEntries()
def ObtainContents(self):
self._filename = self.GetDefaultFilename()
- self._pathname = tools.GetInputFilename(self._filename,
+ self._pathname = tools.get_input_filename(self._filename,
self.external and self.section.GetAllowMissing())
# Allow the file to be missing
if not self._pathname:
bytes: Data read
"""
state.TimingStart('read')
- indata = tools.ReadFile(pathname)
+ indata = tools.read_file(pathname)
state.TimingAccum('read')
state.TimingStart('compress')
data = self.CompressData(indata)
pathnames = []
for fname in self._filenames:
fname = self.check_fake_fname(fname)
- pathname = tools.GetInputFilename(
+ pathname = tools.get_input_filename(
fname, self.external and self.section.GetAllowMissing())
# Allow the file to be missing
if not pathname:
fdt.pack()
outfdt = Fdt.FromData(fdt.as_bytearray())
data = outfdt.GetContents()
- data = FDTMAP_MAGIC + tools.GetBytes(0, 8) + data
+ data = FDTMAP_MAGIC + tools.get_bytes(0, 8) + data
return data
def ObtainContents(self):
'require-matches')
def ExpandEntries(self):
- files = tools.GetInputFilenameGlob(self._pattern)
+ files = tools.get_input_filename_glob(self._pattern)
if self._require_matches and not files:
self.Raise("Pattern '%s' matched no files" % self._pattern)
for fname in files:
self.fill_value = fdt_util.GetByte(self._node, 'fill-byte', 0)
def ObtainContents(self):
- self.SetContents(tools.GetBytes(self.fill_value, self.size))
+ self.SetContents(tools.get_bytes(self.fill_value, self.size))
return True
for seq, fdt_fname in enumerate(self._fdts):
node_name = subnode.name[1:].replace('SEQ',
str(seq + 1))
- fname = tools.GetInputFilename(fdt_fname + '.dtb')
+ fname = tools.get_input_filename(fdt_fname + '.dtb')
with fsw.add_node(node_name):
for pname, prop in subnode.props.items():
val = prop.bytes.replace(
- b'NAME', tools.ToBytes(fdt_fname))
+ b'NAME', tools.to_bytes(fdt_fname))
val = val.replace(
- b'SEQ', tools.ToBytes(str(seq + 1)))
+ b'SEQ', tools.to_bytes(str(seq + 1)))
fsw.property(pname, val)
# Add data for 'fdt' nodes (but not 'config')
if depth == 1 and in_images:
fsw.property('data',
- tools.ReadFile(fname))
+ tools.read_file(fname))
else:
if self._fdts is None:
if self._fit_list_prop:
# self._BuildInput() either returns bytes or raises an exception.
data = self._BuildInput(self._fdt)
uniq = self.GetUniqueName()
- input_fname = tools.GetOutputFilename('%s.itb' % uniq)
- output_fname = tools.GetOutputFilename('%s.fit' % uniq)
- tools.WriteFile(input_fname, data)
- tools.WriteFile(output_fname, data)
+ input_fname = tools.get_output_filename('%s.itb' % uniq)
+ output_fname = tools.get_output_filename('%s.fit' % uniq)
+ tools.write_file(input_fname, data)
+ tools.write_file(output_fname, data)
args = {}
ext_offset = self._fit_props.get('fit,external-offset')
}
if self.mkimage.run(reset_timestamp=True, output_fname=output_fname,
**args) is not None:
- self.SetContents(tools.ReadFile(output_fname))
+ self.SetContents(tools.read_file(output_fname))
else:
# Bintool is missing; just use empty data as the output
self.record_missing_bintool(self.mkimage)
- self.SetContents(tools.GetBytes(0, 1024))
+ self.SetContents(tools.get_bytes(0, 1024))
return True
from binman.entry import Entry
from binman import fmap_util
from patman import tools
-from patman.tools import ToHexSize
+from patman.tools import to_hex_size
from patman import tout
def _AddEntries(areas, entry):
entries = entry.GetEntries()
tout.Debug("fmap: Add entry '%s' type '%s' (%s subentries)" %
- (entry.GetPath(), entry.etype, ToHexSize(entries)))
+ (entry.GetPath(), entry.etype, to_hex_size(entries)))
if entries and entry.etype != 'cbfs':
# Create an area for the section, which encompasses all entries
# within it
def ObtainContents(self):
gbb = 'gbb.bin'
- fname = tools.GetOutputFilename(gbb)
+ fname = tools.get_output_filename(gbb)
if not self.size:
self.Raise('GBB must have a fixed size')
gbb_size = self.size
bmpfv_size = gbb_size - 0x2180
if bmpfv_size < 0:
self.Raise('GBB is too small (minimum 0x2180 bytes)')
- keydir = tools.GetInputFilename(self.keydir)
+ keydir = tools.get_input_filename(self.keydir)
stdout = self.futility.gbb_create(
fname, [0x100, 0x1000, bmpfv_size, 0x1000])
rootkey='%s/root_key.vbpubk' % keydir,
recoverykey='%s/recovery_key.vbpubk' % keydir,
flags=self.gbb_flags,
- bmpfv=tools.GetInputFilename(self.bmpblk))
+ bmpfv=tools.get_input_filename(self.bmpblk))
if stdout is not None:
- self.SetContents(tools.ReadFile(fname))
+ self.SetContents(tools.read_file(fname))
else:
# Bintool is missing; just use the required amount of zero data
self.record_missing_bintool(self.futility)
- self.SetContents(tools.GetBytes(0, gbb_size))
+ self.SetContents(tools.get_bytes(0, gbb_size))
return True
# Create the IFWI file if needed
if self._convert_fit:
inname = self._pathname
- outname = tools.GetOutputFilename('ifwi.bin')
+ outname = tools.get_output_filename('ifwi.bin')
if self.ifwitool.create_ifwi(inname, outname) is None:
# Bintool is missing; just create a zeroed ifwi.bin
self.record_missing_bintool(self.ifwitool)
- self.SetContents(tools.GetBytes(0, 1024))
+ self.SetContents(tools.get_bytes(0, 1024))
self._filename = 'ifwi.bin'
self._pathname = outname
if self.ifwitool.delete_subpart(outname, 'OBBP') is None:
# Bintool is missing; just use zero data
self.record_missing_bintool(self.ifwitool)
- self.SetContents(tools.GetBytes(0, 1024))
+ self.SetContents(tools.get_bytes(0, 1024))
return True
for entry in self._ifwi_entries.values():
# First get the input data and put it in a file
data = entry.GetPaddedData()
uniq = self.GetUniqueName()
- input_fname = tools.GetOutputFilename('input.%s' % uniq)
- tools.WriteFile(input_fname, data)
+ input_fname = tools.get_output_filename('input.%s' % uniq)
+ tools.write_file(input_fname, data)
# At this point we know that ifwitool is present, so we don't need
# to check for None here
After that we delete the OBBP sub-partition and add each of the files
that we want in the IFWI file, one for each sub-entry of the IWFI node.
"""
- self._pathname = tools.GetInputFilename(self._filename,
+ self._pathname = tools.get_input_filename(self._filename,
self.section.GetAllowMissing())
# Allow the file to be missing
if not self._pathname:
return False
data += entry.GetData()
uniq = self.GetUniqueName()
- input_fname = tools.GetOutputFilename('mkimage.%s' % uniq)
- tools.WriteFile(input_fname, data)
- output_fname = tools.GetOutputFilename('mkimage-out.%s' % uniq)
+ input_fname = tools.get_output_filename('mkimage.%s' % uniq)
+ tools.write_file(input_fname, data)
+ output_fname = tools.get_output_filename('mkimage-out.%s' % uniq)
if self.mkimage.run_cmd('-d', input_fname, *self._args,
output_fname) is not None:
- self.SetContents(tools.ReadFile(output_fname))
+ self.SetContents(tools.read_file(output_fname))
else:
# Bintool is missing; just use the input data as the output
self.record_missing_bintool(self.mkimage)
from dtoc import fdt_util
from patman import tools
from patman import tout
-from patman.tools import ToHexSize
+from patman.tools import to_hex_size
class Entry_section(Entry):
data = bytearray()
# Handle padding before the entry
if entry.pad_before:
- data += tools.GetBytes(self._pad_byte, entry.pad_before)
+ data += tools.get_bytes(self._pad_byte, entry.pad_before)
# Add in the actual entry data
data += entry_data
# Handle padding after the entry
if entry.pad_after:
- data += tools.GetBytes(self._pad_byte, entry.pad_after)
+ data += tools.get_bytes(self._pad_byte, entry.pad_after)
if entry.size:
- data += tools.GetBytes(pad_byte, entry.size - len(data))
+ data += tools.get_bytes(pad_byte, entry.size - len(data))
- self.Detail('GetPaddedDataForEntry: size %s' % ToHexSize(self.data))
+ self.Detail('GetPaddedDataForEntry: size %s' % to_hex_size(self.data))
return data
# Handle empty space before the entry
pad = (entry.offset or 0) - self._skip_at_start - len(section_data)
if pad > 0:
- section_data += tools.GetBytes(self._pad_byte, pad)
+ section_data += tools.get_bytes(self._pad_byte, pad)
# Add in the actual entry data
section_data += data
if not size:
data = self.GetPaddedData(self.data)
size = len(data)
- size = tools.Align(size, self.align_size)
+ size = tools.align(size, self.align_size)
if self.size and contents_size > self.size:
self._Raise("contents size %#x (%d) exceeds section size %#x (%d)" %
(contents_size, contents_size, self.size, self.size))
if not self.size:
self.size = size
- if self.size != tools.Align(self.size, self.align_size):
+ if self.size != tools.align(self.size, self.align_size):
self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
(self.size, self.size, self.align_size,
self.align_size))
super().__init__(section, etype, node)
value = fdt_util.GetString(self._node, 'text')
if value:
- value = tools.ToBytes(value)
+ value = tools.to_bytes(value)
else:
label, = self.GetEntryArgsOrProps([EntryArg('text-label', str)])
self.text_label = label
if self.text_label:
value, = self.GetEntryArgsOrProps([EntryArg(self.text_label,
str)])
- value = tools.ToBytes(value) if value is not None else value
+ value = tools.to_bytes(value) if value is not None else value
self.value = value
def ObtainContents(self):
def ReadBlobContents(self):
if self._strip:
uniq = self.GetUniqueName()
- out_fname = tools.GetOutputFilename('%s.stripped' % uniq)
- tools.WriteFile(out_fname, tools.ReadFile(self._pathname))
- tools.Run('strip', out_fname)
+ out_fname = tools.get_output_filename('%s.stripped' % uniq)
+ tools.write_file(out_fname, tools.read_file(self._pathname))
+ tools.run('strip', out_fname)
self._pathname = out_fname
super().ReadBlobContents()
return True
self.fill_value = fdt_util.GetByte(self._node, 'fill-byte', 0)
def ReadBlobContents(self):
- indata = tools.ReadFile(self._pathname)
+ indata = tools.read_file(self._pathname)
data = b''
for line in indata.splitlines():
data += line + b'\0'
pad = self.size - len(data) - 5
if pad < 0:
self.Raise("'u-boot-env' entry too small to hold data (need %#x more bytes)" % -pad)
- data += tools.GetBytes(self.fill_value, pad)
+ data += tools.get_bytes(self.fill_value, pad)
crc = zlib.crc32(data)
buf = struct.pack('<I', crc) + b'\x01' + data
self.SetContents(buf)
super().__init__(section, etype, node)
def ObtainContents(self):
- fname = tools.GetInputFilename('spl/u-boot-spl')
+ fname = tools.get_input_filename('spl/u-boot-spl')
bss_size = elf.GetSymbolAddress(fname, '__bss_size')
if not bss_size:
self.Raise('Expected __bss_size symbol in spl/u-boot-spl')
- self.SetContents(tools.GetBytes(0, bss_size))
+ self.SetContents(tools.get_bytes(0, bss_size))
return True
super().__init__(section, etype, node)
def ObtainContents(self):
- fname = tools.GetInputFilename('tpl/u-boot-tpl')
+ fname = tools.get_input_filename('tpl/u-boot-tpl')
bss_size = elf.GetSymbolAddress(fname, '__bss_size')
if not bss_size:
self.Raise('Expected __bss_size symbol in tpl/u-boot-tpl')
- self.SetContents(tools.GetBytes(0, bss_size))
+ self.SetContents(tools.get_bytes(0, bss_size))
return True
return True
# Write it out to a file
- self._pathname = tools.GetOutputFilename('u-boot-ucode.bin')
- tools.WriteFile(self._pathname, fdt_entry.ucode_data)
+ self._pathname = tools.get_output_filename('u-boot-ucode.bin')
+ tools.write_file(self._pathname, fdt_entry.ucode_data)
self.ReadBlobContents()
def ProcessFdt(self, fdt):
# Figure out where to put the microcode pointer
- fname = tools.GetInputFilename(self.elf_fname)
+ fname = tools.get_input_filename(self.elf_fname)
sym = elf.GetSymbolAddress(fname, '_dt_ucode_base_size')
if sym:
self.target_offset = sym
return None
uniq = self.GetUniqueName()
- output_fname = tools.GetOutputFilename('vblock.%s' % uniq)
- input_fname = tools.GetOutputFilename('input.%s' % uniq)
- tools.WriteFile(input_fname, input_data)
+ output_fname = tools.get_output_filename('vblock.%s' % uniq)
+ input_fname = tools.get_output_filename('input.%s' % uniq)
+ tools.write_file(input_fname, input_data)
prefix = self.keydir + '/'
stdout = self.futility.sign_firmware(
vblock=output_fname,
kernelkey=prefix + self.kernelkey,
flags=f'{self.preamble_flags}')
if stdout is not None:
- data = tools.ReadFile(output_fname)
+ data = tools.read_file(output_fname)
else:
# Bintool is missing; just use 4KB of zero data
self.record_missing_bintool(self.futility)
- data = tools.GetBytes(0, 4096)
+ data = tools.get_bytes(0, 4096)
return data
def ObtainContents(self):
def setUpClass(self):
self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
self._indir = tempfile.mkdtemp(prefix='binmant.')
- tools.PrepareOutputDir(self._indir, True)
+ tools.prepare_output_dir(self._indir, True)
@classmethod
def tearDownClass(self):
- tools._FinaliseForTest()
+ tools._finalise_for_test()
def TestFile(self, fname):
return os.path.join(self._binman_dir, 'test', fname)
self.flags = flags
self.fip_type = None
self.data = None
- self.valid = uuid != tools.GetBytes(0, UUID_LEN)
+ self.valid = uuid != tools.get_bytes(0, UUID_LEN)
if self.valid:
# Look up the friendly name
matches = {val for (key, val) in FIP_TYPES.items()
Usage is something like:
fip = FipWriter(size)
- fip.add_entry('scp-fwu-cfg', tools.ReadFile('something.bin'))
+ fip.add_entry('scp-fwu-cfg', tools.read_file('something.bin'))
...
data = cbw.get_data()
offset += ENTRY_SIZE # terminating entry
for fent in self._fip_entries:
- offset = tools.Align(offset, self._align)
+ offset = tools.align(offset, self._align)
fent.offset = offset
offset += fent.size
re_uuid = re.compile('0x[0-9a-fA-F]{2}')
re_comment = re.compile(r'^/\* (.*) \*/$')
fname = os.path.join(srcdir, 'include/tools_share/firmware_image_package.h')
- data = tools.ReadFile(fname, binary=False)
+ data = tools.read_file(fname, binary=False)
macros = collections.OrderedDict()
comment = None
for linenum, line in enumerate(data.splitlines()):
re_data = re.compile(r'\.name = "([^"]*)",\s*\.uuid = (UUID_\w*),\s*\.cmdline_name = "([^"]+)"',
re.S)
fname = os.path.join(srcdir, 'tools/fiptool/tbbr_config.c')
- data = tools.ReadFile(fname, binary=False)
+ data = tools.read_file(fname, binary=False)
# Example entry:
# {
raise ValueError(
f"Expected file '{readme_fname}' - try using -s to specify the "
'arm-trusted-firmware directory')
- readme = tools.ReadFile(readme_fname, binary=False)
+ readme = tools.read_file(readme_fname, binary=False)
first_line = 'Trusted Firmware-A'
if readme.splitlines()[0] != first_line:
raise ValueError(f"'{readme_fname}' does not start with '{first_line}'")
macros = parse_macros(srcdir)
names = parse_names(srcdir)
output = create_code_output(macros, names)
- orig = tools.ReadFile(oldfile, binary=False)
+ orig = tools.read_file(oldfile, binary=False)
re_fip_list = re.compile(r'(.*FIP_TYPE_LIST = \[).*?( ] # end.*)', re.S)
mat = re_fip_list.match(orig)
new_code = mat.group(1) + '\n' + output + mat.group(2) if mat else output
if new_code == orig:
print(f"Existing code in '{oldfile}' is up-to-date")
else:
- tools.WriteFile(dstfile, new_code, binary=False)
+ tools.write_file(dstfile, new_code, binary=False)
print(f'Needs update, try:\n\tmeld {dstfile} {oldfile}')
def setUp(self):
# Create a temporary directory for test files
self._indir = tempfile.mkdtemp(prefix='fip_util.')
- tools.SetInputDirs([self._indir])
+ tools.set_input_dirs([self._indir])
# Set up a temporary output directory, used by the tools library when
# compressing files
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
self.src_file = os.path.join(self._indir, 'orig.py')
- self.outname = tools.GetOutputFilename('out.py')
+ self.outname = tools.get_output_filename('out.py')
self.args = ['-D', '-s', self._indir, '-o', self.outname]
self.readme = os.path.join(self._indir, 'readme.rst')
self.macro_dir = os.path.join(self._indir, 'include/tools_share')
def setup_readme(self):
"""Set up the readme.txt file"""
- tools.WriteFile(self.readme, 'Trusted Firmware-A\n==================',
+ tools.write_file(self.readme, 'Trusted Firmware-A\n==================',
binary=False)
def setup_macro(self, data=macro_contents):
"""Set up the tbbr_config.c file"""
os.makedirs(self.macro_dir)
- tools.WriteFile(self.macro_fname, data, binary=False)
+ tools.write_file(self.macro_fname, data, binary=False)
def setup_name(self, data=name_contents):
"""Set up the firmware_image_package.h file"""
os.makedirs(self.name_dir)
- tools.WriteFile(self.name_fname, data, binary=False)
+ tools.write_file(self.name_fname, data, binary=False)
def tearDown(self):
"""Remove the temporary input directory and its contents"""
if self._indir:
shutil.rmtree(self._indir)
self._indir = None
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def test_no_readme(self):
"""Test handling of a missing readme.rst"""
def test_invalid_readme(self):
"""Test that an invalid readme.rst is detected"""
- tools.WriteFile(self.readme, 'blah', binary=False)
+ tools.write_file(self.readme, 'blah', binary=False)
with self.assertRaises(Exception) as err:
fip_util.main(self.args, self.src_file)
self.assertIn('does not start with', str(err.exception))
self.setup_name()
# Check generating the file when changes are needed
- tools.WriteFile(self.src_file, '''
+ tools.write_file(self.src_file, '''
# This is taken from tbbr_config.c in ARM Trusted Firmware
FIP_TYPE_LIST = [
self.assertIn('Needs update', stdout.getvalue())
# Check generating the file when no changes are needed
- tools.WriteFile(self.src_file, '''
+ tools.write_file(self.src_file, '''
# This is taken from tbbr_config.c in ARM Trusted Firmware
FIP_TYPE_LIST = [
# ToC Entry UUIDs
args = self.args.copy()
args.remove('-D')
- tools.WriteFile(self.src_file, '', binary=False)
+ tools.write_file(self.src_file, '', binary=False)
with test_util.capture_sys_output():
fip_util.main(args, self.src_file)
fip.add_entry('tb-fw', tb_fw, 0)
fip.add_entry(bytes(range(16)), tb_fw, 0)
data = fip.get_data()
- fname = tools.GetOutputFilename('data.fip')
- tools.WriteFile(fname, data)
+ fname = tools.get_output_filename('data.fip')
+ tools.write_file(fname, data)
result = FIPTOOL.info(fname)
self.assertEqual(
'''Firmware Updater NS_BL2U: offset=0xB0, size=0x7, cmdline="--fwu"
FipReader: reader for the image
"""
fwu = os.path.join(self._indir, 'fwu')
- tools.WriteFile(fwu, self.fwu_data)
+ tools.write_file(fwu, self.fwu_data)
tb_fw = os.path.join(self._indir, 'tb_fw')
- tools.WriteFile(tb_fw, self.tb_fw_data)
+ tools.write_file(tb_fw, self.tb_fw_data)
other_fw = os.path.join(self._indir, 'other_fw')
- tools.WriteFile(other_fw, self.other_fw_data)
+ tools.write_file(other_fw, self.other_fw_data)
- fname = tools.GetOutputFilename('data.fip')
+ fname = tools.get_output_filename('data.fip')
uuid = 'e3b78d9e-4a64-11ec-b45c-fba2b9b49788'
FIPTOOL.create_new(fname, 8, 0x123, fwu, tb_fw, uuid, other_fw)
- return fip_util.FipReader(tools.ReadFile(fname))
+ return fip_util.FipReader(tools.read_file(fname))
@unittest.skipIf(not HAVE_FIPTOOL, 'No fiptool available')
def test_fiptool_create(self):
value: value of that field (string for the ones we support)
"""
name_index = field_names.index('name')
- fields[name_index] = tools.ToBytes(NameToFmap(fields[name_index]))
+ fields[name_index] = tools.to_bytes(NameToFmap(fields[name_index]))
def DecodeFmap(data):
"""Decode a flashmap into a header and list of areas
# ELF file with a '_dt_ucode_base_size' symbol
TestFunctional._MakeInputFile('u-boot',
- tools.ReadFile(cls.ElfTestFile('u_boot_ucode_ptr')))
+ tools.read_file(cls.ElfTestFile('u_boot_ucode_ptr')))
# Intel flash descriptor file
cls._SetupDescriptor()
if self.preserve_outdirs:
print('Preserving output dir: %s' % tools.outdir)
else:
- tools._FinaliseForTest()
+ tools._finalise_for_test()
def setUp(self):
# Enable this to turn on debugging output
Temporary directory to use
New image filename
"""
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
tmpdir = tempfile.mkdtemp(prefix='binman.')
updated_fname = os.path.join(tmpdir, 'image-updated.bin')
- tools.WriteFile(updated_fname, tools.ReadFile(image_fname))
+ tools.write_file(updated_fname, tools.read_file(image_fname))
self._CleanupOutputDir()
return tmpdir, updated_fname
use_expanded=use_expanded, extra_indirs=extra_indirs,
threads=threads)
self.assertEqual(0, retcode)
- out_dtb_fname = tools.GetOutputFilename('u-boot.dtb.out')
+ out_dtb_fname = tools.get_output_filename('u-boot.dtb.out')
# Find the (only) image, read it and return its contents
image = control.images['image']
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
self.assertTrue(os.path.exists(image_fname))
if map:
- map_fname = tools.GetOutputFilename('image.map')
+ map_fname = tools.get_output_filename('image.map')
with open(map_fname) as fd:
map_data = fd.read()
else:
Filename of ELF file to use as SPL
"""
TestFunctional._MakeInputFile('spl/u-boot-spl',
- tools.ReadFile(cls.ElfTestFile(src_fname)))
+ tools.read_file(cls.ElfTestFile(src_fname)))
@classmethod
def _SetupTplElf(cls, src_fname='bss_data'):
Filename of ELF file to use as TPL
"""
TestFunctional._MakeInputFile('tpl/u-boot-tpl',
- tools.ReadFile(cls.ElfTestFile(src_fname)))
+ tools.read_file(cls.ElfTestFile(src_fname)))
@classmethod
def _SetupDescriptor(cls):
image = control.images['image1']
self.assertEqual(len(U_BOOT_DATA), image.size)
- fname = tools.GetOutputFilename('image1.bin')
+ fname = tools.get_output_filename('image1.bin')
self.assertTrue(os.path.exists(fname))
with open(fname, 'rb') as fd:
data = fd.read()
image = control.images['image2']
self.assertEqual(3 + len(U_BOOT_DATA) + 5, image.size)
- fname = tools.GetOutputFilename('image2.bin')
+ fname = tools.get_output_filename('image2.bin')
self.assertTrue(os.path.exists(fname))
with open(fname, 'rb') as fd:
data = fd.read()
self.assertEqual(U_BOOT_DATA, data[3:7])
- self.assertEqual(tools.GetBytes(0, 3), data[:3])
- self.assertEqual(tools.GetBytes(0, 5), data[7:])
+ self.assertEqual(tools.get_bytes(0, 3), data[:3])
+ self.assertEqual(tools.get_bytes(0, 5), data[7:])
def testBadAlign(self):
"""Test that an invalid alignment value is detected"""
self.assertEqual(3, entry.pad_before)
self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size)
self.assertEqual(U_BOOT_DATA, entry.data)
- self.assertEqual(tools.GetBytes(0, 3) + U_BOOT_DATA +
- tools.GetBytes(0, 5), data[:entry.size])
+ self.assertEqual(tools.get_bytes(0, 3) + U_BOOT_DATA +
+ tools.get_bytes(0, 5), data[:entry.size])
pos = entry.size
# Second u-boot has an aligned size, but it has no effect
self.assertEqual(pos, entry.offset)
self.assertEqual(32, entry.size)
self.assertEqual(U_BOOT_DATA, entry.data)
- self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 32 - len(U_BOOT_DATA)),
+ self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 32 - len(U_BOOT_DATA)),
data[pos:pos + entry.size])
pos += entry.size
self.assertEqual(48, entry.offset)
self.assertEqual(16, entry.size)
self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
- self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 16 - len(U_BOOT_DATA)),
+ self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 16 - len(U_BOOT_DATA)),
data[pos:pos + entry.size])
pos += entry.size
self.assertEqual(64, entry.offset)
self.assertEqual(64, entry.size)
self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
- self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 64 - len(U_BOOT_DATA)),
+ self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 64 - len(U_BOOT_DATA)),
data[pos:pos + entry.size])
self.CheckNoGaps(entries)
"""Test that the image pad byte can be specified"""
self._SetupSplElf()
data = self._DoReadFile('021_image_pad.dts')
- self.assertEqual(U_BOOT_SPL_DATA + tools.GetBytes(0xff, 1) +
+ self.assertEqual(U_BOOT_SPL_DATA + tools.get_bytes(0xff, 1) +
U_BOOT_DATA, data)
def testImageName(self):
retcode = self._DoTestFile('022_image_name.dts')
self.assertEqual(0, retcode)
image = control.images['image1']
- fname = tools.GetOutputFilename('test-name')
+ fname = tools.get_output_filename('test-name')
self.assertTrue(os.path.exists(fname))
image = control.images['image2']
- fname = tools.GetOutputFilename('test-name.xx')
+ fname = tools.get_output_filename('test-name.xx')
self.assertTrue(os.path.exists(fname))
def testBlobFilename(self):
"""Test that entries can be sorted"""
self._SetupSplElf()
data = self._DoReadFile('024_sorted.dts')
- self.assertEqual(tools.GetBytes(0, 1) + U_BOOT_SPL_DATA +
- tools.GetBytes(0, 2) + U_BOOT_DATA, data)
+ self.assertEqual(tools.get_bytes(0, 1) + U_BOOT_SPL_DATA +
+ tools.get_bytes(0, 2) + U_BOOT_DATA, data)
def testPackZeroOffset(self):
"""Test that an entry at offset 0 is not given a new offset"""
"""Test that a basic x86 ROM can be created"""
self._SetupSplElf()
data = self._DoReadFile('029_x86_rom.dts')
- self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 3) + U_BOOT_SPL_DATA +
- tools.GetBytes(0, 2), data)
+ self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 3) + U_BOOT_SPL_DATA +
+ tools.get_bytes(0, 2), data)
def testPackX86RomMeNoDesc(self):
"""Test that an invalid Intel descriptor entry is detected"""
def testPackX86RomMe(self):
"""Test that an x86 ROM with an ME region can be created"""
data = self._DoReadFile('031_x86_rom_me.dts')
- expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
+ expected_desc = tools.read_file(self.TestFile('descriptor.bin'))
if data[:0x1000] != expected_desc:
self.fail('Expected descriptor binary at start of image')
self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
fdt_len = self.GetFdtLen(dtb_with_ucode)
ucode_content = dtb_with_ucode[fdt_len:]
ucode_pos = len(nodtb_data) + fdt_len
- fname = tools.GetOutputFilename('test.dtb')
+ fname = tools.get_output_filename('test.dtb')
with open(fname, 'wb') as fd:
fd.write(dtb_with_ucode)
dtb = fdt.FdtScan(fname)
# ELF file without a '_dt_ucode_base_size' symbol
try:
TestFunctional._MakeInputFile('u-boot',
- tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
+ tools.read_file(self.ElfTestFile('u_boot_no_ucode_ptr')))
with self.assertRaises(ValueError) as e:
self._RunPackUbootSingleMicrocode()
finally:
# Put the original file back
TestFunctional._MakeInputFile('u-boot',
- tools.ReadFile(self.ElfTestFile('u_boot_ucode_ptr')))
+ tools.read_file(self.ElfTestFile('u_boot_ucode_ptr')))
def testMicrocodeNotInImage(self):
"""Test that microcode must be placed within the image"""
def testWithoutMicrocode(self):
"""Test that we can cope with an image without microcode (e.g. qemu)"""
TestFunctional._MakeInputFile('u-boot',
- tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
+ tools.read_file(self.ElfTestFile('u_boot_no_ucode_ptr')))
data, dtb, _, _ = self._DoReadFileDtb('044_x86_optional_ucode.dts', True)
# Now check the device tree has no microcode
used_len = len(U_BOOT_NODTB_DATA) + fdt_len
third = data[used_len:]
- self.assertEqual(tools.GetBytes(0, 0x200 - used_len), third)
+ self.assertEqual(tools.get_bytes(0, 0x200 - used_len), third)
def testUnknownPosSize(self):
"""Test that microcode must be placed within the image"""
# ELF file with a '__bss_size' symbol
self._SetupSplElf()
data = self._DoReadFile('047_spl_bss_pad.dts')
- self.assertEqual(U_BOOT_SPL_DATA + tools.GetBytes(0, 10) + U_BOOT_DATA,
+ self.assertEqual(U_BOOT_SPL_DATA + tools.get_bytes(0, 10) + U_BOOT_DATA,
data)
def testSplBssPadMissing(self):
u_boot_offset + len(U_BOOT_DATA),
0x10 + u_boot_offset, 0x04)
expected = (sym_values + base_data[20:] +
- tools.GetBytes(0xff, 1) + U_BOOT_DATA + sym_values +
+ tools.get_bytes(0xff, 1) + U_BOOT_DATA + sym_values +
base_data[20:])
self.assertEqual(expected, data)
def testSections(self):
"""Basic test of sections"""
data = self._DoReadFile('055_sections.dts')
- expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('a'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('&'), 4))
+ expected = (U_BOOT_DATA + tools.get_bytes(ord('!'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('a'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('&'), 4))
self.assertEqual(expected, data)
def testMap(self):
}
data, _, _, _ = self._DoReadFileDtb('066_text.dts',
entry_args=entry_args)
- expected = (tools.ToBytes(TEXT_DATA) +
- tools.GetBytes(0, 8 - len(TEXT_DATA)) +
- tools.ToBytes(TEXT_DATA2) + tools.ToBytes(TEXT_DATA3) +
+ expected = (tools.to_bytes(TEXT_DATA) +
+ tools.get_bytes(0, 8 - len(TEXT_DATA)) +
+ tools.to_bytes(TEXT_DATA2) + tools.to_bytes(TEXT_DATA3) +
b'some text' + b'more text')
self.assertEqual(expected, data)
"""Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('067_fmap.dts')
fhdr, fentries = fmap_util.DecodeFmap(data[32:])
- expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('a'), 12))
+ expected = (U_BOOT_DATA + tools.get_bytes(ord('!'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('a'), 12))
self.assertEqual(expected, data[:32])
self.assertEqual(b'__FMAP__', fhdr.signature)
self.assertEqual(1, fhdr.ver_major)
def testFill(self):
"""Test for an fill entry type"""
data = self._DoReadFile('069_fill.dts')
- expected = tools.GetBytes(0xff, 8) + tools.GetBytes(0, 8)
+ expected = tools.get_bytes(0xff, 8) + tools.get_bytes(0, 8)
self.assertEqual(expected, data)
def testFillNoSize(self):
data, _, _, _ = self._DoReadFileDtb('071_gbb.dts', entry_args=entry_args)
# Since futility
- expected = (GBB_DATA + GBB_DATA + tools.GetBytes(0, 8) +
- tools.GetBytes(0, 0x2180 - 16))
+ expected = (GBB_DATA + GBB_DATA + tools.get_bytes(0, 8) +
+ tools.get_bytes(0, 0x2180 - 16))
self.assertEqual(expected, data)
def testGbbTooSmall(self):
if self._hash_data:
infile = pipe_list[0][11]
m = hashlib.sha256()
- data = tools.ReadFile(infile)
+ data = tools.read_file(infile)
m.update(data)
fd.write(m.digest())
else:
def testFillZero(self):
"""Test for an fill entry type with a size of 0"""
data = self._DoReadFile('080_fill_empty.dts')
- self.assertEqual(tools.GetBytes(0, 16), data)
+ self.assertEqual(tools.get_bytes(0, 16), data)
def testTextMissing(self):
"""Test for a text entry type where there is no text"""
else:
self.assertNotIn(expected, stdout.getvalue())
- self.assertFalse(os.path.exists(tools.GetOutputFilename('image1.bin')))
- self.assertTrue(os.path.exists(tools.GetOutputFilename('image2.bin')))
+ self.assertFalse(os.path.exists(tools.get_output_filename('image1.bin')))
+ self.assertTrue(os.path.exists(tools.get_output_filename('image2.bin')))
self._CleanupOutputDir()
def testUpdateFdtAll(self):
'tpl/u-boot-tpl.dtb.out']:
dtb = fdt.Fdt.FromData(data[start:])
size = dtb._fdt_obj.totalsize()
- pathname = tools.GetOutputFilename(os.path.split(fname)[1])
- outdata = tools.ReadFile(pathname)
+ pathname = tools.get_output_filename(os.path.split(fname)[1])
+ outdata = tools.read_file(pathname)
name = os.path.split(fname)[0]
if name:
"""Test an expanding entry"""
data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts',
map=True)
- expect = (tools.GetBytes(ord('a'), 8) + U_BOOT_DATA +
- MRC_DATA + tools.GetBytes(ord('b'), 1) + U_BOOT_DATA +
- tools.GetBytes(ord('c'), 8) + U_BOOT_DATA +
- tools.GetBytes(ord('d'), 8))
+ expect = (tools.get_bytes(ord('a'), 8) + U_BOOT_DATA +
+ MRC_DATA + tools.get_bytes(ord('b'), 1) + U_BOOT_DATA +
+ tools.get_bytes(ord('c'), 8) + U_BOOT_DATA +
+ tools.get_bytes(ord('d'), 8))
self.assertEqual(expect, data)
self.assertEqual('''ImagePos Offset Size Name
00000000 00000000 00000028 main-section
hash_node = dtb.GetNode('/binman/section/hash').props['value']
m = hashlib.sha256()
m.update(U_BOOT_DATA)
- m.update(tools.GetBytes(ord('a'), 16))
+ m.update(tools.get_bytes(ord('a'), 16))
self.assertEqual(m.digest(), b''.join(hash_node.value))
def testPackUBootTplMicrocode(self):
"""Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('094_fmap_x86.dts')
fhdr, fentries = fmap_util.DecodeFmap(data[32:])
- expected = U_BOOT_DATA + MRC_DATA + tools.GetBytes(ord('a'), 32 - 7)
+ expected = U_BOOT_DATA + MRC_DATA + tools.get_bytes(ord('a'), 32 - 7)
self.assertEqual(expected, data[:32])
fhdr, fentries = fmap_util.DecodeFmap(data[32:])
def testFmapX86Section(self):
"""Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('095_fmap_x86_section.dts')
- expected = U_BOOT_DATA + MRC_DATA + tools.GetBytes(ord('b'), 32 - 7)
+ expected = U_BOOT_DATA + MRC_DATA + tools.get_bytes(ord('b'), 32 - 7)
self.assertEqual(expected, data[:32])
fhdr, fentries = fmap_util.DecodeFmap(data[36:])
with test_util.capture_sys_output() as (stdout, stderr):
with self.assertRaises(ValueError) as e:
self._DoTestFile('014_pack_overlap.dts', map=True)
- map_fname = tools.GetOutputFilename('image.map')
+ map_fname = tools.get_output_filename('image.map')
self.assertEqual("Wrote map file '%s' to show errors\n" % map_fname,
stdout.getvalue())
# We should not get an inmage, but there should be a map file
- self.assertFalse(os.path.exists(tools.GetOutputFilename('image.bin')))
+ self.assertFalse(os.path.exists(tools.get_output_filename('image.bin')))
self.assertTrue(os.path.exists(map_fname))
- map_data = tools.ReadFile(map_fname, binary=False)
+ map_data = tools.read_file(map_fname, binary=False)
self.assertEqual('''ImagePos Offset Size Name
<none> 00000000 00000008 main-section
<none> 00000000 00000004 u-boot
0000002c 00000000 00000004 u-boot
''', map_data)
self.assertEqual(data,
- tools.GetBytes(0x26, 4) + U_BOOT_DATA +
- tools.GetBytes(0x21, 12) +
- tools.GetBytes(0x26, 4) + U_BOOT_DATA +
- tools.GetBytes(0x61, 12) +
- tools.GetBytes(0x26, 4) + U_BOOT_DATA +
- tools.GetBytes(0x26, 8))
+ tools.get_bytes(0x26, 4) + U_BOOT_DATA +
+ tools.get_bytes(0x21, 12) +
+ tools.get_bytes(0x26, 4) + U_BOOT_DATA +
+ tools.get_bytes(0x61, 12) +
+ tools.get_bytes(0x26, 4) + U_BOOT_DATA +
+ tools.get_bytes(0x26, 8))
def testCbfsRaw(self):
"""Test base handling of a Coreboot Filesystem (CBFS)
Args:
data: Conents of output file
"""
- expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
+ expected_desc = tools.read_file(self.TestFile('descriptor.bin'))
if data[:0x1000] != expected_desc:
self.fail('Expected descriptor binary at start of image')
# We expect to find the TPL wil in subpart IBBP entry IBBL
- image_fname = tools.GetOutputFilename('image.bin')
- tpl_fname = tools.GetOutputFilename('tpl.out')
+ image_fname = tools.get_output_filename('image.bin')
+ tpl_fname = tools.get_output_filename('tpl.out')
ifwitool = bintool.Bintool.create('ifwitool')
ifwitool.extract(image_fname, 'IBBP', 'IBBL', tpl_fname)
- tpl_data = tools.ReadFile(tpl_fname)
+ tpl_data = tools.read_file(tpl_fname)
self.assertEqual(U_BOOT_TPL_DATA, tpl_data[:len(U_BOOT_TPL_DATA)])
def testPackX86RomIfwi(self):
fdtmap_data = data[len(U_BOOT_DATA):]
magic = fdtmap_data[:8]
self.assertEqual(b'_FDTMAP_', magic)
- self.assertEqual(tools.GetBytes(0, 8), fdtmap_data[8:16])
+ self.assertEqual(tools.get_bytes(0, 8), fdtmap_data[8:16])
fdt_data = fdtmap_data[16:]
dtb = fdt.Fdt.FromData(fdt_data)
"""Test reading an image and accessing its FDT map"""
self._CheckLz4()
data = self.data = self._DoReadFileRealDtb('128_decode_image.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
orig_image = control.images['image']
image = Image.FromFile(image_fname)
self.assertEqual(orig_image.GetEntries().keys(),
"""Test accessing an image's FDT map without an image header"""
self._CheckLz4()
data = self._DoReadFileRealDtb('129_decode_image_nohdr.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
image = Image.FromFile(image_fname)
self.assertTrue(isinstance(image, Image))
self.assertEqual('image', image.image_name[-5:])
def testReadImageFail(self):
"""Test failing to read an image image's FDT map"""
self._DoReadFile('005_simple.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
with self.assertRaises(ValueError) as e:
image = Image.FromFile(image_fname)
self.assertIn("Cannot find FDT map in image", str(e.exception))
"""
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
image = Image.FromFile(image_fname)
lines = image.GetListEntries(paths)[1]
files = [line[0].strip() for line in lines[1:]]
"""
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
return control.ReadEntry(image_fname, entry_name, decomp)
def testExtractSimple(self):
def testExtractBadFile(self):
"""Test extracting an invalid file"""
fname = os.path.join(self._indir, 'badfile')
- tools.WriteFile(fname, b'')
+ tools.write_file(fname, b'')
with self.assertRaises(ValueError) as e:
control.ReadEntry(fname, 'name')
'-f', fname)
finally:
shutil.rmtree(tmpdir)
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def testExtractOneEntry(self):
"""Test extracting a single entry fron an image """
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
fname = os.path.join(self._indir, 'output.extact')
control.ExtractEntries(image_fname, fname, None, ['u-boot'])
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def _CheckExtractOutput(self, decomp):
expect_size: Size of data to expect in file, or None to skip
"""
path = os.path.join(outdir, entry_path)
- data = tools.ReadFile(path)
+ data = tools.read_file(path)
os.remove(path)
if expect_data:
self.assertEqual(expect_data, data)
os.rmdir(path)
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
outdir = os.path.join(self._indir, 'extract')
einfos = control.ExtractEntries(image_fname, None, outdir, [], decomp)
_CheckPresent('section/root', section.data)
cbfs = section_entries['cbfs']
_CheckPresent('section/cbfs/root', cbfs.data)
- data = tools.ReadFile(image_fname)
+ data = tools.read_file(image_fname)
_CheckPresent('root', data)
# There should be no files left. Remove all the directories to check.
"""Test extracting some entries"""
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
outdir = os.path.join(self._indir, 'extract')
einfos = control.ExtractEntries(image_fname, None, outdir,
['*cb*', '*head*'])
"""Test extracting some entries"""
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
with self.assertRaises(ValueError) as e:
control.ExtractEntries(image_fname, 'fname', None, [])
self.assertIn('Must specify an entry path to write with -f',
"""Test extracting some entries"""
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
with self.assertRaises(ValueError) as e:
control.ExtractEntries(image_fname, 'fname', None, ['a', 'b'])
self.assertIn('Must specify exactly one entry path to write with -f',
orig_dtb_data = entries['u-boot-dtb'].data
orig_fdtmap_data = entries['fdtmap'].data
- image_fname = tools.GetOutputFilename('image.bin')
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, tools.ReadFile(image_fname))
+ image_fname = tools.get_output_filename('image.bin')
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, tools.read_file(image_fname))
image = control.WriteEntry(updated_fname, entry_name, data, decomp,
allow_resize)
data = control.ReadEntry(updated_fname, entry_name, decomp)
data = self._DoReadFileDtb('133_replace_multi.dts', use_real_dtb=True,
update_dtb=True)[0]
expected = b'x' * len(U_BOOT_DATA)
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, data)
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, data)
entry_name = 'u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=False)
self.assertEqual('/binman/image', state.fdt_path_prefix)
# Now check we can write the first image
- image_fname = tools.GetOutputFilename('first-image.bin')
- updated_fname = tools.GetOutputFilename('first-updated.bin')
- tools.WriteFile(updated_fname, tools.ReadFile(image_fname))
+ image_fname = tools.get_output_filename('first-image.bin')
+ updated_fname = tools.get_output_filename('first-updated.bin')
+ tools.write_file(updated_fname, tools.read_file(image_fname))
entry_name = 'u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=False)
self._CheckLz4()
expected = b'x' * len(U_BOOT_DATA)
data = self._DoReadFileRealDtb('142_replace_cbfs.dts')
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, data)
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, data)
entry_name = 'section/cbfs/u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=True)
self._CheckLz4()
expected = U_BOOT_DATA + b'x'
data = self._DoReadFileRealDtb('142_replace_cbfs.dts')
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, data)
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, data)
entry_name = 'section/cbfs/u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=True)
"""
data = self._DoReadFileRealDtb('143_replace_all.dts')
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, data)
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, data)
outdir = os.path.join(self._indir, 'extract')
einfos = control.ExtractEntries(updated_fname, None, outdir, [])
expected1 = b'x' + U_BOOT_DATA + b'y'
u_boot_fname1 = os.path.join(outdir, 'u-boot')
- tools.WriteFile(u_boot_fname1, expected1)
+ tools.write_file(u_boot_fname1, expected1)
expected2 = b'a' + U_BOOT_DATA + b'b'
u_boot_fname2 = os.path.join(outdir, 'u-boot2')
- tools.WriteFile(u_boot_fname2, expected2)
+ tools.write_file(u_boot_fname2, expected2)
expected_text = b'not the same text'
text_fname = os.path.join(outdir, 'text')
- tools.WriteFile(text_fname, expected_text)
+ tools.write_file(text_fname, expected_text)
dtb_fname = os.path.join(outdir, 'u-boot-dtb')
dtb = fdt.FdtScan(dtb_fname)
fname = os.path.join(tmpdir, 'update-u-boot.bin')
expected = b'x' * len(U_BOOT_DATA)
- tools.WriteFile(fname, expected)
+ tools.write_file(fname, expected)
self._DoBinman('replace', '-i', updated_fname, 'u-boot', '-f', fname)
- data = tools.ReadFile(updated_fname)
+ data = tools.read_file(updated_fname)
self.assertEqual(expected, data[:len(expected)])
map_fname = os.path.join(tmpdir, 'image-updated.map')
self.assertFalse(os.path.exists(map_fname))
self._DoBinman('replace', '-i', updated_fname, '-I', outdir,
'u-boot2', 'text')
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
image = Image.FromFile(updated_fname)
image.LoadData()
entries = image.GetEntries()
fname = os.path.join(self._indir, 'update-u-boot.bin')
expected = b'x' * len(U_BOOT_DATA)
- tools.WriteFile(fname, expected)
+ tools.write_file(fname, expected)
self._DoBinman('replace', '-i', updated_fname, 'u-boot',
'-f', fname, '-m')
def testReplaceNoEntryPaths(self):
"""Test replacing an entry without an entry path"""
self._DoReadFileRealDtb('143_replace_all.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
with self.assertRaises(ValueError) as e:
control.ReplaceEntries(image_fname, 'fname', None, [])
self.assertIn('Must specify an entry path to read with -f',
def testReplaceTooManyEntryPaths(self):
"""Test extracting some entries"""
self._DoReadFileRealDtb('143_replace_all.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
with self.assertRaises(ValueError) as e:
control.ReplaceEntries(image_fname, 'fname', None, ['a', 'b'])
self.assertIn('Must specify exactly one entry path to write with -f',
data = self._DoReadFile(dts)
sym_values = struct.pack('<LQLL', *expected_vals)
upto1 = 4 + len(U_BOOT_SPL_DATA)
- expected1 = tools.GetBytes(0xff, 4) + sym_values + U_BOOT_SPL_DATA[20:]
+ expected1 = tools.get_bytes(0xff, 4) + sym_values + U_BOOT_SPL_DATA[20:]
self.assertEqual(expected1, data[:upto1])
upto2 = upto1 + 1 + len(U_BOOT_SPL_DATA)
- expected2 = tools.GetBytes(0xff, 1) + sym_values + U_BOOT_SPL_DATA[20:]
+ expected2 = tools.get_bytes(0xff, 1) + sym_values + U_BOOT_SPL_DATA[20:]
self.assertEqual(expected2, data[upto1:upto2])
upto3 = 0x34 + len(U_BOOT_DATA)
- expected3 = tools.GetBytes(0xff, 1) + U_BOOT_DATA
+ expected3 = tools.get_bytes(0xff, 1) + U_BOOT_DATA
self.assertEqual(expected3, data[upto2:upto3])
expected4 = sym_values + U_BOOT_TPL_DATA[20:]
self.assertIn('data', fnode.props)
fname = os.path.join(self._indir, 'fit_data.fit')
- tools.WriteFile(fname, fit_data)
- out = tools.Run('dumpimage', '-l', fname)
+ tools.write_file(fname, fit_data)
+ out = tools.run('dumpimage', '-l', fname)
# Check a few features to make sure the plumbing works. We don't need
# to test the operation of mkimage or dumpimage here. First convert the
# Size of the external-data region as set up by mkimage
external_data_size = len(U_BOOT_DATA) + 2
expected_size = (len(U_BOOT_DATA) + 0x400 +
- tools.Align(external_data_size, 4) +
+ tools.align(external_data_size, 4) +
len(U_BOOT_NODTB_DATA))
# The data should be outside the FIT
"""Test pad-before, pad-after for entries in sections"""
data, _, _, out_dtb_fname = self._DoReadFileDtb(
'166_pad_in_sections.dts', update_dtb=True)
- expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('!'), 6) +
+ expected = (U_BOOT_DATA + tools.get_bytes(ord('!'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('!'), 6) +
U_BOOT_DATA)
self.assertEqual(expected, data)
node = dtb.GetNode('/images/kernel')
data = dtb.GetProps(node)["data"].bytes
align_pad = 0x10 - (len(U_BOOT_SPL_DATA) % 0x10)
- expected = (tools.GetBytes(0, 0x20) + U_BOOT_SPL_DATA +
- tools.GetBytes(0, align_pad) + U_BOOT_DATA)
+ expected = (tools.get_bytes(0, 0x20) + U_BOOT_SPL_DATA +
+ tools.get_bytes(0, align_pad) + U_BOOT_DATA)
self.assertEqual(expected, data)
node = dtb.GetNode('/images/fdt-1')
data = dtb.GetProps(node)["data"].bytes
- expected = (U_BOOT_SPL_DTB_DATA + tools.GetBytes(0, 20) +
- tools.ToBytes(TEXT_DATA) + tools.GetBytes(0, 30) +
+ expected = (U_BOOT_SPL_DTB_DATA + tools.get_bytes(0, 20) +
+ tools.to_bytes(TEXT_DATA) + tools.get_bytes(0, 30) +
U_BOOT_DTB_DATA)
self.assertEqual(expected, data)
def testSkipAtStartPad(self):
"""Test handling of skip-at-start section with padded entry"""
data = self._DoReadFile('178_skip_at_start_pad.dts')
- before = tools.GetBytes(0, 8)
- after = tools.GetBytes(0, 4)
+ before = tools.get_bytes(0, 8)
+ after = tools.get_bytes(0, 4)
all = before + U_BOOT_DATA + after
self.assertEqual(all, data)
def testSkipAtStartSectionPad(self):
"""Test handling of skip-at-start section with padding"""
data = self._DoReadFile('179_skip_at_start_section_pad.dts')
- before = tools.GetBytes(0, 8)
- after = tools.GetBytes(0, 4)
+ before = tools.get_bytes(0, 8)
+ after = tools.get_bytes(0, 4)
all = before + U_BOOT_DATA + after
self.assertEqual(all, data)
def testSectionPad(self):
"""Testing padding with sections"""
data = self._DoReadFile('180_section_pad.dts')
- expected = (tools.GetBytes(ord('&'), 3) +
- tools.GetBytes(ord('!'), 5) +
+ expected = (tools.get_bytes(ord('&'), 3) +
+ tools.get_bytes(ord('!'), 5) +
U_BOOT_DATA +
- tools.GetBytes(ord('!'), 1) +
- tools.GetBytes(ord('&'), 2))
+ tools.get_bytes(ord('!'), 1) +
+ tools.get_bytes(ord('&'), 2))
self.assertEqual(expected, data)
def testSectionAlign(self):
"""Testing alignment with sections"""
data = self._DoReadFileDtb('181_section_align.dts', map=True)[0]
expected = (b'\0' + # fill section
- tools.GetBytes(ord('&'), 1) + # padding to section align
+ tools.get_bytes(ord('&'), 1) + # padding to section align
b'\0' + # fill section
- tools.GetBytes(ord('!'), 3) + # padding to u-boot align
+ tools.get_bytes(ord('!'), 3) + # padding to u-boot align
U_BOOT_DATA +
- tools.GetBytes(ord('!'), 4) + # padding to u-boot size
- tools.GetBytes(ord('!'), 4)) # padding to section size
+ tools.get_bytes(ord('!'), 4) + # padding to u-boot size
+ tools.get_bytes(ord('!'), 4)) # padding to section size
self.assertEqual(expected, data)
def testCompressImage(self):
'188_image_entryarg.dts',use_real_dtb=True, update_dtb=True,
entry_args=entry_args)
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
orig_image = control.images['image']
# This should not generate an error about the missing 'cros-ec-rw-path'
def testReadImageSkip(self):
"""Test reading an image and accessing its FDT map"""
data = self.data = self._DoReadFileRealDtb('191_read_image_skip.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
orig_image = control.images['image']
image = Image.FromFile(image_fname)
self.assertEqual(orig_image.GetEntries().keys(),
# ELF file with a '__bss_size' symbol
self._SetupTplElf()
data = self._DoReadFile('193_tpl_bss_pad.dts')
- self.assertEqual(U_BOOT_TPL_DATA + tools.GetBytes(0, 10) + U_BOOT_DATA,
+ self.assertEqual(U_BOOT_TPL_DATA + tools.get_bytes(0, 10) + U_BOOT_DATA,
data)
def testTplBssPadMissing(self):
"""Test a collection"""
data = self._DoReadFile('198_collection.dts')
self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA +
- tools.GetBytes(0xff, 2) + U_BOOT_NODTB_DATA +
- tools.GetBytes(0xfe, 3) + U_BOOT_DTB_DATA,
+ tools.get_bytes(0xff, 2) + U_BOOT_NODTB_DATA +
+ tools.get_bytes(0xfe, 3) + U_BOOT_DTB_DATA,
data)
def testCollectionSection(self):
# missing.
data = self._DoReadFile('199_collection_section.dts')
section = U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA
- self.assertEqual(section + U_BOOT_DATA + tools.GetBytes(0xff, 2) +
- section + tools.GetBytes(0xfe, 3) + U_BOOT_DATA,
+ self.assertEqual(section + U_BOOT_DATA + tools.get_bytes(0xff, 2) +
+ section + tools.get_bytes(0xfe, 3) + U_BOOT_DATA,
data)
def testAlignDefault(self):
"""Test that default alignment works on sections"""
data = self._DoReadFile('200_align_default.dts')
- expected = (U_BOOT_DATA + tools.GetBytes(0, 8 - len(U_BOOT_DATA)) +
+ expected = (U_BOOT_DATA + tools.get_bytes(0, 8 - len(U_BOOT_DATA)) +
U_BOOT_DATA)
# Special alignment for section
- expected += tools.GetBytes(0, 32 - len(expected))
+ expected += tools.get_bytes(0, 32 - len(expected))
# No alignment within the nested section
expected += U_BOOT_DATA + U_BOOT_NODTB_DATA;
# Now the final piece, which should be default-aligned
- expected += tools.GetBytes(0, 88 - len(expected)) + U_BOOT_NODTB_DATA
+ expected += tools.get_bytes(0, 88 - len(expected)) + U_BOOT_NODTB_DATA
self.assertEqual(expected, data)
def testPackOpenSBI(self):
def testSectionsSingleThread(self):
"""Test sections without multithreading"""
data = self._DoReadFileDtb('055_sections.dts', threads=0)[0]
- expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('a'), 12) +
- U_BOOT_DATA + tools.GetBytes(ord('&'), 4))
+ expected = (U_BOOT_DATA + tools.get_bytes(ord('!'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('a'), 12) +
+ U_BOOT_DATA + tools.get_bytes(ord('&'), 4))
self.assertEqual(expected, data)
def testThreadTimeout(self):
# definition in the correct place
syms = elf.GetSymbolFileOffset(infile,
['dtb_embed_begin', 'dtb_embed_end'])
- data = tools.ReadFile(outfile)
+ data = tools.read_file(outfile)
dtb_data = data[syms['dtb_embed_begin'].offset:
syms['dtb_embed_end'].offset]
# Set up a version file to make sure that works
version = 'v2025.01-rc2'
- tools.WriteFile(os.path.join(self._indir, 'version'), version,
+ tools.write_file(os.path.join(self._indir, 'version'), version,
binary=False)
self.assertEqual(version, state.GetVersion(self._indir))
# Check that we can read it and it can be scanning, meaning it does
# not have a 16-byte fdtmap header
- data = tools.ReadFile(dtb)
+ data = tools.read_file(dtb)
dtb = fdt.Fdt.FromData(data)
dtb.Scan()
fname = os.path.join(tmpdir, 'fdt.dtb')
self._DoBinman('extract', '-i', updated_fname, '-F', 'dummy',
'-f', fname, 'u-boot')
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
finally:
fdtmap_data = data[fdtmap.image_pos:fdtmap.image_pos + fdtmap.size]
magic = fdtmap_data[:8]
self.assertEqual(b'_FDTMAP_', magic)
- self.assertEqual(tools.GetBytes(0, 8), fdtmap_data[8:16])
+ self.assertEqual(tools.get_bytes(0, 8), fdtmap_data[8:16])
fdt_data = fdtmap_data[16:]
dtb = fdt.Fdt.FromData(fdt_data)
def testFipExtractOneEntry(self):
"""Test extracting a single entry fron an FIP"""
self._DoReadFileRealDtb('207_fip_ls.dts')
- image_fname = tools.GetOutputFilename('image.bin')
+ image_fname = tools.get_output_filename('image.bin')
fname = os.path.join(self._indir, 'output.extact')
control.ExtractEntries(image_fname, fname, None, ['atf-fip/u-boot'])
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def testFipReplace(self):
"""Test replacing a single file in a FIP"""
- expected = U_BOOT_DATA + tools.GetBytes(0x78, 50)
+ expected = U_BOOT_DATA + tools.get_bytes(0x78, 50)
data = self._DoReadFileRealDtb('208_fip_replace.dts')
- updated_fname = tools.GetOutputFilename('image-updated.bin')
- tools.WriteFile(updated_fname, data)
+ updated_fname = tools.get_output_filename('image-updated.bin')
+ tools.write_file(updated_fname, data)
entry_name = 'atf-fip/u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=True)
actual = control.ReadEntry(updated_fname, entry_name)
self.assertEqual(expected, actual)
- new_data = tools.ReadFile(updated_fname)
+ new_data = tools.read_file(updated_fname)
hdr, fents = fip_util.decode_fip(new_data)
self.assertEqual(2, len(fents))
self.assertEqual(True, fent.valid)
rest = data[0x60 + len(ATF_BL31_DATA):0x100]
- self.assertEqual(tools.GetBytes(0xff, len(rest)), rest)
+ self.assertEqual(tools.get_bytes(0xff, len(rest)), rest)
def testFipBadAlign(self):
"""Test that an invalid alignment value in a FIP is detected"""
def testFetchBintools(self):
def fail_download(url):
- """Take the tools.Download() function by raising an exception"""
+ """Take the tools.download() function by raising an exception"""
raise urllib.error.URLError('my error')
args = ['tool']
self.assertIn('Please specify bintools to fetch', str(e.exception))
args = ['tool', '--fetch', '_testing']
- with unittest.mock.patch.object(tools, 'Download',
+ with unittest.mock.patch.object(tools, 'download',
side_effect=fail_download):
with test_util.capture_sys_output() as (stdout, _):
self._DoBinman(*args)
Raises:
ValueError if something goes wrong
"""
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
size = len(data)
# First look for an image header
dtb_size = probe_dtb.GetFdtObj().totalsize()
fdtmap_data = data[pos:pos + dtb_size + fdtmap.FDTMAP_HDR_LEN]
fdt_data = fdtmap_data[fdtmap.FDTMAP_HDR_LEN:]
- out_fname = tools.GetOutputFilename('fdtmap.in.dtb')
- tools.WriteFile(out_fname, fdt_data)
+ out_fname = tools.get_output_filename('fdtmap.in.dtb')
+ tools.write_file(out_fname, fdt_data)
dtb = fdt.Fdt(out_fname)
dtb.Scan()
def BuildImage(self):
"""Write the image to a file"""
- fname = tools.GetOutputFilename(self._filename)
+ fname = tools.get_output_filename(self._filename)
tout.Info("Writing image to '%s'" % fname)
with open(fname, 'wb') as fd:
data = self.GetPaddedData()
Filename of map file written
"""
filename = '%s.map' % self.image_name
- fname = tools.GetOutputFilename(filename)
+ fname = tools.get_output_filename(filename)
with open(fname, 'w') as fd:
print('%8s %8s %8s %s' % ('ImagePos', 'Offset', 'Size', 'Name'),
file=fd)
data = GetFdtForEtype(etype).GetContents()
else:
fname = output_fdt_info[etype][1]
- pathname = tools.GetInputFilename(fname)
- data = tools.ReadFile(pathname)
+ pathname = tools.get_input_filename(fname)
+ data = tools.read_file(pathname)
return pathname, data
def UpdateFdtContents(etype, data):
"""
dtb, fname = output_fdt_info[etype]
dtb_fname = dtb.GetFilename()
- tools.WriteFile(dtb_fname, data)
+ tools.write_file(dtb_fname, data)
dtb = fdt.FdtScan(dtb_fname)
output_fdt_info[etype] = [dtb, fname]
else:
fdt_set = {}
for etype, fname in DTB_TYPE_FNAME.items():
- infile = tools.GetInputFilename(fname, allow_missing=True)
+ infile = tools.get_input_filename(fname, allow_missing=True)
if infile and os.path.exists(infile):
fname_dtb = fdt_util.EnsureCompiled(infile)
- out_fname = tools.GetOutputFilename('%s.out' %
+ out_fname = tools.get_output_filename('%s.out' %
os.path.split(fname)[1])
- tools.WriteFile(out_fname, tools.ReadFile(fname_dtb))
+ tools.write_file(out_fname, tools.read_file(fname_dtb))
other_dtb = fdt.FdtScan(out_fname)
output_fdt_info[etype] = [other_dtb, out_fname]
tout.Info(" Found device tree type 'fdtmap' '%s'" % image.fdtmap_dtb.name)
for etype, value in image.GetFdts().items():
entry, fname = value
- out_fname = tools.GetOutputFilename('%s.dtb' % entry.etype)
+ out_fname = tools.get_output_filename('%s.dtb' % entry.etype)
tout.Info(" Found device tree type '%s' at '%s' path '%s'" %
(etype, out_fname, entry.GetPath()))
entry._filename = entry.GetDefaultFilename()
data = entry.ReadData()
- tools.WriteFile(out_fname, data)
+ tools.write_file(out_fname, data)
dtb = fdt.Fdt(out_fname)
dtb.Scan()
image_node = dtb.GetNode('/binman')
"""
version_fname = os.path.join(path, 'version')
if os.path.exists(version_fname):
- version = tools.ReadFile(version_fname, binary=False)
+ version = tools.read_file(version_fname, binary=False)
else:
version = '(unreleased)'
return version
global builder
if options.full_help:
- tools.PrintFullHelp(
+ tools.print_full_help(
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README')
)
return 0
if arg.startswith('O='):
out_dir = arg[2:]
fname = os.path.join(cwd or '', out_dir, 'u-boot')
- tools.WriteFile(fname, b'U-Boot')
+ tools.write_file(fname, b'U-Boot')
if type(commit) is not str:
stderr = self._error.get((brd.target, commit.sequence))
if stderr:
def testPrepareOutputSpace(self):
def _Touch(fname):
- tools.WriteFile(os.path.join(base_dir, fname), b'')
+ tools.write_file(os.path.join(base_dir, fname), b'')
base_dir = tempfile.mkdtemp()
# We'll use MakeArgs() to provide this
pass
elif full_path:
- env[b'CROSS_COMPILE'] = tools.ToBytes(
+ env[b'CROSS_COMPILE'] = tools.to_bytes(
wrapper + os.path.join(self.path, self.cross))
else:
- env[b'CROSS_COMPILE'] = tools.ToBytes(wrapper + self.cross)
- env[b'PATH'] = tools.ToBytes(self.path) + b':' + env[b'PATH']
+ env[b'CROSS_COMPILE'] = tools.to_bytes(wrapper + self.cross)
+ env[b'PATH'] = tools.to_bytes(self.path) + b':' + env[b'PATH']
env[b'LC_ALL'] = b'C'
url = '%s/%s/%s/' % (base, arch, version)
print('Checking: %s' % url)
response = urllib.request.urlopen(url)
- html = tools.ToString(response.read())
+ html = tools.to_string(response.read())
parser = MyHTMLParser(fetch_arch)
parser.feed(html)
if fetch_arch == 'list':
os.mkdir(dest)
# Download the tar file for this toolchain and unpack it
- tarfile, tmpdir = tools.Download(url, '.buildman')
+ tarfile, tmpdir = tools.download(url, '.buildman')
if not tarfile:
return 1
print(col.Color(col.GREEN, 'Unpacking to: %s' % dest), end=' ')
prop_name: Name of property
"""
self.props[prop_name] = Prop(self, None, prop_name,
- tools.GetBytes(0, 4))
+ tools.get_bytes(0, 4))
def AddEmptyProp(self, prop_name, len):
"""Add a property with a fixed data size, for filling in later
prop_name: Name of property
len: Length of data in property
"""
- value = tools.GetBytes(0, len)
+ value = tools.get_bytes(0, len)
self.props[prop_name] = Prop(self, None, prop_name, value)
def _CheckProp(self, prop_name):
dts_input = os.path.join(tmpdir, 'source.dts')
dtb_output = os.path.join(tmpdir, 'source.dtb')
else:
- dts_input = tools.GetOutputFilename('source.dts')
- dtb_output = tools.GetOutputFilename('source.dtb')
+ dts_input = tools.get_output_filename('source.dts')
+ dtb_output = tools.get_output_filename('source.dtb')
search_paths = [os.path.join(os.getcwd(), 'include')]
root, _ = os.path.splitext(fname)
- cc, args = tools.GetTargetCompileTool('cc')
+ cc, args = tools.get_target_compile_tool('cc')
args += ['-E', '-P', '-x', 'assembler-with-cpp', '-D__ASSEMBLY__']
args += ['-Ulinux']
for path in search_paths:
search_list = []
for path in search_paths:
search_list.extend(['-i', path])
- dtc, args = tools.GetTargetCompileTool('dtc')
+ dtc, args = tools.get_target_compile_tool('dtc')
args += ['-I', 'dts', '-o', dtb_output, '-O', 'dtb',
'-W', 'no-unit_address_vs_reg']
args.extend(search_list)
"""Tests for dtoc"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
cls.maxDiff = None
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
@staticmethod
def _write_python_string(fname, data):
def test_empty_file(self):
"""Test output from a device tree file with no nodes"""
dtb_file = get_dtb_file('dtoc_test_empty.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
# Run this one without saved_scan to complete test coverage
dtb_platdata.run_steps(['struct'], dtb_file, False, output, [], None,
def test_simple(self):
"""Test output from some simple nodes with various types of data"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
# Try the 'all' command
self.run_test(['all'], dtb_file, output)
- data = tools.ReadFile(output, binary=False)
+ data = tools.read_file(output, binary=False)
self._check_strings(
self.decl_text + self.platdata_text + self.struct_text, data)
def test_driver_alias(self):
"""Test output from a device tree file with a driver alias"""
dtb_file = get_dtb_file('dtoc_test_driver_alias.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_invalid_driver(self):
"""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')
+ output = tools.get_output_filename('output')
with test_util.capture_sys_output() as _:
dtb_platdata.run_steps(
['struct'], dtb_file, False, output, [], None, False,
def test_phandle(self):
"""Test output from a node containing a phandle reference"""
dtb_file = get_dtb_file('dtoc_test_phandle.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_phandle_single(self):
"""Test output from a node containing a phandle reference"""
dtb_file = get_dtb_file('dtoc_test_phandle_single.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_phandle_reorder(self):
"""Test that phandle targets are generated before their references"""
dtb_file = get_dtb_file('dtoc_test_phandle_reorder.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['platdata'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_phandle_cd_gpio(self):
"""Test that phandle targets are generated when unsing cd-gpios"""
dtb_file = get_dtb_file('dtoc_test_phandle_cd_gpios.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
dtb_platdata.run_steps(
['platdata'], dtb_file, False, output, [], None, False,
warning_disabled=True, scan=copy_scan())
"""Test a node containing an invalid phandle fails"""
dtb_file = get_dtb_file('dtoc_test_phandle_bad.dts',
capture_stderr=True)
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Cannot parse 'clocks' in node 'phandle-source'",
"""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')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'phandle-target' has no cells property",
def test_addresses64(self):
"""Test output from a node with a 'reg' property with na=2, ns=2"""
dtb_file = get_dtb_file('dtoc_test_addr64.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_addresses32(self):
"""Test output from a node with a 'reg' property with na=1, ns=1"""
dtb_file = get_dtb_file('dtoc_test_addr32.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_addresses64_32(self):
"""Test output from a node with a 'reg' property with na=2, ns=1"""
dtb_file = get_dtb_file('dtoc_test_addr64_32.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_addresses32_64(self):
"""Test output from a node with a 'reg' property with na=1, ns=2"""
dtb_file = get_dtb_file('dtoc_test_addr32_64.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
"""Test that a reg property with an invalid type generates an error"""
# 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')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Node 'spl-test' reg property is not an int",
"""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')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn(
def test_add_prop(self):
"""Test that a subequent node can add a new property to a struct"""
dtb_file = get_dtb_file('dtoc_test_add_prop.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
with open(output) as infile:
data = infile.read()
def test_multi_to_file(self):
"""Test output of multiple pieces to a single file"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['all'], dtb_file, output)
- data = tools.ReadFile(output, binary=False)
+ data = tools.read_file(output, binary=False)
self._check_strings(
self.decl_text + self.platdata_text + self.struct_text, data)
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')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['invalid-cmd'], dtb_file, output)
self.assertIn(
def check_output_dirs(self, instantiate):
# Remove the directory so that files from other tests are not there
- tools._RemoveOutputDir()
- tools.PrepareOutputDir(None)
+ tools._remove_output_dir()
+ tools.prepare_output_dir(None)
# This should create the .dts and .dtb in the output directory
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- outdir = tools.GetOutputDir()
+ outdir = tools.get_output_dir()
fnames = glob.glob(outdir + '/*')
self.assertEqual(2, len(fnames))
Scanner: scanner to use
"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
# Take a copy before messing with it
scan = copy_scan()
def test_alias_read(self):
"""Test obtaining aliases"""
dtb_file = get_dtb_file('dtoc_test_inst.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
plat = self.run_test(['struct'], dtb_file, output)
scan = plat._scan
def test_alias_read_bad(self):
"""Test invalid alias property name"""
dtb_file = get_dtb_file('dtoc_test_alias_bad.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
plat = self.run_test(['struct'], dtb_file, output)
self.assertIn("Cannot decode alias 'i2c4-'", str(exc.exception))
# node (/does/not/exist)
dtb_file = get_dtb_file('dtoc_test_alias_bad_path.dts', True)
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
plat = self.run_test(['struct'], dtb_file, output)
self.assertIn("Alias 'i2c4' path '/does/not/exist' not found",
def test_alias_read_bad_uclass(self):
"""Test alias for a uclass that doesn't exist"""
dtb_file = get_dtb_file('dtoc_test_alias_bad_uc.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with test_util.capture_sys_output() as (stdout, _):
plat = self.run_test(['struct'], dtb_file, output)
self.assertEqual("Could not find uclass for alias 'other1'",
def test_sequence(self):
"""Test assignment of sequence numnbers"""
dtb_file = get_dtb_file('dtoc_test_inst.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
plat = self.run_test(['struct'], dtb_file, output)
scan = plat._scan
def test_process_root(self):
"""Test assignment of sequence numnbers"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
# Take a copy before messing with it
scan = copy_scan()
def test_simple_inst(self):
"""Test output from some simple nodes with instantiate enabled"""
dtb_file = get_dtb_file('dtoc_test_inst.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['decl'], dtb_file, output, True)
with open(output) as infile:
def test_inst_no_hdr(self):
"""Test dealing with a struct tsssshat has no header"""
dtb_file = get_dtb_file('dtoc_test_inst.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
# Run it once to set everything up
plat = self.run_test(['decl'], dtb_file, output, True)
def test_missing_props(self):
"""Test detection of a parent node with no properties"""
dtb_file = get_dtb_file('dtoc_test_noprops.dts', capture_stderr=True)
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['struct'], dtb_file, output)
self.assertIn("Parent node '/i2c@0' has no properties - do you need",
def test_single_reg(self):
"""Test detection of a parent node with no properties"""
dtb_file = get_dtb_file('dtoc_test_single_reg.dts')
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
self.run_test(['struct'], dtb_file, output)
def test_missing_parent(self):
"""Test detection of a parent node with no properties"""
dtb_file = get_dtb_file('dtoc_test_noparent.dts', capture_stderr=True)
- output = tools.GetOutputFilename('output')
+ output = tools.get_output_filename('output')
with self.assertRaises(ValueError) as exc:
self.run_test(['device'], dtb_file, output, instantiate=True)
self.assertIn("Node '/i2c@0/spl-test/pmic@9' requires parent node "
"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
"""Tests the GetEmpty() function for the various supported types"""
self.assertEqual(True, fdt.Prop.GetEmpty(Type.BOOL))
self.assertEqual(chr(0), fdt.Prop.GetEmpty(Type.BYTE))
- self.assertEqual(tools.GetBytes(0, 4), fdt.Prop.GetEmpty(Type.INT))
+ self.assertEqual(tools.get_bytes(0, 4), fdt.Prop.GetEmpty(Type.INT))
self.assertEqual('', fdt.Prop.GetEmpty(Type.STRING))
def testGetOffset(self):
self.node.AddString('string', val)
self.dtb.Sync(auto_resize=True)
data = self.fdt.getprop(self.node.Offset(), 'string')
- self.assertEqual(tools.ToBytes(val) + b'\0', data)
+ self.assertEqual(tools.to_bytes(val) + b'\0', data)
self.fdt.pack()
self.node.SetString('string', val + 'x')
self.node.SetString('string', val[:-1])
prop = self.node.props['string']
- prop.SetData(tools.ToBytes(val))
+ prop.SetData(tools.to_bytes(val))
self.dtb.Sync(auto_resize=False)
data = self.fdt.getprop(self.node.Offset(), 'string')
- self.assertEqual(tools.ToBytes(val), data)
+ self.assertEqual(tools.to_bytes(val), data)
self.node.AddEmptyProp('empty', 5)
self.dtb.Sync(auto_resize=True)
prop = self.node.props['empty']
- prop.SetData(tools.ToBytes(val))
+ prop.SetData(tools.to_bytes(val))
self.dtb.Sync(auto_resize=False)
data = self.fdt.getprop(self.node.Offset(), 'empty')
- self.assertEqual(tools.ToBytes(val), data)
+ self.assertEqual(tools.to_bytes(val), data)
self.node.SetData('empty', b'123')
self.assertEqual(b'123', prop.bytes)
# Trying adding a lot of data at once
- self.node.AddData('data', tools.GetBytes(65, 20000))
+ self.node.AddData('data', tools.get_bytes(65, 20000))
self.dtb.Sync(auto_resize=True)
def testFromData(self):
def testGetFilename(self):
"""Test the dtb filename can be provided"""
- self.assertEqual(tools.GetOutputFilename('source.dtb'),
+ self.assertEqual(tools.get_output_filename('source.dtb'),
self.dtb.GetFilename())
"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
"""Tests for src_scan"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def test_simple(self):
"""Simple test of scanning drivers"""
pathname = os.path.join(indir, fname)
dirname = os.path.dirname(pathname)
os.makedirs(dirname, exist_ok=True)
- tools.WriteFile(pathname, '', binary=False)
+ tools.write_file(pathname, '', binary=False)
fname_list.append(pathname)
try:
def test_scan(self):
"""Test scanning of a driver"""
fname = os.path.join(OUR_PATH, '..', '..', 'drivers/i2c/tegra_i2c.c')
- buff = tools.ReadFile(fname, False)
+ buff = tools.read_file(fname, False)
scan = src_scan.Scanner(None, None)
scan._parse_driver(fname, buff)
self.assertIn('i2c_tegra', scan._drivers)
def test_struct_scan_errors(self):
"""Test scanning a header file with an invalid unicode file"""
- output = tools.GetOutputFilename('output.h')
- tools.WriteFile(output, b'struct this is a test \x81 of bad unicode')
+ 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, _):
text (str): Text to put into the file
"""
path = os.path.join(self.gitdir, fname)
- tools.WriteFile(path, text, binary=False)
+ tools.write_file(path, text, binary=False)
index = self.repo.index
index.add(fname)
author = pygit2.Signature('Test user', 'test@email.com')
fd.close()
elif args.full_help:
- tools.PrintFullHelp(
+ tools.print_full_help(
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README')
)
# Path to the Chrome OS chroot, if we know it
chroot_path = None
-# Search paths to use for Filename(), used to find files
+# Search paths to use for filename(), used to find files
search_paths = []
tool_search_paths = []
# List of paths to use when looking for an input file
indir = []
-def PrepareOutputDir(dirname, preserve=False):
+def prepare_output_dir(dirname, preserve=False):
"""Select an output directory, ensuring it exists.
This either creates a temporary directory or checks that the one supplied
outdir = tempfile.mkdtemp(prefix='binman.')
tout.Debug("Using temporary directory '%s'" % outdir)
-def _RemoveOutputDir():
+def _remove_output_dir():
global outdir
shutil.rmtree(outdir)
tout.Debug("Deleted temporary directory '%s'" % outdir)
outdir = None
-def FinaliseOutputDir():
+def finalise_output_dir():
global outdir, preserve_outdir
"""Tidy up: delete output directory if temporary and not preserved."""
if outdir and not preserve_outdir:
- _RemoveOutputDir()
+ _remove_output_dir()
outdir = None
-def GetOutputFilename(fname):
+def get_output_filename(fname):
"""Return a filename within the output directory.
Args:
"""
return os.path.join(outdir, fname)
-def GetOutputDir():
+def get_output_dir():
"""Return the current output directory
Returns:
"""
return outdir
-def _FinaliseForTest():
+def _finalise_for_test():
"""Remove the output directory (for use by tests)"""
global outdir
if outdir:
- _RemoveOutputDir()
+ _remove_output_dir()
outdir = None
-def SetInputDirs(dirname):
+def set_input_dirs(dirname):
"""Add a list of input directories, where input files are kept.
Args:
indir = dirname
tout.Debug("Using input directories %s" % indir)
-def GetInputFilename(fname, allow_missing=False):
+def get_input_filename(fname, allow_missing=False):
"""Return a filename for use as input.
Args:
raise ValueError("Filename '%s' not found in input path (%s) (cwd='%s')" %
(fname, ','.join(indir), os.getcwd()))
-def GetInputFilenameGlob(pattern):
+def get_input_filename_glob(pattern):
"""Return a list of filenames for use as input.
Args:
files += glob.glob(pathname)
return sorted(files)
-def Align(pos, align):
+def align(pos, align):
if align:
mask = align - 1
pos = (pos + mask) & ~mask
return pos
-def NotPowerOfTwo(num):
+def not_power_of_two(num):
return num and (num & (num - 1))
-def SetToolPaths(toolpaths):
+def set_tool_paths(toolpaths):
"""Set the path to search for tools
Args:
- toolpaths: List of paths to search for tools executed by Run()
+ toolpaths: List of paths to search for tools executed by run()
"""
global tool_search_paths
tool_search_paths = toolpaths
-def PathHasFile(path_spec, fname):
+def path_has_file(path_spec, fname):
"""Check if a given filename is in the PATH
Args:
return True
return False
-def GetHostCompileTool(name):
+def get_host_compile_tool(name):
"""Get the host-specific version for a compile tool
This checks the environment variables that specify which version of
return host_name, extra_args
return name, []
-def GetTargetCompileTool(name, cross_compile=None):
+def get_target_compile_tool(name, cross_compile=None):
"""Get the target-specific version for a compile tool
This first checks the environment variables that specify which
target_name = cross_compile + name
elif name == 'ld':
try:
- if Run(cross_compile + 'ld.bfd', '-v'):
+ if run(cross_compile + 'ld.bfd', '-v'):
target_name = cross_compile + 'ld.bfd'
except:
target_name = cross_compile + 'ld'
raise_on_error = kwargs.get('raise_on_error', True)
env = get_env_with_path()
if for_target:
- name, extra_args = GetTargetCompileTool(name)
+ name, extra_args = get_target_compile_tool(name)
args = tuple(extra_args) + args
elif for_host:
- name, extra_args = GetHostCompileTool(name)
+ name, extra_args = get_host_compile_tool(name)
args = tuple(extra_args) + args
name = os.path.expanduser(name) # Expand paths containing ~
all_args = (name,) + args
result.stderr or result.stdout))
return result
except ValueError:
- if env and not PathHasFile(env['PATH'], name):
+ if env and not path_has_file(env['PATH'], name):
msg = "Please install tool '%s'" % name
package = packages.get(name)
if package:
def tool_find(name):
"""Search the current path for a tool
- This uses both PATH and any value from SetToolPaths() to search for a tool
+ This uses both PATH and any value from set_tool_paths() to search for a tool
Args:
name (str): Name of tool to locate
if os.path.isfile(fname) and os.access(fname, os.X_OK):
return fname
-def Run(name, *args, **kwargs):
+def run(name, *args, **kwargs):
"""Run a tool with some arguments
This runs a 'tool', which is a program used by binman to process files and
if result is not None:
return result.stdout
-def Filename(fname):
+def filename(fname):
"""Resolve a file path to an absolute path.
If fname starts with ##/ and chroot is available, ##/ gets replaced with
# If not found, just return the standard, unchanged path
return fname
-def ReadFile(fname, binary=True):
+def read_file(fname, binary=True):
"""Read and return the contents of a file.
Args:
Returns:
data read from file, as a string.
"""
- with open(Filename(fname), binary and 'rb' or 'r') as fd:
+ with open(filename(fname), binary and 'rb' or 'r') as fd:
data = fd.read()
#self._out.Info("Read file '%s' size %d (%#0x)" %
#(fname, len(data), len(data)))
return data
-def WriteFile(fname, data, binary=True):
+def write_file(fname, data, binary=True):
"""Write data into a file.
Args:
"""
#self._out.Info("Write file '%s' size %d (%#0x)" %
#(fname, len(data), len(data)))
- with open(Filename(fname), binary and 'wb' or 'w') as fd:
+ with open(filename(fname), binary and 'wb' or 'w') as fd:
fd.write(data)
-def GetBytes(byte, size):
+def get_bytes(byte, size):
"""Get a string of bytes of a given size
Args:
"""
return bytes([byte]) * size
-def ToBytes(string):
+def to_bytes(string):
"""Convert a str type into a bytes type
Args:
"""
return string.encode('utf-8')
-def ToString(bval):
+def to_string(bval):
"""Convert a bytes type into a str type
Args:
"""
return bval.decode('utf-8')
-def ToHex(val):
+def to_hex(val):
"""Convert an integer value (or None) to a string
Returns:
"""
return 'None' if val is None else '%#x' % val
-def ToHexSize(val):
+def to_hex_size(val):
"""Return the size of an object in hex
Returns:
"""
return 'None' if val is None else '%#x' % len(val)
-def PrintFullHelp(fname):
+def print_full_help(fname):
"""Print the full help message for a tool using an appropriate pager.
Args:
pager = ['more']
command.Run(*pager, fname)
-def Download(url, tmpdir_pattern='.patman'):
+def download(url, tmpdir_pattern='.patman'):
"""Download a file to a temporary directory
Args:
projects / u-boot.git / commitdiff