colin/u-boot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

patman: Convert camel case in tools.py

Browse Source 
Convert this file to snake case and update all files which use it.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
2022-01-29 14:14:04 -07:00
parent 82ee8bfe51
commit c1aa66e75d
50 changed files with 473 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

320
tools/binman/ftest.py
View File

@@ -174,7 +174,7 @@ class TestFunctional(unittest.TestCase):
# 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()
@@ -236,7 +236,7 @@ class TestFunctional(unittest.TestCase):
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
@@ -262,10 +262,10 @@ class TestFunctional(unittest.TestCase):
Temporary directory to use
New image filename
"""
image_fname = tools.GetOutputFilename('image.bin')
image_fname = tools.get_output_filename('image.bin')
tmpdir = tempfile.mkdtemp(prefix='binman.')
updated_fname = os.path.join(tmpdir, 'image-updated.bin')
tools.WriteFile(updated_fname, tools.ReadFile(image_fname))
tools.write_file(updated_fname, tools.read_file(image_fname))
self._CleanupOutputDir()
return tmpdir, updated_fname
@@ -492,14 +492,14 @@ class TestFunctional(unittest.TestCase):
use_expanded=use_expanded, extra_indirs=extra_indirs,
threads=threads)
self.assertEqual(0, retcode)
out_dtb_fname = tools.GetOutputFilename('u-boot.dtb.out')
out_dtb_fname = tools.get_output_filename('u-boot.dtb.out')
# Find the (only) image, read it and return its contents
image = control.images['image']
image_fname = tools.GetOutputFilename('image.bin')
image_fname = tools.get_output_filename('image.bin')
self.assertTrue(os.path.exists(image_fname))
if map:
map_fname = tools.GetOutputFilename('image.map')
map_fname = tools.get_output_filename('image.map')
with open(map_fname) as fd:
map_data = fd.read()
else:
@@ -578,7 +578,7 @@ class TestFunctional(unittest.TestCase):
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'):
@@ -588,7 +588,7 @@ class TestFunctional(unittest.TestCase):
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):
@@ -756,7 +756,7 @@ class TestFunctional(unittest.TestCase):
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()
@@ -764,13 +764,13 @@ class TestFunctional(unittest.TestCase):
image = control.images['image2']
self.assertEqual(3 + len(U_BOOT_DATA) + 5, image.size)
fname = tools.GetOutputFilename('image2.bin')
fname = tools.get_output_filename('image2.bin')
self.assertTrue(os.path.exists(fname))
with open(fname, 'rb') as fd:
data = fd.read()
self.assertEqual(U_BOOT_DATA, data[3:7])
self.assertEqual(tools.GetBytes(0, 3), data[:3])
self.assertEqual(tools.GetBytes(0, 5), data[7:])
self.assertEqual(tools.get_bytes(0, 3), data[:3])
self.assertEqual(tools.get_bytes(0, 5), data[7:])
def testBadAlign(self):
"""Test that an invalid alignment value is detected"""
@@ -838,8 +838,8 @@ class TestFunctional(unittest.TestCase):
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
@@ -857,7 +857,7 @@ class TestFunctional(unittest.TestCase):
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
@@ -867,7 +867,7 @@ class TestFunctional(unittest.TestCase):
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
@@ -877,7 +877,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -997,7 +997,7 @@ class TestFunctional(unittest.TestCase):
"""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):
@@ -1005,11 +1005,11 @@ class TestFunctional(unittest.TestCase):
retcode = self._DoTestFile('022_image_name.dts')
self.assertEqual(0, retcode)
image = control.images['image1']
fname = tools.GetOutputFilename('test-name')
fname = tools.get_output_filename('test-name')
self.assertTrue(os.path.exists(fname))
image = control.images['image2']
fname = tools.GetOutputFilename('test-name.xx')
fname = tools.get_output_filename('test-name.xx')
self.assertTrue(os.path.exists(fname))
def testBlobFilename(self):
@@ -1021,8 +1021,8 @@ class TestFunctional(unittest.TestCase):
"""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"""
@@ -1065,8 +1065,8 @@ class TestFunctional(unittest.TestCase):
"""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"""
@@ -1090,7 +1090,7 @@ class TestFunctional(unittest.TestCase):
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)])
@@ -1139,7 +1139,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -1244,7 +1244,7 @@ class TestFunctional(unittest.TestCase):
# 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()
@@ -1254,7 +1254,7 @@ class TestFunctional(unittest.TestCase):
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"""
@@ -1267,7 +1267,7 @@ class TestFunctional(unittest.TestCase):
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
@@ -1279,7 +1279,7 @@ class TestFunctional(unittest.TestCase):
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"""
@@ -1308,7 +1308,7 @@ class TestFunctional(unittest.TestCase):
# 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):
@@ -1404,7 +1404,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -1426,9 +1426,9 @@ class TestFunctional(unittest.TestCase):
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):
@@ -1593,9 +1593,9 @@ class TestFunctional(unittest.TestCase):
}
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)
@@ -1617,8 +1617,8 @@ class TestFunctional(unittest.TestCase):
"""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)
@@ -1670,7 +1670,7 @@ class TestFunctional(unittest.TestCase):
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):
@@ -1700,8 +1700,8 @@ class TestFunctional(unittest.TestCase):
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):
@@ -1751,7 +1751,7 @@ class TestFunctional(unittest.TestCase):
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:
@@ -1845,7 +1845,7 @@ class TestFunctional(unittest.TestCase):
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"""
@@ -1875,8 +1875,8 @@ class TestFunctional(unittest.TestCase):
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):
@@ -1933,8 +1933,8 @@ class TestFunctional(unittest.TestCase):
'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:
@@ -2027,10 +2027,10 @@ class TestFunctional(unittest.TestCase):
"""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
@@ -2085,7 +2085,7 @@ class TestFunctional(unittest.TestCase):
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):
@@ -2107,7 +2107,7 @@ class TestFunctional(unittest.TestCase):
"""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:])
@@ -2129,7 +2129,7 @@ class TestFunctional(unittest.TestCase):
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:])
@@ -2177,14 +2177,14 @@ class TestFunctional(unittest.TestCase):
with test_util.capture_sys_output() as (stdout, stderr):
with self.assertRaises(ValueError) as e:
self._DoTestFile('014_pack_overlap.dts', map=True)
map_fname = tools.GetOutputFilename('image.map')
map_fname = tools.get_output_filename('image.map')
self.assertEqual("Wrote map file '%s' to show errors\n" % map_fname,
stdout.getvalue())
# We should not get an inmage, but there should be a map file
self.assertFalse(os.path.exists(tools.GetOutputFilename('image.bin')))
self.assertFalse(os.path.exists(tools.get_output_filename('image.bin')))
self.assertTrue(os.path.exists(map_fname))
map_data = tools.ReadFile(map_fname, binary=False)
map_data = tools.read_file(map_fname, binary=False)
self.assertEqual('''ImagePos Offset Size Name
<none> 00000000 00000008 main-section
<none> 00000000 00000004 u-boot
@@ -2210,12 +2210,12 @@ class TestFunctional(unittest.TestCase):
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)
@@ -2332,17 +2332,17 @@ class TestFunctional(unittest.TestCase):
Args:
data: Conents of output file
"""
expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
expected_desc = tools.read_file(self.TestFile('descriptor.bin'))
if data[:0x1000] != expected_desc:
self.fail('Expected descriptor binary at start of image')
# We expect to find the TPL wil in subpart IBBP entry IBBL
image_fname = tools.GetOutputFilename('image.bin')
tpl_fname = tools.GetOutputFilename('tpl.out')
image_fname = tools.get_output_filename('image.bin')
tpl_fname = tools.get_output_filename('tpl.out')
ifwitool = bintool.Bintool.create('ifwitool')
ifwitool.extract(image_fname, 'IBBP', 'IBBL', tpl_fname)
tpl_data = tools.ReadFile(tpl_fname)
tpl_data = tools.read_file(tpl_fname)
self.assertEqual(U_BOOT_TPL_DATA, tpl_data[:len(U_BOOT_TPL_DATA)])
def testPackX86RomIfwi(self):
@@ -2403,7 +2403,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -2668,7 +2668,7 @@ class TestFunctional(unittest.TestCase):
"""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(),
@@ -2684,7 +2684,7 @@ class TestFunctional(unittest.TestCase):
"""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:])
@@ -2692,7 +2692,7 @@ class TestFunctional(unittest.TestCase):
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))
@@ -2752,7 +2752,7 @@ class TestFunctional(unittest.TestCase):
"""
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:]]
@@ -2798,7 +2798,7 @@ class TestFunctional(unittest.TestCase):
"""
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):
@@ -2858,7 +2858,7 @@ class TestFunctional(unittest.TestCase):
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')
@@ -2874,17 +2874,17 @@ class TestFunctional(unittest.TestCase):
'-f', fname)
finally:
shutil.rmtree(tmpdir)
data = tools.ReadFile(fname)
data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def testExtractOneEntry(self):
"""Test extracting a single entry fron an image """
self._CheckLz4()
self._DoReadFileRealDtb('130_list_fdtmap.dts')
image_fname = tools.GetOutputFilename('image.bin')
image_fname = tools.get_output_filename('image.bin')
fname = os.path.join(self._indir, 'output.extact')
control.ExtractEntries(image_fname, fname, None, ['u-boot'])
data = tools.ReadFile(fname)
data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def _CheckExtractOutput(self, decomp):
@@ -2906,7 +2906,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -2926,7 +2926,7 @@ class TestFunctional(unittest.TestCase):
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)
@@ -2962,7 +2962,7 @@ class TestFunctional(unittest.TestCase):
_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.
@@ -2987,7 +2987,7 @@ class TestFunctional(unittest.TestCase):
"""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*'])
@@ -3002,7 +3002,7 @@ class TestFunctional(unittest.TestCase):
"""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',
@@ -3012,7 +3012,7 @@ class TestFunctional(unittest.TestCase):
"""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',
@@ -3113,9 +3113,9 @@ class TestFunctional(unittest.TestCase):
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)
@@ -3170,8 +3170,8 @@ class TestFunctional(unittest.TestCase):
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)
@@ -3182,9 +3182,9 @@ class TestFunctional(unittest.TestCase):
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)
@@ -3348,8 +3348,8 @@ class TestFunctional(unittest.TestCase):
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)
@@ -3361,8 +3361,8 @@ class TestFunctional(unittest.TestCase):
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)
@@ -3383,23 +3383,23 @@ class TestFunctional(unittest.TestCase):
"""
data = self._DoReadFileRealDtb('143_replace_all.dts')
updated_fname = tools.GetOutputFilename('image-updated.bin')
tools.WriteFile(updated_fname, data)
updated_fname = tools.get_output_filename('image-updated.bin')
tools.write_file(updated_fname, data)
outdir = os.path.join(self._indir, 'extract')
einfos = control.ExtractEntries(updated_fname, None, outdir, [])
expected1 = b'x' + U_BOOT_DATA + b'y'
u_boot_fname1 = os.path.join(outdir, 'u-boot')
tools.WriteFile(u_boot_fname1, expected1)
tools.write_file(u_boot_fname1, expected1)
expected2 = b'a' + U_BOOT_DATA + b'b'
u_boot_fname2 = os.path.join(outdir, 'u-boot2')
tools.WriteFile(u_boot_fname2, expected2)
tools.write_file(u_boot_fname2, expected2)
expected_text = b'not the same text'
text_fname = os.path.join(outdir, 'text')
tools.WriteFile(text_fname, expected_text)
tools.write_file(text_fname, expected_text)
dtb_fname = os.path.join(outdir, 'u-boot-dtb')
dtb = fdt.FdtScan(dtb_fname)
@@ -3475,10 +3475,10 @@ class TestFunctional(unittest.TestCase):
fname = os.path.join(tmpdir, 'update-u-boot.bin')
expected = b'x' * len(U_BOOT_DATA)
tools.WriteFile(fname, expected)
tools.write_file(fname, expected)
self._DoBinman('replace', '-i', updated_fname, 'u-boot', '-f', fname)
data = tools.ReadFile(updated_fname)
data = tools.read_file(updated_fname)
self.assertEqual(expected, data[:len(expected)])
map_fname = os.path.join(tmpdir, 'image-updated.map')
self.assertFalse(os.path.exists(map_fname))
@@ -3493,7 +3493,7 @@ class TestFunctional(unittest.TestCase):
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()
@@ -3531,7 +3531,7 @@ class TestFunctional(unittest.TestCase):
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')
@@ -3543,7 +3543,7 @@ class TestFunctional(unittest.TestCase):
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',
@@ -3552,7 +3552,7 @@ class TestFunctional(unittest.TestCase):
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',
@@ -3597,15 +3597,15 @@ class TestFunctional(unittest.TestCase):
data = self._DoReadFile(dts)
sym_values = struct.pack('<LQLL', *expected_vals)
upto1 = 4 + len(U_BOOT_SPL_DATA)
expected1 = tools.GetBytes(0xff, 4) + sym_values + U_BOOT_SPL_DATA[20:]
expected1 = tools.get_bytes(0xff, 4) + sym_values + U_BOOT_SPL_DATA[20:]
self.assertEqual(expected1, data[:upto1])
upto2 = upto1 + 1 + len(U_BOOT_SPL_DATA)
expected2 = tools.GetBytes(0xff, 1) + sym_values + U_BOOT_SPL_DATA[20:]
expected2 = tools.get_bytes(0xff, 1) + sym_values + U_BOOT_SPL_DATA[20:]
self.assertEqual(expected2, data[upto1:upto2])
upto3 = 0x34 + len(U_BOOT_DATA)
expected3 = tools.GetBytes(0xff, 1) + U_BOOT_DATA
expected3 = tools.get_bytes(0xff, 1) + U_BOOT_DATA
self.assertEqual(expected3, data[upto2:upto3])
expected4 = sym_values + U_BOOT_TPL_DATA[20:]
@@ -3727,8 +3727,8 @@ class TestFunctional(unittest.TestCase):
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
@@ -3763,7 +3763,7 @@ class TestFunctional(unittest.TestCase):
# 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
@@ -3802,8 +3802,8 @@ class TestFunctional(unittest.TestCase):
"""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)
@@ -3846,14 +3846,14 @@ class TestFunctional(unittest.TestCase):
node = dtb.GetNode('/images/kernel')
data = dtb.GetProps(node)["data"].bytes
align_pad = 0x10 - (len(U_BOOT_SPL_DATA) % 0x10)
expected = (tools.GetBytes(0, 0x20) + U_BOOT_SPL_DATA +
tools.GetBytes(0, align_pad) + U_BOOT_DATA)
expected = (tools.get_bytes(0, 0x20) + U_BOOT_SPL_DATA +
tools.get_bytes(0, align_pad) + U_BOOT_DATA)
self.assertEqual(expected, data)
node = dtb.GetNode('/images/fdt-1')
data = dtb.GetProps(node)["data"].bytes
expected = (U_BOOT_SPL_DTB_DATA + tools.GetBytes(0, 20) +
tools.ToBytes(TEXT_DATA) + tools.GetBytes(0, 30) +
expected = (U_BOOT_SPL_DTB_DATA + tools.get_bytes(0, 20) +
tools.to_bytes(TEXT_DATA) + tools.get_bytes(0, 30) +
U_BOOT_DTB_DATA)
self.assertEqual(expected, data)
@@ -4069,8 +4069,8 @@ class TestFunctional(unittest.TestCase):
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)
@@ -4089,8 +4089,8 @@ class TestFunctional(unittest.TestCase):
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)
@@ -4110,23 +4110,23 @@ class TestFunctional(unittest.TestCase):
def testSectionPad(self):
"""Testing padding with sections"""
data = self._DoReadFile('180_section_pad.dts')
expected = (tools.GetBytes(ord('&'), 3) +
tools.GetBytes(ord('!'), 5) +
expected = (tools.get_bytes(ord('&'), 3) +
tools.get_bytes(ord('!'), 5) +
U_BOOT_DATA +
tools.GetBytes(ord('!'), 1) +
tools.GetBytes(ord('&'), 2))
tools.get_bytes(ord('!'), 1) +
tools.get_bytes(ord('&'), 2))
self.assertEqual(expected, data)
def testSectionAlign(self):
"""Testing alignment with sections"""
data = self._DoReadFileDtb('181_section_align.dts', map=True)[0]
expected = (b'\0' + # fill section
tools.GetBytes(ord('&'), 1) + # padding to section align
tools.get_bytes(ord('&'), 1) + # padding to section align
b'\0' + # fill section
tools.GetBytes(ord('!'), 3) + # padding to u-boot align
tools.get_bytes(ord('!'), 3) + # padding to u-boot align
U_BOOT_DATA +
tools.GetBytes(ord('!'), 4) + # padding to u-boot size
tools.GetBytes(ord('!'), 4)) # padding to section size
tools.get_bytes(ord('!'), 4) + # padding to u-boot size
tools.get_bytes(ord('!'), 4)) # padding to section size
self.assertEqual(expected, data)
def testCompressImage(self):
@@ -4357,7 +4357,7 @@ class TestFunctional(unittest.TestCase):
'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'
@@ -4378,7 +4378,7 @@ class TestFunctional(unittest.TestCase):
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(),
@@ -4406,7 +4406,7 @@ class TestFunctional(unittest.TestCase):
# 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):
@@ -4605,8 +4605,8 @@ class TestFunctional(unittest.TestCase):
"""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):
@@ -4617,21 +4617,21 @@ class TestFunctional(unittest.TestCase):
# missing.
data = self._DoReadFile('199_collection_section.dts')
section = U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA
self.assertEqual(section + U_BOOT_DATA + tools.GetBytes(0xff, 2) +
section + tools.GetBytes(0xfe, 3) + U_BOOT_DATA,
self.assertEqual(section + U_BOOT_DATA + tools.get_bytes(0xff, 2) +
section + tools.get_bytes(0xfe, 3) + U_BOOT_DATA,
data)
def testAlignDefault(self):
"""Test that default alignment works on sections"""
data = self._DoReadFile('200_align_default.dts')
expected = (U_BOOT_DATA + tools.GetBytes(0, 8 - len(U_BOOT_DATA)) +
expected = (U_BOOT_DATA + tools.get_bytes(0, 8 - len(U_BOOT_DATA)) +
U_BOOT_DATA)
# Special alignment for section
expected += tools.GetBytes(0, 32 - len(expected))
expected += tools.get_bytes(0, 32 - len(expected))
# No alignment within the nested section
expected += U_BOOT_DATA + U_BOOT_NODTB_DATA;
# Now the final piece, which should be default-aligned
expected += tools.GetBytes(0, 88 - len(expected)) + U_BOOT_NODTB_DATA
expected += tools.get_bytes(0, 88 - len(expected)) + U_BOOT_NODTB_DATA
self.assertEqual(expected, data)
def testPackOpenSBI(self):
@@ -4642,9 +4642,9 @@ class TestFunctional(unittest.TestCase):
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):
@@ -4677,7 +4677,7 @@ class TestFunctional(unittest.TestCase):
# 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]
@@ -4756,7 +4756,7 @@ class TestFunctional(unittest.TestCase):
# 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))
@@ -4780,7 +4780,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
# 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()
@@ -4788,7 +4788,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
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:
@@ -4917,7 +4917,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
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)
@@ -4944,25 +4944,25 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
def testFipExtractOneEntry(self):
"""Test extracting a single entry fron an FIP"""
self._DoReadFileRealDtb('207_fip_ls.dts')
image_fname = tools.GetOutputFilename('image.bin')
image_fname = tools.get_output_filename('image.bin')
fname = os.path.join(self._indir, 'output.extact')
control.ExtractEntries(image_fname, fname, None, ['atf-fip/u-boot'])
data = tools.ReadFile(fname)
data = tools.read_file(fname)
self.assertEqual(U_BOOT_DATA, data)
def testFipReplace(self):
"""Test replacing a single file in a FIP"""
expected = U_BOOT_DATA + tools.GetBytes(0x78, 50)
expected = U_BOOT_DATA + tools.get_bytes(0x78, 50)
data = self._DoReadFileRealDtb('208_fip_replace.dts')
updated_fname = tools.GetOutputFilename('image-updated.bin')
tools.WriteFile(updated_fname, data)
updated_fname = tools.get_output_filename('image-updated.bin')
tools.write_file(updated_fname, data)
entry_name = 'atf-fip/u-boot'
control.WriteEntry(updated_fname, entry_name, expected,
allow_resize=True)
actual = control.ReadEntry(updated_fname, entry_name)
self.assertEqual(expected, actual)
new_data = tools.ReadFile(updated_fname)
new_data = tools.read_file(updated_fname)
hdr, fents = fip_util.decode_fip(new_data)
self.assertEqual(2, len(fents))
@@ -4999,7 +4999,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
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"""
@@ -5055,7 +5055,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
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']
@@ -5070,7 +5070,7 @@ fdt fdtmap Extract the devicetree blob from the fdtmap
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)