Convert this file to snake case and update all files which use it.
Signed-off-by: Simon Glass <sjg@chromium.org>
50 files changed:
"""
tmpdir = tempfile.mkdtemp(prefix='binmanf.')
print(f"- clone git repo '{git_repo}' to '{tmpdir}'")
"""
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}'")
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):
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
"""
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
return fname, tmpdir
@classmethod
"""
args = ['sudo', 'apt', 'install', '-y', package]
print('- %s' % ' '.join(args))
"""
args = ['sudo', 'apt', 'install', '-y', package]
print('- %s' % ' '.join(args))
return True
@staticmethod
return True
@staticmethod
Args:
fake_download (function): Function to call instead of
Args:
fake_download (function): Function to call instead of
method (bintool.FETCH_...: Fetch method to use
Returns:
method (bintool.FETCH_...: Fetch method to use
Returns:
"""
btest = Bintool.create('_testing')
col = terminal.Color()
"""
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)
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):
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)
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):
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)
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(_):
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
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'
return fname, dirname
expected = b'this is a test'
self.seq = 0
with unittest.mock.patch.object(bintool, 'DOWNLOAD_DESTDIR', destdir):
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))
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()
self.assertEqual(expected, data)
lines = stdout.getvalue().splitlines()
tmpdir = cmd[2]
self.fname = os.path.join(tmpdir, 'pathname')
if write_file:
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):
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')
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()
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)
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(_):
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):
return fname, dirname
def fake_run(*cmd):
# See Bintool.build_from_git()
tmpdir = cmd[2]
self.fname = os.path.join(tmpdir, 'pathname')
# 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')
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():
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))
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)
self.assertEqual(expected, data)
os.remove(result_fname)
bytes: Compressed data
"""
with tempfile.NamedTemporaryFile(prefix='comp.tmp',
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)
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',
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)
args = ['-cd', inf.name]
return self.run_cmd(*args, binary=True)
bytes: Compressed data
"""
with tempfile.NamedTemporaryFile(prefix='comp.tmp',
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',
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)
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
def decompress(self, indata):
"""Decompress data with lzma_alone
bytes: Decompressed data
"""
with tempfile.NamedTemporaryFile(prefix='decomp.tmp',
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',
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)
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
def fetch(self, method):
"""Fetch handler for lzma_alone
Returns:
String with required padding (at least one 0x00 byte) at the end
"""
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)
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))
FILE_ATTR_TAG_COMPRESSION, ATTR_COMPRESSION_LEN,
self.compress, self.memlen)
elif self.ftype == TYPE_EMPTY:
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:
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))
# 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,
hdr_len += pad_len
# This is the offset of the start of the file's data,
Usage is something like:
cbw = CbfsWriter(size)
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()
...
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()))
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 _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.')
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 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
# 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()
cls.cbfstool = bintool.Bintool.create('cbfstool')
cls.have_cbfstool = cls.cbfstool.is_present()
if cls._indir:
shutil.rmtree(cls._indir)
cls._indir = None
if cls._indir:
shutil.rmtree(cls._indir)
cls._indir = None
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
@classmethod
def _make_input_file(cls, fname, contents):
@classmethod
def _make_input_file(cls, fname, contents):
Full pathname of file created
"""
pathname = os.path.join(cls._indir, fname)
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):
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',
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',
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
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
"""
if not self.have_cbfstool or not self.have_lz4:
return
- expect = tools.ReadFile(cbfstool_fname)
+ expect = tools.read_file(cbfstool_fname)
- 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')
print('diff -y <(xxd -g1 /tmp/expect) <(xxd -g1 /tmp/actual) | colordiff')
self.fail('cbfstool produced a different result')
size = 0xb0
cbw = CbfsWriter(size)
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)
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)
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
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))
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)
if len(entry_paths) != 1:
raise ValueError('Must specify exactly one entry path to write with -f')
entry = image.FindEntryPath(entry_paths[0])
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)
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))
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'" %
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)
# 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)
dtb = fdt.FdtScan(fname)
node = _FindBinmanNode(dtb)
global state
if args.full_help:
global state
if args.full_help:
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README.rst')
)
return 0
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)
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)
if args.cmd == 'ls':
ListEntries(args.image, args.paths)
allow_resize=not args.fix_size, write_map=args.map)
if args.cmd == 'tool':
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:
if args.list:
bintool.Bintool.list_all()
elif args.fetch:
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
return 0
elf_params = None
return 0
elf_params = None
# runtime.
use_expanded = not args.no_expanded
try:
# 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)
state.SetEntryArgs(args.entry_arg)
state.SetThreads(args.threads)
# Write the updated FDTs to our output files
for dtb_item in state.GetAllFdts():
# 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()
if elf_params:
data = state.GetFdtForEtype('u-boot-dtb').GetContents()
# Use this to debug the time take to pack the image
#state.TimingShow()
finally:
# Use this to debug the time take to pack the image
#state.TimingShow()
finally:
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
key: Name of symbol
value: Hex value of symbol
"""
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))
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
"""
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
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
# 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)
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))
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 = 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:]
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)
tout.Info('Written to offset %#x' % syms[start_sym].offset)
"""
def __init__(self, contents_size):
self.contents_size = contents_size
"""
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'
def GetPath(self):
return 'entry_path'
if 'MAKEFLAGS' in os.environ:
del os.environ['MAKEFLAGS']
try:
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
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.')
@classmethod
def setUpClass(cls):
cls._indir = tempfile.mkdtemp(prefix='elf.')
- tools.SetInputDirs(['.'])
+ tools.set_input_dirs(['.'])
BuildElfTestFiles(cls._indir)
@classmethod
BuildElfTestFiles(cls._indir)
@classmethod
section = FakeSection(sym_value=None)
elf_fname = self.ElfTestFile('u_boot_binman_syms')
syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
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):
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)
# 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:
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)
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
load = 0xfef20000
entry = load + 2
offset = elf.GetSymbolFileOffset(fname, ['embed_start', 'embed_end'])
start = offset['embed_start'].offset
end = offset['embed_end'].offset
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)
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 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 = {}
from patman import tout
modules = {}
self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
self.align = fdt_util.GetInt(self._node, 'align')
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:
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')
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')
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:
# 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" % (
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
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' %
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
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' %
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.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 = 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
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
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
# 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))
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' %
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
"""
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):
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():
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
with open(outfname, "wb") as out:
out.truncate(1024)
self.faked = True
class TestEntry(unittest.TestCase):
def setUp(self):
class TestEntry(unittest.TestCase):
def setUp(self):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def GetNode(self):
binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
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)
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()
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()
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:
self.external and self.section.GetAllowMissing())
# Allow the file to be missing
if not self._pathname:
bytes: Data read
"""
state.TimingStart('read')
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)
state.TimingAccum('read')
state.TimingStart('compress')
data = self.CompressData(indata)
pathnames = []
for fname in self._filenames:
fname = self.check_fake_fname(fname)
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:
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()
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):
return data
def ObtainContents(self):
'require-matches')
def ExpandEntries(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:
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.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))
for seq, fdt_fname in enumerate(self._fdts):
node_name = subnode.name[1:].replace('SEQ',
str(seq + 1))
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(
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))
- 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',
fsw.property(pname, val)
# Add data for 'fdt' nodes (but not 'config')
if depth == 1 and in_images:
fsw.property('data',
+ tools.read_file(fname))
else:
if self._fdts is None:
if self._fit_list_prop:
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()
# 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')
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:
}
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)
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))
from binman.entry import Entry
from binman import fmap_util
from patman import tools
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
def _AddEntries(areas, entry):
entries = entry.GetEntries()
tout.Debug("fmap: Add entry '%s' type '%s' (%s subentries)" %
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
if entries and entry.etype != 'cbfs':
# Create an area for the section, which encompasses all entries
# within it
def ObtainContents(self):
gbb = 'gbb.bin'
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)')
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])
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,
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))
- 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)
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))
# Create the IFWI file if needed
if self._convert_fit:
inname = self._pathname
# 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)
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
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)
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()
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
# 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.
"""
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:
self.section.GetAllowMissing())
# Allow the file to be missing
if not self._pathname:
return False
data += entry.GetData()
uniq = self.GetUniqueName()
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:
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)
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 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):
class Entry_section(Entry):
data = bytearray()
# Handle padding before the entry
if entry.pad_before:
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:
# 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)
- 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))
# Handle empty space before the entry
pad = (entry.offset or 0) - self._skip_at_start - len(section_data)
if pad > 0:
# 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
# Add in the actual entry data
section_data += data
if not size:
data = self.GetPaddedData(self.data)
size = len(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 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))
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:
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)])
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):
self.value = value
def ObtainContents(self):
def ReadBlobContents(self):
if self._strip:
uniq = self.GetUniqueName()
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._pathname = out_fname
super().ReadBlobContents()
return True
self.fill_value = fdt_util.GetByte(self._node, 'fill-byte', 0)
def ReadBlobContents(self):
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'
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)
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)
crc = zlib.crc32(data)
buf = struct.pack('<I', crc) + b'\x01' + data
self.SetContents(buf)
super().__init__(section, etype, node)
def ObtainContents(self):
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')
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))
super().__init__(section, etype, node)
def ObtainContents(self):
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')
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
# Write it out to a file
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)
def ProcessFdt(self, fdt):
# Figure out where to put the microcode pointer
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
sym = elf.GetSymbolAddress(fname, '_dt_ucode_base_size')
if sym:
self.target_offset = sym
return None
uniq = self.GetUniqueName()
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,
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:
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)
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):
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.')
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):
@classmethod
def tearDownClass(self):
- tools._FinaliseForTest()
+ tools._finalise_for_test()
def TestFile(self, fname):
return os.path.join(self._binman_dir, 'test', fname)
def TestFile(self, fname):
return os.path.join(self._binman_dir, 'test', fname)
self.flags = flags
self.fip_type = None
self.data = None
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()
if self.valid:
# Look up the friendly name
matches = {val for (key, val) in FIP_TYPES.items()
Usage is something like:
fip = FipWriter(size)
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()
...
data = cbw.get_data()
offset += ENTRY_SIZE # terminating entry
for fent in self._fip_entries:
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
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')
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()):
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')
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)
raise ValueError(
f"Expected file '{readme_fname}' - try using -s to specify the "
'arm-trusted-firmware directory')
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)
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:
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}')
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.')
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
# 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.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')
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"""
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)
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)
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
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_no_readme(self):
"""Test handling of a missing readme.rst"""
def test_invalid_readme(self):
"""Test that an invalid readme.rst is detected"""
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))
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
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 = [
# 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
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
# This is taken from tbbr_config.c in ARM Trusted Firmware
FIP_TYPE_LIST = [
# ToC Entry UUIDs
args = self.args.copy()
args.remove('-D')
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)
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()
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"
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')
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')
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')
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)
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):
@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')
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
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',
# 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()
# Intel flash descriptor file
cls._SetupDescriptor()
if self.preserve_outdirs:
print('Preserving output dir: %s' % tools.outdir)
else:
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
def setUp(self):
# Enable this to turn on debugging output
Temporary directory to use
New image filename
"""
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')
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
self._CleanupOutputDir()
return tmpdir, updated_fname
use_expanded=use_expanded, extra_indirs=extra_indirs,
threads=threads)
self.assertEqual(0, retcode)
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']
# 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:
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:
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',
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'):
@classmethod
def _SetupTplElf(cls, src_fname='bss_data'):
Filename of ELF file to use as TPL
"""
TestFunctional._MakeInputFile('tpl/u-boot-tpl',
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):
@classmethod
def _SetupDescriptor(cls):
image = control.images['image1']
self.assertEqual(len(U_BOOT_DATA), image.size)
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()
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)
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.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"""
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(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
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(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
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(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
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(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)
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')
"""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):
U_BOOT_DATA, data)
def testImageName(self):
retcode = self._DoTestFile('022_image_name.dts')
self.assertEqual(0, retcode)
image = control.images['image1']
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']
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):
self.assertTrue(os.path.exists(fname))
def testBlobFilename(self):
"""Test that entries can be sorted"""
self._SetupSplElf()
data = self._DoReadFile('024_sorted.dts')
"""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"""
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')
"""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 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')
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)])
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
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)
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',
# 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()
with self.assertRaises(ValueError) as e:
self._RunPackUbootSingleMicrocode()
finally:
# Put the original file back
TestFunctional._MakeInputFile('u-boot',
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 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',
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
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:]
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"""
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')
# 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):
data)
def testSplBssPadMissing(self):
u_boot_offset + len(U_BOOT_DATA),
0x10 + u_boot_offset, 0x04)
expected = (sym_values + base_data[20:] +
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)
base_data[20:])
self.assertEqual(expected, data)
def testSections(self):
"""Basic test of sections"""
data = self._DoReadFile('055_sections.dts')
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):
self.assertEqual(expected, data)
def testMap(self):
}
data, _, _, _ = self._DoReadFileDtb('066_text.dts',
entry_args=entry_args)
}
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)
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:])
"""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)
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')
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):
self.assertEqual(expected, data)
def testFillNoSize(self):
data, _, _, _ = self._DoReadFileDtb('071_gbb.dts', entry_args=entry_args)
# Since futility
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):
self.assertEqual(expected, data)
def testGbbTooSmall(self):
if self._hash_data:
infile = pipe_list[0][11]
m = hashlib.sha256()
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:
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')
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"""
def testTextMissing(self):
"""Test for a text entry type where there is no text"""
else:
self.assertNotIn(expected, stdout.getvalue())
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):
self._CleanupOutputDir()
def testUpdateFdtAll(self):
'tpl/u-boot-tpl.dtb.out']:
dtb = fdt.Fdt.FromData(data[start:])
size = dtb._fdt_obj.totalsize()
'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:
name = os.path.split(fname)[0]
if name:
"""Test an expanding entry"""
data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts',
map=True)
"""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
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)
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):
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:])
"""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:])
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')
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:])
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)
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.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))
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
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,
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)
def testCbfsRaw(self):
"""Test base handling of a Coreboot Filesystem (CBFS)
Args:
data: Conents of output file
"""
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
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)
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):
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)
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)
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')
"""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(),
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')
"""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:])
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')
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))
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')
"""
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:]]
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')
"""
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):
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')
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')
with self.assertRaises(ValueError) as e:
control.ReadEntry(fname, 'name')
'-f', fname)
finally:
shutil.rmtree(tmpdir)
'-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')
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'])
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):
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)
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.remove(path)
if expect_data:
self.assertEqual(expect_data, data)
os.rmdir(path)
self._DoReadFileRealDtb('130_list_fdtmap.dts')
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)
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)
_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.
_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')
"""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*'])
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')
"""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',
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')
"""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',
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
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)
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)
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)
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
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)
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')
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)
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')
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)
entry_name = 'section/cbfs/u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=True)
"""
data = self._DoReadFileRealDtb('143_replace_all.dts')
"""
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')
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')
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')
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)
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)
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)
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.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')
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()
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)
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')
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')
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',
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')
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',
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)
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)
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)
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.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')
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
# 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 +
# 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
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)
"""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)
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)
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
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)
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')
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)
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')
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)
all = before + U_BOOT_DATA + after
self.assertEqual(all, data)
def testSectionPad(self):
"""Testing padding with sections"""
data = self._DoReadFile('180_section_pad.dts')
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) +
- 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
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
- tools.GetBytes(ord('!'), 3) + # padding to u-boot align
+ tools.get_bytes(ord('!'), 3) + # padding to u-boot align
- 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):
self.assertEqual(expected, data)
def testCompressImage(self):
'188_image_entryarg.dts',use_real_dtb=True, update_dtb=True,
entry_args=entry_args)
'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'
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')
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(),
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')
# 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):
data)
def testTplBssPadMissing(self):
"""Test a collection"""
data = self._DoReadFile('198_collection.dts')
self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA +
"""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):
data)
def testCollectionSection(self):
# missing.
data = self._DoReadFile('199_collection_section.dts')
section = U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA
# 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')
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
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
# 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):
self.assertEqual(expected, data)
def testPackOpenSBI(self):
def testSectionsSingleThread(self):
"""Test sections without multithreading"""
data = self._DoReadFileDtb('055_sections.dts', threads=0)[0]
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):
self.assertEqual(expected, data)
def testThreadTimeout(self):
# definition in the correct place
syms = elf.GetSymbolFileOffset(infile,
['dtb_embed_begin', 'dtb_embed_end'])
# 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]
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'
# 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))
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
# 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()
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')
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:
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)
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)
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')
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'])
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"""
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')
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)
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))
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(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 testFipBadAlign(self):
"""Test that an invalid alignment value in a FIP is detected"""
def testFetchBintools(self):
def fail_download(url):
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']
raise urllib.error.URLError('my error')
args = ['tool']
self.assertIn('Please specify bintools to fetch', str(e.exception))
args = ['tool', '--fetch', '_testing']
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)
side_effect=fail_download):
with test_util.capture_sys_output() as (stdout, _):
self._DoBinman(*args)
Raises:
ValueError if something goes wrong
"""
Raises:
ValueError if something goes wrong
"""
- data = tools.ReadFile(fname)
+ data = tools.read_file(fname)
size = len(data)
# First look for an image header
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:]
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()
dtb = fdt.Fdt(out_fname)
dtb.Scan()
def BuildImage(self):
"""Write the image to a file"""
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()
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
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)
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]
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):
return pathname, data
def UpdateFdtContents(etype, data):
"""
dtb, fname = output_fdt_info[etype]
dtb_fname = dtb.GetFilename()
"""
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]
dtb = fdt.FdtScan(dtb_fname)
output_fdt_info[etype] = [dtb, fname]
else:
fdt_set = {}
for etype, fname in DTB_TYPE_FNAME.items():
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)
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' %
- 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]
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
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()
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')
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_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
else:
version = '(unreleased)'
return version
global builder
if options.full_help:
global builder
if options.full_help:
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README')
)
return 0
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')
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:
if type(commit) is not str:
stderr = self._error.get((brd.target, commit.sequence))
if stderr:
def testPrepareOutputSpace(self):
def _Touch(fname):
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()
base_dir = tempfile.mkdtemp()
# We'll use MakeArgs() to provide this
pass
elif full_path:
# 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:
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']
url = '%s/%s/%s/' % (base, arch, version)
print('Checking: %s' % url)
response = urllib.request.urlopen(url)
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':
parser = MyHTMLParser(fetch_arch)
parser.feed(html)
if fetch_arch == 'list':
os.mkdir(dest)
# Download the tar file for this toolchain and unpack it
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=' ')
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,
prop_name: Name of property
"""
self.props[prop_name] = Prop(self, None, prop_name,
def AddEmptyProp(self, prop_name, len):
"""Add a property with a fixed data size, for filling in later
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
"""
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):
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 = 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)
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:
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])
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)
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):
"""Tests for dtoc"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
cls.maxDiff = None
@classmethod
def tearDownClass(cls):
cls.maxDiff = None
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
@staticmethod
def _write_python_string(fname, data):
@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')
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,
# 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')
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()
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)
# 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')
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()
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')
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,
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')
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()
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')
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()
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')
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()
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')
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())
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)
"""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'",
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)
"""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",
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')
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()
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')
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()
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')
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()
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')
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()
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)
"""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",
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)
"""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(
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')
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()
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')
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)
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)
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')
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(
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
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')
# 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))
fnames = glob.glob(outdir + '/*')
self.assertEqual(2, len(fnames))
Scanner: scanner to use
"""
dtb_file = get_dtb_file('dtoc_test_simple.dts')
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()
# 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')
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
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')
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))
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)
# 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",
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')
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'",
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')
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
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')
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()
# 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')
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:
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')
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)
# 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)
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",
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')
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)
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 "
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):
"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
@classmethod
def setUpClass(cls):
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
@classmethod
def setUpClass(cls):
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
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))
"""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.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.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.fdt.pack()
self.node.SetString('string', val + 'x')
self.node.SetString('string', val[:-1])
prop = self.node.props['string']
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.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']
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.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.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):
self.dtb.Sync(auto_resize=True)
def testFromData(self):
def testGetFilename(self):
"""Test the dtb filename can be provided"""
def testGetFilename(self):
"""Test the dtb filename can be provided"""
- self.assertEqual(tools.GetOutputFilename('source.dtb'),
+ self.assertEqual(tools.get_output_filename('source.dtb'),
"""
@classmethod
def setUpClass(cls):
"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
def setUp(self):
self.dtb = fdt.FdtScan(find_dtb_file('dtoc_test_simple.dts'))
"""Tests for src_scan"""
@classmethod
def setUpClass(cls):
"""Tests for src_scan"""
@classmethod
def setUpClass(cls):
- tools.PrepareOutputDir(None)
+ tools.prepare_output_dir(None)
@classmethod
def tearDownClass(cls):
@classmethod
def tearDownClass(cls):
- tools.FinaliseOutputDir()
+ tools.finalise_output_dir()
def test_simple(self):
"""Simple test of scanning drivers"""
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)
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:
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')
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)
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"""
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, _):
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)
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')
index = self.repo.index
index.add(fname)
author = pygit2.Signature('Test user', 'test@email.com')
fd.close()
elif args.full_help:
fd.close()
elif args.full_help:
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), 'README')
)
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
# 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 = []
search_paths = []
tool_search_paths = []
# List of paths to use when looking for an input file
indir = []
# 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
"""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)
outdir = tempfile.mkdtemp(prefix='binman.')
tout.Debug("Using temporary directory '%s'" % outdir)
+def _remove_output_dir():
global outdir
shutil.rmtree(outdir)
tout.Debug("Deleted temporary directory '%s'" % outdir)
outdir = None
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:
global outdir, preserve_outdir
"""Tidy up: delete output directory if temporary and not preserved."""
if outdir and not preserve_outdir:
-def GetOutputFilename(fname):
+def get_output_filename(fname):
"""Return a filename within the output directory.
Args:
"""Return a filename within the output directory.
Args:
"""
return os.path.join(outdir, fname)
"""
return os.path.join(outdir, fname)
"""Return the current output directory
Returns:
"""Return the current output directory
Returns:
+def _finalise_for_test():
"""Remove the output directory (for use by tests)"""
global outdir
if outdir:
"""Remove the output directory (for use by tests)"""
global outdir
if outdir:
-def SetInputDirs(dirname):
+def set_input_dirs(dirname):
"""Add a list of input directories, where input files are kept.
Args:
"""Add a list of input directories, where input files are kept.
Args:
indir = dirname
tout.Debug("Using input directories %s" % indir)
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:
"""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()))
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:
"""Return a list of filenames for use as input.
Args:
files += glob.glob(pathname)
return sorted(files)
files += glob.glob(pathname)
return sorted(files)
if align:
mask = align - 1
pos = (pos + mask) & ~mask
return pos
if align:
mask = align - 1
pos = (pos + mask) & ~mask
return pos
+def not_power_of_two(num):
return num and (num & (num - 1))
return num and (num & (num - 1))
-def SetToolPaths(toolpaths):
+def set_tool_paths(toolpaths):
"""Set the path to search for tools
Args:
"""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
"""
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:
"""Check if a given filename is in the PATH
Args:
-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
"""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, []
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
"""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:
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'
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:
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:
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
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:
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:
msg = "Please install tool '%s'" % name
package = packages.get(name)
if package:
def tool_find(name):
"""Search the current path for a tool
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
Args:
name (str): Name of tool to locate
if os.path.isfile(fname) and os.access(fname, os.X_OK):
return fname
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
"""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
if result is not None:
return result.stdout
"""Resolve a file path to an absolute path.
If fname starts with ##/ and chroot is available, ##/ gets replaced with
"""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
# 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:
"""Read and return the contents of a file.
Args:
Returns:
data read from file, as a string.
"""
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
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:
"""Write data into a file.
Args:
"""
#self._out.Info("Write file '%s' size %d (%#0x)" %
#(fname, len(data), len(data)))
"""
#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:
-def GetBytes(byte, size):
+def get_bytes(byte, size):
"""Get a string of bytes of a given size
Args:
"""Get a string of bytes of a given size
Args:
"""
return bytes([byte]) * size
"""
return bytes([byte]) * size
"""Convert a str type into a bytes type
Args:
"""Convert a str type into a bytes type
Args:
"""
return string.encode('utf-8')
"""
return string.encode('utf-8')
"""Convert a bytes type into a str type
Args:
"""Convert a bytes type into a str type
Args:
"""
return bval.decode('utf-8')
"""
return bval.decode('utf-8')
"""Convert an integer value (or None) to a string
Returns:
"""Convert an integer value (or None) to a string
Returns:
"""
return 'None' if val is None else '%#x' % val
"""
return 'None' if val is None else '%#x' % val
"""Return the size of an object in hex
Returns:
"""Return the size of an object in hex
Returns:
"""
return 'None' if val is None else '%#x' % len(val)
"""
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:
"""Print the full help message for a tool using an appropriate pager.
Args:
pager = ['more']
command.Run(*pager, fname)
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:
"""Download a file to a temporary directory
Args:
projects / platform / kernel / u-boot.git / commitdiff