1# SPDX-License-Identifier: GPL-2.0+ 2# Copyright (c) 2016 Google, Inc 3# Written by Simon Glass <sjg@chromium.org> 4# 5# To run a single test, change to this directory, and: 6# 7# python -m unittest func_test.TestFunctional.testHelp 8 9import hashlib 10from optparse import OptionParser 11import os 12import shutil 13import struct 14import sys 15import tempfile 16import unittest 17 18import binman 19import cmdline 20import command 21import control 22import elf 23import fdt 24import fdt_util 25import fmap_util 26import test_util 27import state 28import tools 29import tout 30 31# Contents of test files, corresponding to different entry types 32U_BOOT_DATA = '1234' 33U_BOOT_IMG_DATA = 'img' 34U_BOOT_SPL_DATA = '56780123456789abcde' 35U_BOOT_TPL_DATA = 'tpl' 36BLOB_DATA = '89' 37ME_DATA = '0abcd' 38VGA_DATA = 'vga' 39U_BOOT_DTB_DATA = 'udtb' 40U_BOOT_SPL_DTB_DATA = 'spldtb' 41U_BOOT_TPL_DTB_DATA = 'tpldtb' 42X86_START16_DATA = 'start16' 43X86_START16_SPL_DATA = 'start16spl' 44X86_START16_TPL_DATA = 'start16tpl' 45PPC_MPC85XX_BR_DATA = 'ppcmpc85xxbr' 46U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' 47U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' 48U_BOOT_TPL_NODTB_DATA = 'tplnodtb with microcode pointer somewhere in here' 49FSP_DATA = 'fsp' 50CMC_DATA = 'cmc' 51VBT_DATA = 'vbt' 52MRC_DATA = 'mrc' 53TEXT_DATA = 'text' 54TEXT_DATA2 = 'text2' 55TEXT_DATA3 = 'text3' 56CROS_EC_RW_DATA = 'ecrw' 57GBB_DATA = 'gbbd' 58BMPBLK_DATA = 'bmp' 59VBLOCK_DATA = 'vblk' 60FILES_DATA = ("sorry I'm late\nOh, don't bother apologising, I'm " + 61 "sorry you're alive\n") 62COMPRESS_DATA = 'data to compress' 63REFCODE_DATA = 'refcode' 64 65 66class TestFunctional(unittest.TestCase): 67 """Functional tests for binman 68 69 Most of these use a sample .dts file to build an image and then check 70 that it looks correct. The sample files are in the test/ subdirectory 71 and are numbered. 72 73 For each entry type a very small test file is created using fixed 74 string contents. This makes it easy to test that things look right, and 75 debug problems. 76 77 In some cases a 'real' file must be used - these are also supplied in 78 the test/ diurectory. 79 """ 80 @classmethod 81 def setUpClass(self): 82 global entry 83 import entry 84 85 # Handle the case where argv[0] is 'python' 86 self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) 87 self._binman_pathname = os.path.join(self._binman_dir, 'binman') 88 89 # Create a temporary directory for input files 90 self._indir = tempfile.mkdtemp(prefix='binmant.') 91 92 # Create some test files 93 TestFunctional._MakeInputFile('u-boot.bin', U_BOOT_DATA) 94 TestFunctional._MakeInputFile('u-boot.img', U_BOOT_IMG_DATA) 95 TestFunctional._MakeInputFile('spl/u-boot-spl.bin', U_BOOT_SPL_DATA) 96 TestFunctional._MakeInputFile('tpl/u-boot-tpl.bin', U_BOOT_TPL_DATA) 97 TestFunctional._MakeInputFile('blobfile', BLOB_DATA) 98 TestFunctional._MakeInputFile('me.bin', ME_DATA) 99 TestFunctional._MakeInputFile('vga.bin', VGA_DATA) 100 self._ResetDtbs() 101 TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA) 102 TestFunctional._MakeInputFile('u-boot-br.bin', PPC_MPC85XX_BR_DATA) 103 TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin', 104 X86_START16_SPL_DATA) 105 TestFunctional._MakeInputFile('tpl/u-boot-x86-16bit-tpl.bin', 106 X86_START16_TPL_DATA) 107 TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA) 108 TestFunctional._MakeInputFile('spl/u-boot-spl-nodtb.bin', 109 U_BOOT_SPL_NODTB_DATA) 110 TestFunctional._MakeInputFile('tpl/u-boot-tpl-nodtb.bin', 111 U_BOOT_TPL_NODTB_DATA) 112 TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) 113 TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) 114 TestFunctional._MakeInputFile('vbt.bin', VBT_DATA) 115 TestFunctional._MakeInputFile('mrc.bin', MRC_DATA) 116 TestFunctional._MakeInputFile('ecrw.bin', CROS_EC_RW_DATA) 117 TestFunctional._MakeInputDir('devkeys') 118 TestFunctional._MakeInputFile('bmpblk.bin', BMPBLK_DATA) 119 TestFunctional._MakeInputFile('refcode.bin', REFCODE_DATA) 120 121 # ELF file with a '_dt_ucode_base_size' symbol 122 with open(self.TestFile('u_boot_ucode_ptr')) as fd: 123 TestFunctional._MakeInputFile('u-boot', fd.read()) 124 125 # Intel flash descriptor file 126 with open(self.TestFile('descriptor.bin')) as fd: 127 TestFunctional._MakeInputFile('descriptor.bin', fd.read()) 128 129 shutil.copytree(self.TestFile('files'), 130 os.path.join(self._indir, 'files')) 131 132 TestFunctional._MakeInputFile('compress', COMPRESS_DATA) 133 134 @classmethod 135 def tearDownClass(self): 136 """Remove the temporary input directory and its contents""" 137 if self._indir: 138 shutil.rmtree(self._indir) 139 self._indir = None 140 141 def setUp(self): 142 # Enable this to turn on debugging output 143 # tout.Init(tout.DEBUG) 144 command.test_result = None 145 146 def tearDown(self): 147 """Remove the temporary output directory""" 148 tools._FinaliseForTest() 149 150 @classmethod 151 def _ResetDtbs(self): 152 TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA) 153 TestFunctional._MakeInputFile('spl/u-boot-spl.dtb', U_BOOT_SPL_DTB_DATA) 154 TestFunctional._MakeInputFile('tpl/u-boot-tpl.dtb', U_BOOT_TPL_DTB_DATA) 155 156 def _RunBinman(self, *args, **kwargs): 157 """Run binman using the command line 158 159 Args: 160 Arguments to pass, as a list of strings 161 kwargs: Arguments to pass to Command.RunPipe() 162 """ 163 result = command.RunPipe([[self._binman_pathname] + list(args)], 164 capture=True, capture_stderr=True, raise_on_error=False) 165 if result.return_code and kwargs.get('raise_on_error', True): 166 raise Exception("Error running '%s': %s" % (' '.join(args), 167 result.stdout + result.stderr)) 168 return result 169 170 def _DoBinman(self, *args): 171 """Run binman using directly (in the same process) 172 173 Args: 174 Arguments to pass, as a list of strings 175 Returns: 176 Return value (0 for success) 177 """ 178 args = list(args) 179 if '-D' in sys.argv: 180 args = args + ['-D'] 181 (options, args) = cmdline.ParseArgs(args) 182 options.pager = 'binman-invalid-pager' 183 options.build_dir = self._indir 184 185 # For testing, you can force an increase in verbosity here 186 # options.verbosity = tout.DEBUG 187 return control.Binman(options, args) 188 189 def _DoTestFile(self, fname, debug=False, map=False, update_dtb=False, 190 entry_args=None, images=None, use_real_dtb=False): 191 """Run binman with a given test file 192 193 Args: 194 fname: Device-tree source filename to use (e.g. 005_simple.dts) 195 debug: True to enable debugging output 196 map: True to output map files for the images 197 update_dtb: Update the offset and size of each entry in the device 198 tree before packing it into the image 199 entry_args: Dict of entry args to supply to binman 200 key: arg name 201 value: value of that arg 202 images: List of image names to build 203 """ 204 args = ['-p', '-I', self._indir, '-d', self.TestFile(fname)] 205 if debug: 206 args.append('-D') 207 if map: 208 args.append('-m') 209 if update_dtb: 210 args.append('-up') 211 if not use_real_dtb: 212 args.append('--fake-dtb') 213 if entry_args: 214 for arg, value in entry_args.iteritems(): 215 args.append('-a%s=%s' % (arg, value)) 216 if images: 217 for image in images: 218 args += ['-i', image] 219 return self._DoBinman(*args) 220 221 def _SetupDtb(self, fname, outfile='u-boot.dtb'): 222 """Set up a new test device-tree file 223 224 The given file is compiled and set up as the device tree to be used 225 for ths test. 226 227 Args: 228 fname: Filename of .dts file to read 229 outfile: Output filename for compiled device-tree binary 230 231 Returns: 232 Contents of device-tree binary 233 """ 234 tools.PrepareOutputDir(None) 235 dtb = fdt_util.EnsureCompiled(self.TestFile(fname)) 236 with open(dtb) as fd: 237 data = fd.read() 238 TestFunctional._MakeInputFile(outfile, data) 239 tools.FinaliseOutputDir() 240 return data 241 242 def _GetDtbContentsForSplTpl(self, dtb_data, name): 243 """Create a version of the main DTB for SPL or SPL 244 245 For testing we don't actually have different versions of the DTB. With 246 U-Boot we normally run fdtgrep to remove unwanted nodes, but for tests 247 we don't normally have any unwanted nodes. 248 249 We still want the DTBs for SPL and TPL to be different though, since 250 otherwise it is confusing to know which one we are looking at. So add 251 an 'spl' or 'tpl' property to the top-level node. 252 """ 253 dtb = fdt.Fdt.FromData(dtb_data) 254 dtb.Scan() 255 dtb.GetNode('/binman').AddZeroProp(name) 256 dtb.Sync(auto_resize=True) 257 dtb.Pack() 258 return dtb.GetContents() 259 260 def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False, 261 update_dtb=False, entry_args=None, reset_dtbs=True): 262 """Run binman and return the resulting image 263 264 This runs binman with a given test file and then reads the resulting 265 output file. It is a shortcut function since most tests need to do 266 these steps. 267 268 Raises an assertion failure if binman returns a non-zero exit code. 269 270 Args: 271 fname: Device-tree source filename to use (e.g. 005_simple.dts) 272 use_real_dtb: True to use the test file as the contents of 273 the u-boot-dtb entry. Normally this is not needed and the 274 test contents (the U_BOOT_DTB_DATA string) can be used. 275 But in some test we need the real contents. 276 map: True to output map files for the images 277 update_dtb: Update the offset and size of each entry in the device 278 tree before packing it into the image 279 280 Returns: 281 Tuple: 282 Resulting image contents 283 Device tree contents 284 Map data showing contents of image (or None if none) 285 Output device tree binary filename ('u-boot.dtb' path) 286 """ 287 dtb_data = None 288 # Use the compiled test file as the u-boot-dtb input 289 if use_real_dtb: 290 dtb_data = self._SetupDtb(fname) 291 infile = os.path.join(self._indir, 'u-boot.dtb') 292 293 # For testing purposes, make a copy of the DT for SPL and TPL. Add 294 # a node indicating which it is, so aid verification. 295 for name in ['spl', 'tpl']: 296 dtb_fname = '%s/u-boot-%s.dtb' % (name, name) 297 outfile = os.path.join(self._indir, dtb_fname) 298 TestFunctional._MakeInputFile(dtb_fname, 299 self._GetDtbContentsForSplTpl(dtb_data, name)) 300 301 try: 302 retcode = self._DoTestFile(fname, map=map, update_dtb=update_dtb, 303 entry_args=entry_args, use_real_dtb=use_real_dtb) 304 self.assertEqual(0, retcode) 305 out_dtb_fname = tools.GetOutputFilename('u-boot.dtb.out') 306 307 # Find the (only) image, read it and return its contents 308 image = control.images['image'] 309 image_fname = tools.GetOutputFilename('image.bin') 310 self.assertTrue(os.path.exists(image_fname)) 311 if map: 312 map_fname = tools.GetOutputFilename('image.map') 313 with open(map_fname) as fd: 314 map_data = fd.read() 315 else: 316 map_data = None 317 with open(image_fname) as fd: 318 return fd.read(), dtb_data, map_data, out_dtb_fname 319 finally: 320 # Put the test file back 321 if reset_dtbs and use_real_dtb: 322 self._ResetDtbs() 323 324 def _DoReadFile(self, fname, use_real_dtb=False): 325 """Helper function which discards the device-tree binary 326 327 Args: 328 fname: Device-tree source filename to use (e.g. 005_simple.dts) 329 use_real_dtb: True to use the test file as the contents of 330 the u-boot-dtb entry. Normally this is not needed and the 331 test contents (the U_BOOT_DTB_DATA string) can be used. 332 But in some test we need the real contents. 333 334 Returns: 335 Resulting image contents 336 """ 337 return self._DoReadFileDtb(fname, use_real_dtb)[0] 338 339 @classmethod 340 def _MakeInputFile(self, fname, contents): 341 """Create a new test input file, creating directories as needed 342 343 Args: 344 fname: Filename to create 345 contents: File contents to write in to the file 346 Returns: 347 Full pathname of file created 348 """ 349 pathname = os.path.join(self._indir, fname) 350 dirname = os.path.dirname(pathname) 351 if dirname and not os.path.exists(dirname): 352 os.makedirs(dirname) 353 with open(pathname, 'wb') as fd: 354 fd.write(contents) 355 return pathname 356 357 @classmethod 358 def _MakeInputDir(self, dirname): 359 """Create a new test input directory, creating directories as needed 360 361 Args: 362 dirname: Directory name to create 363 364 Returns: 365 Full pathname of directory created 366 """ 367 pathname = os.path.join(self._indir, dirname) 368 if not os.path.exists(pathname): 369 os.makedirs(pathname) 370 return pathname 371 372 @classmethod 373 def _SetupSplElf(self, src_fname='bss_data'): 374 """Set up an ELF file with a '_dt_ucode_base_size' symbol 375 376 Args: 377 Filename of ELF file to use as SPL 378 """ 379 with open(self.TestFile(src_fname)) as fd: 380 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) 381 382 @classmethod 383 def TestFile(self, fname): 384 return os.path.join(self._binman_dir, 'test', fname) 385 386 def AssertInList(self, grep_list, target): 387 """Assert that at least one of a list of things is in a target 388 389 Args: 390 grep_list: List of strings to check 391 target: Target string 392 """ 393 for grep in grep_list: 394 if grep in target: 395 return 396 self.fail("Error: '%' not found in '%s'" % (grep_list, target)) 397 398 def CheckNoGaps(self, entries): 399 """Check that all entries fit together without gaps 400 401 Args: 402 entries: List of entries to check 403 """ 404 offset = 0 405 for entry in entries.values(): 406 self.assertEqual(offset, entry.offset) 407 offset += entry.size 408 409 def GetFdtLen(self, dtb): 410 """Get the totalsize field from a device-tree binary 411 412 Args: 413 dtb: Device-tree binary contents 414 415 Returns: 416 Total size of device-tree binary, from the header 417 """ 418 return struct.unpack('>L', dtb[4:8])[0] 419 420 def _GetPropTree(self, dtb, prop_names): 421 def AddNode(node, path): 422 if node.name != '/': 423 path += '/' + node.name 424 for subnode in node.subnodes: 425 for prop in subnode.props.values(): 426 if prop.name in prop_names: 427 prop_path = path + '/' + subnode.name + ':' + prop.name 428 tree[prop_path[len('/binman/'):]] = fdt_util.fdt32_to_cpu( 429 prop.value) 430 AddNode(subnode, path) 431 432 tree = {} 433 AddNode(dtb.GetRoot(), '') 434 return tree 435 436 def testRun(self): 437 """Test a basic run with valid args""" 438 result = self._RunBinman('-h') 439 440 def testFullHelp(self): 441 """Test that the full help is displayed with -H""" 442 result = self._RunBinman('-H') 443 help_file = os.path.join(self._binman_dir, 'README') 444 # Remove possible extraneous strings 445 extra = '::::::::::::::\n' + help_file + '\n::::::::::::::\n' 446 gothelp = result.stdout.replace(extra, '') 447 self.assertEqual(len(gothelp), os.path.getsize(help_file)) 448 self.assertEqual(0, len(result.stderr)) 449 self.assertEqual(0, result.return_code) 450 451 def testFullHelpInternal(self): 452 """Test that the full help is displayed with -H""" 453 try: 454 command.test_result = command.CommandResult() 455 result = self._DoBinman('-H') 456 help_file = os.path.join(self._binman_dir, 'README') 457 finally: 458 command.test_result = None 459 460 def testHelp(self): 461 """Test that the basic help is displayed with -h""" 462 result = self._RunBinman('-h') 463 self.assertTrue(len(result.stdout) > 200) 464 self.assertEqual(0, len(result.stderr)) 465 self.assertEqual(0, result.return_code) 466 467 def testBoard(self): 468 """Test that we can run it with a specific board""" 469 self._SetupDtb('005_simple.dts', 'sandbox/u-boot.dtb') 470 TestFunctional._MakeInputFile('sandbox/u-boot.bin', U_BOOT_DATA) 471 result = self._DoBinman('-b', 'sandbox') 472 self.assertEqual(0, result) 473 474 def testNeedBoard(self): 475 """Test that we get an error when no board ius supplied""" 476 with self.assertRaises(ValueError) as e: 477 result = self._DoBinman() 478 self.assertIn("Must provide a board to process (use -b <board>)", 479 str(e.exception)) 480 481 def testMissingDt(self): 482 """Test that an invalid device-tree file generates an error""" 483 with self.assertRaises(Exception) as e: 484 self._RunBinman('-d', 'missing_file') 485 # We get one error from libfdt, and a different one from fdtget. 486 self.AssertInList(["Couldn't open blob from 'missing_file'", 487 'No such file or directory'], str(e.exception)) 488 489 def testBrokenDt(self): 490 """Test that an invalid device-tree source file generates an error 491 492 Since this is a source file it should be compiled and the error 493 will come from the device-tree compiler (dtc). 494 """ 495 with self.assertRaises(Exception) as e: 496 self._RunBinman('-d', self.TestFile('001_invalid.dts')) 497 self.assertIn("FATAL ERROR: Unable to parse input tree", 498 str(e.exception)) 499 500 def testMissingNode(self): 501 """Test that a device tree without a 'binman' node generates an error""" 502 with self.assertRaises(Exception) as e: 503 self._DoBinman('-d', self.TestFile('002_missing_node.dts')) 504 self.assertIn("does not have a 'binman' node", str(e.exception)) 505 506 def testEmpty(self): 507 """Test that an empty binman node works OK (i.e. does nothing)""" 508 result = self._RunBinman('-d', self.TestFile('003_empty.dts')) 509 self.assertEqual(0, len(result.stderr)) 510 self.assertEqual(0, result.return_code) 511 512 def testInvalidEntry(self): 513 """Test that an invalid entry is flagged""" 514 with self.assertRaises(Exception) as e: 515 result = self._RunBinman('-d', 516 self.TestFile('004_invalid_entry.dts')) 517 self.assertIn("Unknown entry type 'not-a-valid-type' in node " 518 "'/binman/not-a-valid-type'", str(e.exception)) 519 520 def testSimple(self): 521 """Test a simple binman with a single file""" 522 data = self._DoReadFile('005_simple.dts') 523 self.assertEqual(U_BOOT_DATA, data) 524 525 def testSimpleDebug(self): 526 """Test a simple binman run with debugging enabled""" 527 data = self._DoTestFile('005_simple.dts', debug=True) 528 529 def testDual(self): 530 """Test that we can handle creating two images 531 532 This also tests image padding. 533 """ 534 retcode = self._DoTestFile('006_dual_image.dts') 535 self.assertEqual(0, retcode) 536 537 image = control.images['image1'] 538 self.assertEqual(len(U_BOOT_DATA), image._size) 539 fname = tools.GetOutputFilename('image1.bin') 540 self.assertTrue(os.path.exists(fname)) 541 with open(fname) as fd: 542 data = fd.read() 543 self.assertEqual(U_BOOT_DATA, data) 544 545 image = control.images['image2'] 546 self.assertEqual(3 + len(U_BOOT_DATA) + 5, image._size) 547 fname = tools.GetOutputFilename('image2.bin') 548 self.assertTrue(os.path.exists(fname)) 549 with open(fname) as fd: 550 data = fd.read() 551 self.assertEqual(U_BOOT_DATA, data[3:7]) 552 self.assertEqual(chr(0) * 3, data[:3]) 553 self.assertEqual(chr(0) * 5, data[7:]) 554 555 def testBadAlign(self): 556 """Test that an invalid alignment value is detected""" 557 with self.assertRaises(ValueError) as e: 558 self._DoTestFile('007_bad_align.dts') 559 self.assertIn("Node '/binman/u-boot': Alignment 23 must be a power " 560 "of two", str(e.exception)) 561 562 def testPackSimple(self): 563 """Test that packing works as expected""" 564 retcode = self._DoTestFile('008_pack.dts') 565 self.assertEqual(0, retcode) 566 self.assertIn('image', control.images) 567 image = control.images['image'] 568 entries = image.GetEntries() 569 self.assertEqual(5, len(entries)) 570 571 # First u-boot 572 self.assertIn('u-boot', entries) 573 entry = entries['u-boot'] 574 self.assertEqual(0, entry.offset) 575 self.assertEqual(len(U_BOOT_DATA), entry.size) 576 577 # Second u-boot, aligned to 16-byte boundary 578 self.assertIn('u-boot-align', entries) 579 entry = entries['u-boot-align'] 580 self.assertEqual(16, entry.offset) 581 self.assertEqual(len(U_BOOT_DATA), entry.size) 582 583 # Third u-boot, size 23 bytes 584 self.assertIn('u-boot-size', entries) 585 entry = entries['u-boot-size'] 586 self.assertEqual(20, entry.offset) 587 self.assertEqual(len(U_BOOT_DATA), entry.contents_size) 588 self.assertEqual(23, entry.size) 589 590 # Fourth u-boot, placed immediate after the above 591 self.assertIn('u-boot-next', entries) 592 entry = entries['u-boot-next'] 593 self.assertEqual(43, entry.offset) 594 self.assertEqual(len(U_BOOT_DATA), entry.size) 595 596 # Fifth u-boot, placed at a fixed offset 597 self.assertIn('u-boot-fixed', entries) 598 entry = entries['u-boot-fixed'] 599 self.assertEqual(61, entry.offset) 600 self.assertEqual(len(U_BOOT_DATA), entry.size) 601 602 self.assertEqual(65, image._size) 603 604 def testPackExtra(self): 605 """Test that extra packing feature works as expected""" 606 retcode = self._DoTestFile('009_pack_extra.dts') 607 608 self.assertEqual(0, retcode) 609 self.assertIn('image', control.images) 610 image = control.images['image'] 611 entries = image.GetEntries() 612 self.assertEqual(5, len(entries)) 613 614 # First u-boot with padding before and after 615 self.assertIn('u-boot', entries) 616 entry = entries['u-boot'] 617 self.assertEqual(0, entry.offset) 618 self.assertEqual(3, entry.pad_before) 619 self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size) 620 621 # Second u-boot has an aligned size, but it has no effect 622 self.assertIn('u-boot-align-size-nop', entries) 623 entry = entries['u-boot-align-size-nop'] 624 self.assertEqual(12, entry.offset) 625 self.assertEqual(4, entry.size) 626 627 # Third u-boot has an aligned size too 628 self.assertIn('u-boot-align-size', entries) 629 entry = entries['u-boot-align-size'] 630 self.assertEqual(16, entry.offset) 631 self.assertEqual(32, entry.size) 632 633 # Fourth u-boot has an aligned end 634 self.assertIn('u-boot-align-end', entries) 635 entry = entries['u-boot-align-end'] 636 self.assertEqual(48, entry.offset) 637 self.assertEqual(16, entry.size) 638 639 # Fifth u-boot immediately afterwards 640 self.assertIn('u-boot-align-both', entries) 641 entry = entries['u-boot-align-both'] 642 self.assertEqual(64, entry.offset) 643 self.assertEqual(64, entry.size) 644 645 self.CheckNoGaps(entries) 646 self.assertEqual(128, image._size) 647 648 def testPackAlignPowerOf2(self): 649 """Test that invalid entry alignment is detected""" 650 with self.assertRaises(ValueError) as e: 651 self._DoTestFile('010_pack_align_power2.dts') 652 self.assertIn("Node '/binman/u-boot': Alignment 5 must be a power " 653 "of two", str(e.exception)) 654 655 def testPackAlignSizePowerOf2(self): 656 """Test that invalid entry size alignment is detected""" 657 with self.assertRaises(ValueError) as e: 658 self._DoTestFile('011_pack_align_size_power2.dts') 659 self.assertIn("Node '/binman/u-boot': Alignment size 55 must be a " 660 "power of two", str(e.exception)) 661 662 def testPackInvalidAlign(self): 663 """Test detection of an offset that does not match its alignment""" 664 with self.assertRaises(ValueError) as e: 665 self._DoTestFile('012_pack_inv_align.dts') 666 self.assertIn("Node '/binman/u-boot': Offset 0x5 (5) does not match " 667 "align 0x4 (4)", str(e.exception)) 668 669 def testPackInvalidSizeAlign(self): 670 """Test that invalid entry size alignment is detected""" 671 with self.assertRaises(ValueError) as e: 672 self._DoTestFile('013_pack_inv_size_align.dts') 673 self.assertIn("Node '/binman/u-boot': Size 0x5 (5) does not match " 674 "align-size 0x4 (4)", str(e.exception)) 675 676 def testPackOverlap(self): 677 """Test that overlapping regions are detected""" 678 with self.assertRaises(ValueError) as e: 679 self._DoTestFile('014_pack_overlap.dts') 680 self.assertIn("Node '/binman/u-boot-align': Offset 0x3 (3) overlaps " 681 "with previous entry '/binman/u-boot' ending at 0x4 (4)", 682 str(e.exception)) 683 684 def testPackEntryOverflow(self): 685 """Test that entries that overflow their size are detected""" 686 with self.assertRaises(ValueError) as e: 687 self._DoTestFile('015_pack_overflow.dts') 688 self.assertIn("Node '/binman/u-boot': Entry contents size is 0x4 (4) " 689 "but entry size is 0x3 (3)", str(e.exception)) 690 691 def testPackImageOverflow(self): 692 """Test that entries which overflow the image size are detected""" 693 with self.assertRaises(ValueError) as e: 694 self._DoTestFile('016_pack_image_overflow.dts') 695 self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section " 696 "size 0x3 (3)", str(e.exception)) 697 698 def testPackImageSize(self): 699 """Test that the image size can be set""" 700 retcode = self._DoTestFile('017_pack_image_size.dts') 701 self.assertEqual(0, retcode) 702 self.assertIn('image', control.images) 703 image = control.images['image'] 704 self.assertEqual(7, image._size) 705 706 def testPackImageSizeAlign(self): 707 """Test that image size alignemnt works as expected""" 708 retcode = self._DoTestFile('018_pack_image_align.dts') 709 self.assertEqual(0, retcode) 710 self.assertIn('image', control.images) 711 image = control.images['image'] 712 self.assertEqual(16, image._size) 713 714 def testPackInvalidImageAlign(self): 715 """Test that invalid image alignment is detected""" 716 with self.assertRaises(ValueError) as e: 717 self._DoTestFile('019_pack_inv_image_align.dts') 718 self.assertIn("Section '/binman': Size 0x7 (7) does not match " 719 "align-size 0x8 (8)", str(e.exception)) 720 721 def testPackAlignPowerOf2(self): 722 """Test that invalid image alignment is detected""" 723 with self.assertRaises(ValueError) as e: 724 self._DoTestFile('020_pack_inv_image_align_power2.dts') 725 self.assertIn("Section '/binman': Alignment size 131 must be a power of " 726 "two", str(e.exception)) 727 728 def testImagePadByte(self): 729 """Test that the image pad byte can be specified""" 730 self._SetupSplElf() 731 data = self._DoReadFile('021_image_pad.dts') 732 self.assertEqual(U_BOOT_SPL_DATA + (chr(0xff) * 1) + U_BOOT_DATA, data) 733 734 def testImageName(self): 735 """Test that image files can be named""" 736 retcode = self._DoTestFile('022_image_name.dts') 737 self.assertEqual(0, retcode) 738 image = control.images['image1'] 739 fname = tools.GetOutputFilename('test-name') 740 self.assertTrue(os.path.exists(fname)) 741 742 image = control.images['image2'] 743 fname = tools.GetOutputFilename('test-name.xx') 744 self.assertTrue(os.path.exists(fname)) 745 746 def testBlobFilename(self): 747 """Test that generic blobs can be provided by filename""" 748 data = self._DoReadFile('023_blob.dts') 749 self.assertEqual(BLOB_DATA, data) 750 751 def testPackSorted(self): 752 """Test that entries can be sorted""" 753 self._SetupSplElf() 754 data = self._DoReadFile('024_sorted.dts') 755 self.assertEqual(chr(0) * 1 + U_BOOT_SPL_DATA + chr(0) * 2 + 756 U_BOOT_DATA, data) 757 758 def testPackZeroOffset(self): 759 """Test that an entry at offset 0 is not given a new offset""" 760 with self.assertRaises(ValueError) as e: 761 self._DoTestFile('025_pack_zero_size.dts') 762 self.assertIn("Node '/binman/u-boot-spl': Offset 0x0 (0) overlaps " 763 "with previous entry '/binman/u-boot' ending at 0x4 (4)", 764 str(e.exception)) 765 766 def testPackUbootDtb(self): 767 """Test that a device tree can be added to U-Boot""" 768 data = self._DoReadFile('026_pack_u_boot_dtb.dts') 769 self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA, data) 770 771 def testPackX86RomNoSize(self): 772 """Test that the end-at-4gb property requires a size property""" 773 with self.assertRaises(ValueError) as e: 774 self._DoTestFile('027_pack_4gb_no_size.dts') 775 self.assertIn("Section '/binman': Section size must be provided when " 776 "using end-at-4gb", str(e.exception)) 777 778 def test4gbAndSkipAtStartTogether(self): 779 """Test that the end-at-4gb and skip-at-size property can't be used 780 together""" 781 with self.assertRaises(ValueError) as e: 782 self._DoTestFile('80_4gb_and_skip_at_start_together.dts') 783 self.assertIn("Section '/binman': Provide either 'end-at-4gb' or " 784 "'skip-at-start'", str(e.exception)) 785 786 def testPackX86RomOutside(self): 787 """Test that the end-at-4gb property checks for offset boundaries""" 788 with self.assertRaises(ValueError) as e: 789 self._DoTestFile('028_pack_4gb_outside.dts') 790 self.assertIn("Node '/binman/u-boot': Offset 0x0 (0) is outside " 791 "the section starting at 0xffffffe0 (4294967264)", 792 str(e.exception)) 793 794 def testPackX86Rom(self): 795 """Test that a basic x86 ROM can be created""" 796 self._SetupSplElf() 797 data = self._DoReadFile('029_x86-rom.dts') 798 self.assertEqual(U_BOOT_DATA + chr(0) * 7 + U_BOOT_SPL_DATA + 799 chr(0) * 2, data) 800 801 def testPackX86RomMeNoDesc(self): 802 """Test that an invalid Intel descriptor entry is detected""" 803 TestFunctional._MakeInputFile('descriptor.bin', '') 804 with self.assertRaises(ValueError) as e: 805 self._DoTestFile('031_x86-rom-me.dts') 806 self.assertIn("Node '/binman/intel-descriptor': Cannot find FD " 807 "signature", str(e.exception)) 808 809 def testPackX86RomBadDesc(self): 810 """Test that the Intel requires a descriptor entry""" 811 with self.assertRaises(ValueError) as e: 812 self._DoTestFile('030_x86-rom-me-no-desc.dts') 813 self.assertIn("Node '/binman/intel-me': No offset set with " 814 "offset-unset: should another entry provide this correct " 815 "offset?", str(e.exception)) 816 817 def testPackX86RomMe(self): 818 """Test that an x86 ROM with an ME region can be created""" 819 data = self._DoReadFile('031_x86-rom-me.dts') 820 self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)]) 821 822 def testPackVga(self): 823 """Test that an image with a VGA binary can be created""" 824 data = self._DoReadFile('032_intel-vga.dts') 825 self.assertEqual(VGA_DATA, data[:len(VGA_DATA)]) 826 827 def testPackStart16(self): 828 """Test that an image with an x86 start16 region can be created""" 829 data = self._DoReadFile('033_x86-start16.dts') 830 self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)]) 831 832 def testPackPowerpcMpc85xxBootpgResetvec(self): 833 """Test that an image with powerpc-mpc85xx-bootpg-resetvec can be 834 created""" 835 data = self._DoReadFile('81_powerpc_mpc85xx_bootpg_resetvec.dts') 836 self.assertEqual(PPC_MPC85XX_BR_DATA, data[:len(PPC_MPC85XX_BR_DATA)]) 837 838 def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False): 839 """Handle running a test for insertion of microcode 840 841 Args: 842 dts_fname: Name of test .dts file 843 nodtb_data: Data that we expect in the first section 844 ucode_second: True if the microsecond entry is second instead of 845 third 846 847 Returns: 848 Tuple: 849 Contents of first region (U-Boot or SPL) 850 Offset and size components of microcode pointer, as inserted 851 in the above (two 4-byte words) 852 """ 853 data = self._DoReadFile(dts_fname, True) 854 855 # Now check the device tree has no microcode 856 if ucode_second: 857 ucode_content = data[len(nodtb_data):] 858 ucode_pos = len(nodtb_data) 859 dtb_with_ucode = ucode_content[16:] 860 fdt_len = self.GetFdtLen(dtb_with_ucode) 861 else: 862 dtb_with_ucode = data[len(nodtb_data):] 863 fdt_len = self.GetFdtLen(dtb_with_ucode) 864 ucode_content = dtb_with_ucode[fdt_len:] 865 ucode_pos = len(nodtb_data) + fdt_len 866 fname = tools.GetOutputFilename('test.dtb') 867 with open(fname, 'wb') as fd: 868 fd.write(dtb_with_ucode) 869 dtb = fdt.FdtScan(fname) 870 ucode = dtb.GetNode('/microcode') 871 self.assertTrue(ucode) 872 for node in ucode.subnodes: 873 self.assertFalse(node.props.get('data')) 874 875 # Check that the microcode appears immediately after the Fdt 876 # This matches the concatenation of the data properties in 877 # the /microcode/update@xxx nodes in 34_x86_ucode.dts. 878 ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 879 0x78235609) 880 self.assertEqual(ucode_data, ucode_content[:len(ucode_data)]) 881 882 # Check that the microcode pointer was inserted. It should match the 883 # expected offset and size 884 pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos, 885 len(ucode_data)) 886 u_boot = data[:len(nodtb_data)] 887 return u_boot, pos_and_size 888 889 def testPackUbootMicrocode(self): 890 """Test that x86 microcode can be handled correctly 891 892 We expect to see the following in the image, in order: 893 u-boot-nodtb.bin with a microcode pointer inserted at the correct 894 place 895 u-boot.dtb with the microcode removed 896 the microcode 897 """ 898 first, pos_and_size = self._RunMicrocodeTest('034_x86_ucode.dts', 899 U_BOOT_NODTB_DATA) 900 self.assertEqual('nodtb with microcode' + pos_and_size + 901 ' somewhere in here', first) 902 903 def _RunPackUbootSingleMicrocode(self): 904 """Test that x86 microcode can be handled correctly 905 906 We expect to see the following in the image, in order: 907 u-boot-nodtb.bin with a microcode pointer inserted at the correct 908 place 909 u-boot.dtb with the microcode 910 an empty microcode region 911 """ 912 # We need the libfdt library to run this test since only that allows 913 # finding the offset of a property. This is required by 914 # Entry_u_boot_dtb_with_ucode.ObtainContents(). 915 data = self._DoReadFile('035_x86_single_ucode.dts', True) 916 917 second = data[len(U_BOOT_NODTB_DATA):] 918 919 fdt_len = self.GetFdtLen(second) 920 third = second[fdt_len:] 921 second = second[:fdt_len] 922 923 ucode_data = struct.pack('>2L', 0x12345678, 0x12345679) 924 self.assertIn(ucode_data, second) 925 ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA) 926 927 # Check that the microcode pointer was inserted. It should match the 928 # expected offset and size 929 pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos, 930 len(ucode_data)) 931 first = data[:len(U_BOOT_NODTB_DATA)] 932 self.assertEqual('nodtb with microcode' + pos_and_size + 933 ' somewhere in here', first) 934 935 def testPackUbootSingleMicrocode(self): 936 """Test that x86 microcode can be handled correctly with fdt_normal. 937 """ 938 self._RunPackUbootSingleMicrocode() 939 940 def testUBootImg(self): 941 """Test that u-boot.img can be put in a file""" 942 data = self._DoReadFile('036_u_boot_img.dts') 943 self.assertEqual(U_BOOT_IMG_DATA, data) 944 945 def testNoMicrocode(self): 946 """Test that a missing microcode region is detected""" 947 with self.assertRaises(ValueError) as e: 948 self._DoReadFile('037_x86_no_ucode.dts', True) 949 self.assertIn("Node '/binman/u-boot-dtb-with-ucode': No /microcode " 950 "node found in ", str(e.exception)) 951 952 def testMicrocodeWithoutNode(self): 953 """Test that a missing u-boot-dtb-with-ucode node is detected""" 954 with self.assertRaises(ValueError) as e: 955 self._DoReadFile('038_x86_ucode_missing_node.dts', True) 956 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find " 957 "microcode region u-boot-dtb-with-ucode", str(e.exception)) 958 959 def testMicrocodeWithoutNode2(self): 960 """Test that a missing u-boot-ucode node is detected""" 961 with self.assertRaises(ValueError) as e: 962 self._DoReadFile('039_x86_ucode_missing_node2.dts', True) 963 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find " 964 "microcode region u-boot-ucode", str(e.exception)) 965 966 def testMicrocodeWithoutPtrInElf(self): 967 """Test that a U-Boot binary without the microcode symbol is detected""" 968 # ELF file without a '_dt_ucode_base_size' symbol 969 try: 970 with open(self.TestFile('u_boot_no_ucode_ptr')) as fd: 971 TestFunctional._MakeInputFile('u-boot', fd.read()) 972 973 with self.assertRaises(ValueError) as e: 974 self._RunPackUbootSingleMicrocode() 975 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate " 976 "_dt_ucode_base_size symbol in u-boot", str(e.exception)) 977 978 finally: 979 # Put the original file back 980 with open(self.TestFile('u_boot_ucode_ptr')) as fd: 981 TestFunctional._MakeInputFile('u-boot', fd.read()) 982 983 def testMicrocodeNotInImage(self): 984 """Test that microcode must be placed within the image""" 985 with self.assertRaises(ValueError) as e: 986 self._DoReadFile('040_x86_ucode_not_in_image.dts', True) 987 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode " 988 "pointer _dt_ucode_base_size at fffffe14 is outside the " 989 "section ranging from 00000000 to 0000002e", str(e.exception)) 990 991 def testWithoutMicrocode(self): 992 """Test that we can cope with an image without microcode (e.g. qemu)""" 993 with open(self.TestFile('u_boot_no_ucode_ptr')) as fd: 994 TestFunctional._MakeInputFile('u-boot', fd.read()) 995 data, dtb, _, _ = self._DoReadFileDtb('044_x86_optional_ucode.dts', True) 996 997 # Now check the device tree has no microcode 998 self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)]) 999 second = data[len(U_BOOT_NODTB_DATA):] 1000 1001 fdt_len = self.GetFdtLen(second) 1002 self.assertEqual(dtb, second[:fdt_len]) 1003 1004 used_len = len(U_BOOT_NODTB_DATA) + fdt_len 1005 third = data[used_len:] 1006 self.assertEqual(chr(0) * (0x200 - used_len), third) 1007 1008 def testUnknownPosSize(self): 1009 """Test that microcode must be placed within the image""" 1010 with self.assertRaises(ValueError) as e: 1011 self._DoReadFile('041_unknown_pos_size.dts', True) 1012 self.assertIn("Section '/binman': Unable to set offset/size for unknown " 1013 "entry 'invalid-entry'", str(e.exception)) 1014 1015 def testPackFsp(self): 1016 """Test that an image with a FSP binary can be created""" 1017 data = self._DoReadFile('042_intel-fsp.dts') 1018 self.assertEqual(FSP_DATA, data[:len(FSP_DATA)]) 1019 1020 def testPackCmc(self): 1021 """Test that an image with a CMC binary can be created""" 1022 data = self._DoReadFile('043_intel-cmc.dts') 1023 self.assertEqual(CMC_DATA, data[:len(CMC_DATA)]) 1024 1025 def testPackVbt(self): 1026 """Test that an image with a VBT binary can be created""" 1027 data = self._DoReadFile('046_intel-vbt.dts') 1028 self.assertEqual(VBT_DATA, data[:len(VBT_DATA)]) 1029 1030 def testSplBssPad(self): 1031 """Test that we can pad SPL's BSS with zeros""" 1032 # ELF file with a '__bss_size' symbol 1033 self._SetupSplElf() 1034 data = self._DoReadFile('047_spl_bss_pad.dts') 1035 self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data) 1036 1037 def testSplBssPadMissing(self): 1038 """Test that a missing symbol is detected""" 1039 self._SetupSplElf('u_boot_ucode_ptr') 1040 with self.assertRaises(ValueError) as e: 1041 self._DoReadFile('047_spl_bss_pad.dts') 1042 self.assertIn('Expected __bss_size symbol in spl/u-boot-spl', 1043 str(e.exception)) 1044 1045 def testPackStart16Spl(self): 1046 """Test that an image with an x86 start16 SPL region can be created""" 1047 data = self._DoReadFile('048_x86-start16-spl.dts') 1048 self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)]) 1049 1050 def _PackUbootSplMicrocode(self, dts, ucode_second=False): 1051 """Helper function for microcode tests 1052 1053 We expect to see the following in the image, in order: 1054 u-boot-spl-nodtb.bin with a microcode pointer inserted at the 1055 correct place 1056 u-boot.dtb with the microcode removed 1057 the microcode 1058 1059 Args: 1060 dts: Device tree file to use for test 1061 ucode_second: True if the microsecond entry is second instead of 1062 third 1063 """ 1064 self._SetupSplElf('u_boot_ucode_ptr') 1065 first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA, 1066 ucode_second=ucode_second) 1067 self.assertEqual('splnodtb with microc' + pos_and_size + 1068 'ter somewhere in here', first) 1069 1070 def testPackUbootSplMicrocode(self): 1071 """Test that x86 microcode can be handled correctly in SPL""" 1072 self._PackUbootSplMicrocode('049_x86_ucode_spl.dts') 1073 1074 def testPackUbootSplMicrocodeReorder(self): 1075 """Test that order doesn't matter for microcode entries 1076 1077 This is the same as testPackUbootSplMicrocode but when we process the 1078 u-boot-ucode entry we have not yet seen the u-boot-dtb-with-ucode 1079 entry, so we reply on binman to try later. 1080 """ 1081 self._PackUbootSplMicrocode('058_x86_ucode_spl_needs_retry.dts', 1082 ucode_second=True) 1083 1084 def testPackMrc(self): 1085 """Test that an image with an MRC binary can be created""" 1086 data = self._DoReadFile('050_intel_mrc.dts') 1087 self.assertEqual(MRC_DATA, data[:len(MRC_DATA)]) 1088 1089 def testSplDtb(self): 1090 """Test that an image with spl/u-boot-spl.dtb can be created""" 1091 data = self._DoReadFile('051_u_boot_spl_dtb.dts') 1092 self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)]) 1093 1094 def testSplNoDtb(self): 1095 """Test that an image with spl/u-boot-spl-nodtb.bin can be created""" 1096 data = self._DoReadFile('052_u_boot_spl_nodtb.dts') 1097 self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)]) 1098 1099 def testSymbols(self): 1100 """Test binman can assign symbols embedded in U-Boot""" 1101 elf_fname = self.TestFile('u_boot_binman_syms') 1102 syms = elf.GetSymbols(elf_fname, ['binman', 'image']) 1103 addr = elf.GetSymbolAddress(elf_fname, '__image_copy_start') 1104 self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr) 1105 1106 self._SetupSplElf('u_boot_binman_syms') 1107 data = self._DoReadFile('053_symbols.dts') 1108 sym_values = struct.pack('<LQL', 0x24 + 0, 0x24 + 24, 0x24 + 20) 1109 expected = (sym_values + U_BOOT_SPL_DATA[16:] + chr(0xff) + 1110 U_BOOT_DATA + 1111 sym_values + U_BOOT_SPL_DATA[16:]) 1112 self.assertEqual(expected, data) 1113 1114 def testPackUnitAddress(self): 1115 """Test that we support multiple binaries with the same name""" 1116 data = self._DoReadFile('054_unit_address.dts') 1117 self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data) 1118 1119 def testSections(self): 1120 """Basic test of sections""" 1121 data = self._DoReadFile('055_sections.dts') 1122 expected = (U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 + 1123 U_BOOT_DATA + '&' * 4) 1124 self.assertEqual(expected, data) 1125 1126 def testMap(self): 1127 """Tests outputting a map of the images""" 1128 _, _, map_data, _ = self._DoReadFileDtb('055_sections.dts', map=True) 1129 self.assertEqual('''ImagePos Offset Size Name 113000000000 00000000 00000028 main-section 113100000000 00000000 00000010 section@0 113200000000 00000000 00000004 u-boot 113300000010 00000010 00000010 section@1 113400000010 00000000 00000004 u-boot 113500000020 00000020 00000004 section@2 113600000020 00000000 00000004 u-boot 1137''', map_data) 1138 1139 def testNamePrefix(self): 1140 """Tests that name prefixes are used""" 1141 _, _, map_data, _ = self._DoReadFileDtb('056_name_prefix.dts', map=True) 1142 self.assertEqual('''ImagePos Offset Size Name 114300000000 00000000 00000028 main-section 114400000000 00000000 00000010 section@0 114500000000 00000000 00000004 ro-u-boot 114600000010 00000010 00000010 section@1 114700000010 00000000 00000004 rw-u-boot 1148''', map_data) 1149 1150 def testUnknownContents(self): 1151 """Test that obtaining the contents works as expected""" 1152 with self.assertRaises(ValueError) as e: 1153 self._DoReadFile('057_unknown_contents.dts', True) 1154 self.assertIn("Section '/binman': Internal error: Could not complete " 1155 "processing of contents: remaining [<_testing.Entry__testing ", 1156 str(e.exception)) 1157 1158 def testBadChangeSize(self): 1159 """Test that trying to change the size of an entry fails""" 1160 with self.assertRaises(ValueError) as e: 1161 self._DoReadFile('059_change_size.dts', True) 1162 self.assertIn("Node '/binman/_testing': Cannot update entry size from " 1163 '2 to 1', str(e.exception)) 1164 1165 def testUpdateFdt(self): 1166 """Test that we can update the device tree with offset/size info""" 1167 _, _, _, out_dtb_fname = self._DoReadFileDtb('060_fdt_update.dts', 1168 update_dtb=True) 1169 dtb = fdt.Fdt(out_dtb_fname) 1170 dtb.Scan() 1171 props = self._GetPropTree(dtb, ['offset', 'size', 'image-pos']) 1172 self.assertEqual({ 1173 'image-pos': 0, 1174 'offset': 0, 1175 '_testing:offset': 32, 1176 '_testing:size': 1, 1177 '_testing:image-pos': 32, 1178 'section@0/u-boot:offset': 0, 1179 'section@0/u-boot:size': len(U_BOOT_DATA), 1180 'section@0/u-boot:image-pos': 0, 1181 'section@0:offset': 0, 1182 'section@0:size': 16, 1183 'section@0:image-pos': 0, 1184 1185 'section@1/u-boot:offset': 0, 1186 'section@1/u-boot:size': len(U_BOOT_DATA), 1187 'section@1/u-boot:image-pos': 16, 1188 'section@1:offset': 16, 1189 'section@1:size': 16, 1190 'section@1:image-pos': 16, 1191 'size': 40 1192 }, props) 1193 1194 def testUpdateFdtBad(self): 1195 """Test that we detect when ProcessFdt never completes""" 1196 with self.assertRaises(ValueError) as e: 1197 self._DoReadFileDtb('061_fdt_update_bad.dts', update_dtb=True) 1198 self.assertIn('Could not complete processing of Fdt: remaining ' 1199 '[<_testing.Entry__testing', str(e.exception)) 1200 1201 def testEntryArgs(self): 1202 """Test passing arguments to entries from the command line""" 1203 entry_args = { 1204 'test-str-arg': 'test1', 1205 'test-int-arg': '456', 1206 } 1207 self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args) 1208 self.assertIn('image', control.images) 1209 entry = control.images['image'].GetEntries()['_testing'] 1210 self.assertEqual('test0', entry.test_str_fdt) 1211 self.assertEqual('test1', entry.test_str_arg) 1212 self.assertEqual(123, entry.test_int_fdt) 1213 self.assertEqual(456, entry.test_int_arg) 1214 1215 def testEntryArgsMissing(self): 1216 """Test missing arguments and properties""" 1217 entry_args = { 1218 'test-int-arg': '456', 1219 } 1220 self._DoReadFileDtb('063_entry_args_missing.dts', entry_args=entry_args) 1221 entry = control.images['image'].GetEntries()['_testing'] 1222 self.assertEqual('test0', entry.test_str_fdt) 1223 self.assertEqual(None, entry.test_str_arg) 1224 self.assertEqual(None, entry.test_int_fdt) 1225 self.assertEqual(456, entry.test_int_arg) 1226 1227 def testEntryArgsRequired(self): 1228 """Test missing arguments and properties""" 1229 entry_args = { 1230 'test-int-arg': '456', 1231 } 1232 with self.assertRaises(ValueError) as e: 1233 self._DoReadFileDtb('064_entry_args_required.dts') 1234 self.assertIn("Node '/binman/_testing': Missing required " 1235 'properties/entry args: test-str-arg, test-int-fdt, test-int-arg', 1236 str(e.exception)) 1237 1238 def testEntryArgsInvalidFormat(self): 1239 """Test that an invalid entry-argument format is detected""" 1240 args = ['-d', self.TestFile('064_entry_args_required.dts'), '-ano-value'] 1241 with self.assertRaises(ValueError) as e: 1242 self._DoBinman(*args) 1243 self.assertIn("Invalid entry arguemnt 'no-value'", str(e.exception)) 1244 1245 def testEntryArgsInvalidInteger(self): 1246 """Test that an invalid entry-argument integer is detected""" 1247 entry_args = { 1248 'test-int-arg': 'abc', 1249 } 1250 with self.assertRaises(ValueError) as e: 1251 self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args) 1252 self.assertIn("Node '/binman/_testing': Cannot convert entry arg " 1253 "'test-int-arg' (value 'abc') to integer", 1254 str(e.exception)) 1255 1256 def testEntryArgsInvalidDatatype(self): 1257 """Test that an invalid entry-argument datatype is detected 1258 1259 This test could be written in entry_test.py except that it needs 1260 access to control.entry_args, which seems more than that module should 1261 be able to see. 1262 """ 1263 entry_args = { 1264 'test-bad-datatype-arg': '12', 1265 } 1266 with self.assertRaises(ValueError) as e: 1267 self._DoReadFileDtb('065_entry_args_unknown_datatype.dts', 1268 entry_args=entry_args) 1269 self.assertIn('GetArg() internal error: Unknown data type ', 1270 str(e.exception)) 1271 1272 def testText(self): 1273 """Test for a text entry type""" 1274 entry_args = { 1275 'test-id': TEXT_DATA, 1276 'test-id2': TEXT_DATA2, 1277 'test-id3': TEXT_DATA3, 1278 } 1279 data, _, _, _ = self._DoReadFileDtb('066_text.dts', 1280 entry_args=entry_args) 1281 expected = (TEXT_DATA + chr(0) * (8 - len(TEXT_DATA)) + TEXT_DATA2 + 1282 TEXT_DATA3 + 'some text') 1283 self.assertEqual(expected, data) 1284 1285 def testEntryDocs(self): 1286 """Test for creation of entry documentation""" 1287 with test_util.capture_sys_output() as (stdout, stderr): 1288 control.WriteEntryDocs(binman.GetEntryModules()) 1289 self.assertTrue(len(stdout.getvalue()) > 0) 1290 1291 def testEntryDocsMissing(self): 1292 """Test handling of missing entry documentation""" 1293 with self.assertRaises(ValueError) as e: 1294 with test_util.capture_sys_output() as (stdout, stderr): 1295 control.WriteEntryDocs(binman.GetEntryModules(), 'u_boot') 1296 self.assertIn('Documentation is missing for modules: u_boot', 1297 str(e.exception)) 1298 1299 def testFmap(self): 1300 """Basic test of generation of a flashrom fmap""" 1301 data = self._DoReadFile('067_fmap.dts') 1302 fhdr, fentries = fmap_util.DecodeFmap(data[32:]) 1303 expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 1304 self.assertEqual(expected, data[:32]) 1305 self.assertEqual('__FMAP__', fhdr.signature) 1306 self.assertEqual(1, fhdr.ver_major) 1307 self.assertEqual(0, fhdr.ver_minor) 1308 self.assertEqual(0, fhdr.base) 1309 self.assertEqual(16 + 16 + 1310 fmap_util.FMAP_HEADER_LEN + 1311 fmap_util.FMAP_AREA_LEN * 3, fhdr.image_size) 1312 self.assertEqual('FMAP', fhdr.name) 1313 self.assertEqual(3, fhdr.nareas) 1314 for fentry in fentries: 1315 self.assertEqual(0, fentry.flags) 1316 1317 self.assertEqual(0, fentries[0].offset) 1318 self.assertEqual(4, fentries[0].size) 1319 self.assertEqual('RO_U_BOOT', fentries[0].name) 1320 1321 self.assertEqual(16, fentries[1].offset) 1322 self.assertEqual(4, fentries[1].size) 1323 self.assertEqual('RW_U_BOOT', fentries[1].name) 1324 1325 self.assertEqual(32, fentries[2].offset) 1326 self.assertEqual(fmap_util.FMAP_HEADER_LEN + 1327 fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) 1328 self.assertEqual('FMAP', fentries[2].name) 1329 1330 def testBlobNamedByArg(self): 1331 """Test we can add a blob with the filename coming from an entry arg""" 1332 entry_args = { 1333 'cros-ec-rw-path': 'ecrw.bin', 1334 } 1335 data, _, _, _ = self._DoReadFileDtb('068_blob_named_by_arg.dts', 1336 entry_args=entry_args) 1337 1338 def testFill(self): 1339 """Test for an fill entry type""" 1340 data = self._DoReadFile('069_fill.dts') 1341 expected = 8 * chr(0xff) + 8 * chr(0) 1342 self.assertEqual(expected, data) 1343 1344 def testFillNoSize(self): 1345 """Test for an fill entry type with no size""" 1346 with self.assertRaises(ValueError) as e: 1347 self._DoReadFile('070_fill_no_size.dts') 1348 self.assertIn("'fill' entry must have a size property", 1349 str(e.exception)) 1350 1351 def _HandleGbbCommand(self, pipe_list): 1352 """Fake calls to the futility utility""" 1353 if pipe_list[0][0] == 'futility': 1354 fname = pipe_list[0][-1] 1355 # Append our GBB data to the file, which will happen every time the 1356 # futility command is called. 1357 with open(fname, 'a') as fd: 1358 fd.write(GBB_DATA) 1359 return command.CommandResult() 1360 1361 def testGbb(self): 1362 """Test for the Chromium OS Google Binary Block""" 1363 command.test_result = self._HandleGbbCommand 1364 entry_args = { 1365 'keydir': 'devkeys', 1366 'bmpblk': 'bmpblk.bin', 1367 } 1368 data, _, _, _ = self._DoReadFileDtb('071_gbb.dts', entry_args=entry_args) 1369 1370 # Since futility 1371 expected = GBB_DATA + GBB_DATA + 8 * chr(0) + (0x2180 - 16) * chr(0) 1372 self.assertEqual(expected, data) 1373 1374 def testGbbTooSmall(self): 1375 """Test for the Chromium OS Google Binary Block being large enough""" 1376 with self.assertRaises(ValueError) as e: 1377 self._DoReadFileDtb('072_gbb_too_small.dts') 1378 self.assertIn("Node '/binman/gbb': GBB is too small", 1379 str(e.exception)) 1380 1381 def testGbbNoSize(self): 1382 """Test for the Chromium OS Google Binary Block having a size""" 1383 with self.assertRaises(ValueError) as e: 1384 self._DoReadFileDtb('073_gbb_no_size.dts') 1385 self.assertIn("Node '/binman/gbb': GBB must have a fixed size", 1386 str(e.exception)) 1387 1388 def _HandleVblockCommand(self, pipe_list): 1389 """Fake calls to the futility utility""" 1390 if pipe_list[0][0] == 'futility': 1391 fname = pipe_list[0][3] 1392 with open(fname, 'wb') as fd: 1393 fd.write(VBLOCK_DATA) 1394 return command.CommandResult() 1395 1396 def testVblock(self): 1397 """Test for the Chromium OS Verified Boot Block""" 1398 command.test_result = self._HandleVblockCommand 1399 entry_args = { 1400 'keydir': 'devkeys', 1401 } 1402 data, _, _, _ = self._DoReadFileDtb('074_vblock.dts', 1403 entry_args=entry_args) 1404 expected = U_BOOT_DATA + VBLOCK_DATA + U_BOOT_DTB_DATA 1405 self.assertEqual(expected, data) 1406 1407 def testVblockNoContent(self): 1408 """Test we detect a vblock which has no content to sign""" 1409 with self.assertRaises(ValueError) as e: 1410 self._DoReadFile('075_vblock_no_content.dts') 1411 self.assertIn("Node '/binman/vblock': Vblock must have a 'content' " 1412 'property', str(e.exception)) 1413 1414 def testVblockBadPhandle(self): 1415 """Test that we detect a vblock with an invalid phandle in contents""" 1416 with self.assertRaises(ValueError) as e: 1417 self._DoReadFile('076_vblock_bad_phandle.dts') 1418 self.assertIn("Node '/binman/vblock': Cannot find node for phandle " 1419 '1000', str(e.exception)) 1420 1421 def testVblockBadEntry(self): 1422 """Test that we detect an entry that points to a non-entry""" 1423 with self.assertRaises(ValueError) as e: 1424 self._DoReadFile('077_vblock_bad_entry.dts') 1425 self.assertIn("Node '/binman/vblock': Cannot find entry for node " 1426 "'other'", str(e.exception)) 1427 1428 def testTpl(self): 1429 """Test that an image with TPL and ots device tree can be created""" 1430 # ELF file with a '__bss_size' symbol 1431 with open(self.TestFile('bss_data')) as fd: 1432 TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read()) 1433 data = self._DoReadFile('078_u_boot_tpl.dts') 1434 self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data) 1435 1436 def testUsesPos(self): 1437 """Test that the 'pos' property cannot be used anymore""" 1438 with self.assertRaises(ValueError) as e: 1439 data = self._DoReadFile('079_uses_pos.dts') 1440 self.assertIn("Node '/binman/u-boot': Please use 'offset' instead of " 1441 "'pos'", str(e.exception)) 1442 1443 def testFillZero(self): 1444 """Test for an fill entry type with a size of 0""" 1445 data = self._DoReadFile('080_fill_empty.dts') 1446 self.assertEqual(chr(0) * 16, data) 1447 1448 def testTextMissing(self): 1449 """Test for a text entry type where there is no text""" 1450 with self.assertRaises(ValueError) as e: 1451 self._DoReadFileDtb('066_text.dts',) 1452 self.assertIn("Node '/binman/text': No value provided for text label " 1453 "'test-id'", str(e.exception)) 1454 1455 def testPackStart16Tpl(self): 1456 """Test that an image with an x86 start16 TPL region can be created""" 1457 data = self._DoReadFile('081_x86-start16-tpl.dts') 1458 self.assertEqual(X86_START16_TPL_DATA, data[:len(X86_START16_TPL_DATA)]) 1459 1460 def testSelectImage(self): 1461 """Test that we can select which images to build""" 1462 with test_util.capture_sys_output() as (stdout, stderr): 1463 retcode = self._DoTestFile('006_dual_image.dts', images=['image2']) 1464 self.assertEqual(0, retcode) 1465 self.assertIn('Skipping images: image1', stdout.getvalue()) 1466 1467 self.assertFalse(os.path.exists(tools.GetOutputFilename('image1.bin'))) 1468 self.assertTrue(os.path.exists(tools.GetOutputFilename('image2.bin'))) 1469 1470 def testUpdateFdtAll(self): 1471 """Test that all device trees are updated with offset/size info""" 1472 data, _, _, _ = self._DoReadFileDtb('082_fdt_update_all.dts', 1473 use_real_dtb=True, update_dtb=True) 1474 1475 base_expected = { 1476 'section:image-pos': 0, 1477 'u-boot-tpl-dtb:size': 513, 1478 'u-boot-spl-dtb:size': 513, 1479 'u-boot-spl-dtb:offset': 493, 1480 'image-pos': 0, 1481 'section/u-boot-dtb:image-pos': 0, 1482 'u-boot-spl-dtb:image-pos': 493, 1483 'section/u-boot-dtb:size': 493, 1484 'u-boot-tpl-dtb:image-pos': 1006, 1485 'section/u-boot-dtb:offset': 0, 1486 'section:size': 493, 1487 'offset': 0, 1488 'section:offset': 0, 1489 'u-boot-tpl-dtb:offset': 1006, 1490 'size': 1519 1491 } 1492 1493 # We expect three device-tree files in the output, one after the other. 1494 # Read them in sequence. We look for an 'spl' property in the SPL tree, 1495 # and 'tpl' in the TPL tree, to make sure they are distinct from the 1496 # main U-Boot tree. All three should have the same postions and offset. 1497 start = 0 1498 for item in ['', 'spl', 'tpl']: 1499 dtb = fdt.Fdt.FromData(data[start:]) 1500 dtb.Scan() 1501 props = self._GetPropTree(dtb, ['offset', 'size', 'image-pos', 1502 'spl', 'tpl']) 1503 expected = dict(base_expected) 1504 if item: 1505 expected[item] = 0 1506 self.assertEqual(expected, props) 1507 start += dtb._fdt_obj.totalsize() 1508 1509 def testUpdateFdtOutput(self): 1510 """Test that output DTB files are updated""" 1511 try: 1512 data, dtb_data, _, _ = self._DoReadFileDtb('082_fdt_update_all.dts', 1513 use_real_dtb=True, update_dtb=True, reset_dtbs=False) 1514 1515 # Unfortunately, compiling a source file always results in a file 1516 # called source.dtb (see fdt_util.EnsureCompiled()). The test 1517 # source file (e.g. test/075_fdt_update_all.dts) thus does not enter 1518 # binman as a file called u-boot.dtb. To fix this, copy the file 1519 # over to the expected place. 1520 #tools.WriteFile(os.path.join(self._indir, 'u-boot.dtb'), 1521 #tools.ReadFile(tools.GetOutputFilename('source.dtb'))) 1522 start = 0 1523 for fname in ['u-boot.dtb.out', 'spl/u-boot-spl.dtb.out', 1524 'tpl/u-boot-tpl.dtb.out']: 1525 dtb = fdt.Fdt.FromData(data[start:]) 1526 size = dtb._fdt_obj.totalsize() 1527 pathname = tools.GetOutputFilename(os.path.split(fname)[1]) 1528 outdata = tools.ReadFile(pathname) 1529 name = os.path.split(fname)[0] 1530 1531 if name: 1532 orig_indata = self._GetDtbContentsForSplTpl(dtb_data, name) 1533 else: 1534 orig_indata = dtb_data 1535 self.assertNotEqual(outdata, orig_indata, 1536 "Expected output file '%s' be updated" % pathname) 1537 self.assertEqual(outdata, data[start:start + size], 1538 "Expected output file '%s' to match output image" % 1539 pathname) 1540 start += size 1541 finally: 1542 self._ResetDtbs() 1543 1544 def _decompress(self, data): 1545 out = os.path.join(self._indir, 'lz4.tmp') 1546 with open(out, 'wb') as fd: 1547 fd.write(data) 1548 return tools.Run('lz4', '-dc', out) 1549 ''' 1550 try: 1551 orig = lz4.frame.decompress(data) 1552 except AttributeError: 1553 orig = lz4.decompress(data) 1554 ''' 1555 1556 def testCompress(self): 1557 """Test compression of blobs""" 1558 data, _, _, out_dtb_fname = self._DoReadFileDtb('083_compress.dts', 1559 use_real_dtb=True, update_dtb=True) 1560 dtb = fdt.Fdt(out_dtb_fname) 1561 dtb.Scan() 1562 props = self._GetPropTree(dtb, ['size', 'uncomp-size']) 1563 orig = self._decompress(data) 1564 self.assertEquals(COMPRESS_DATA, orig) 1565 expected = { 1566 'blob:uncomp-size': len(COMPRESS_DATA), 1567 'blob:size': len(data), 1568 'size': len(data), 1569 } 1570 self.assertEqual(expected, props) 1571 1572 def testFiles(self): 1573 """Test bringing in multiple files""" 1574 data = self._DoReadFile('084_files.dts') 1575 self.assertEqual(FILES_DATA, data) 1576 1577 def testFilesCompress(self): 1578 """Test bringing in multiple files and compressing them""" 1579 data = self._DoReadFile('085_files_compress.dts') 1580 1581 image = control.images['image'] 1582 entries = image.GetEntries() 1583 files = entries['files'] 1584 entries = files._section._entries 1585 1586 orig = '' 1587 for i in range(1, 3): 1588 key = '%d.dat' % i 1589 start = entries[key].image_pos 1590 len = entries[key].size 1591 chunk = data[start:start + len] 1592 orig += self._decompress(chunk) 1593 1594 self.assertEqual(FILES_DATA, orig) 1595 1596 def testFilesMissing(self): 1597 """Test missing files""" 1598 with self.assertRaises(ValueError) as e: 1599 data = self._DoReadFile('086_files_none.dts') 1600 self.assertIn("Node '/binman/files': Pattern \'files/*.none\' matched " 1601 'no files', str(e.exception)) 1602 1603 def testFilesNoPattern(self): 1604 """Test missing files""" 1605 with self.assertRaises(ValueError) as e: 1606 data = self._DoReadFile('087_files_no_pattern.dts') 1607 self.assertIn("Node '/binman/files': Missing 'pattern' property", 1608 str(e.exception)) 1609 1610 def testExpandSize(self): 1611 """Test an expanding entry""" 1612 data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts', 1613 map=True) 1614 expect = ('a' * 8 + U_BOOT_DATA + 1615 MRC_DATA + 'b' * 1 + U_BOOT_DATA + 1616 'c' * 8 + U_BOOT_DATA + 1617 'd' * 8) 1618 self.assertEqual(expect, data) 1619 self.assertEqual('''ImagePos Offset Size Name 162000000000 00000000 00000028 main-section 162100000000 00000000 00000008 fill 162200000008 00000008 00000004 u-boot 16230000000c 0000000c 00000004 section 16240000000c 00000000 00000003 intel-mrc 162500000010 00000010 00000004 u-boot2 162600000014 00000014 0000000c section2 162700000014 00000000 00000008 fill 16280000001c 00000008 00000004 u-boot 162900000020 00000020 00000008 fill2 1630''', map_data) 1631 1632 def testExpandSizeBad(self): 1633 """Test an expanding entry which fails to provide contents""" 1634 with test_util.capture_sys_output() as (stdout, stderr): 1635 with self.assertRaises(ValueError) as e: 1636 self._DoReadFileDtb('089_expand_size_bad.dts', map=True) 1637 self.assertIn("Node '/binman/_testing': Cannot obtain contents when " 1638 'expanding entry', str(e.exception)) 1639 1640 def testHash(self): 1641 """Test hashing of the contents of an entry""" 1642 _, _, _, out_dtb_fname = self._DoReadFileDtb('090_hash.dts', 1643 use_real_dtb=True, update_dtb=True) 1644 dtb = fdt.Fdt(out_dtb_fname) 1645 dtb.Scan() 1646 hash_node = dtb.GetNode('/binman/u-boot/hash').props['value'] 1647 m = hashlib.sha256() 1648 m.update(U_BOOT_DATA) 1649 self.assertEqual(m.digest(), ''.join(hash_node.value)) 1650 1651 def testHashNoAlgo(self): 1652 with self.assertRaises(ValueError) as e: 1653 self._DoReadFileDtb('091_hash_no_algo.dts', update_dtb=True) 1654 self.assertIn("Node \'/binman/u-boot\': Missing \'algo\' property for " 1655 'hash node', str(e.exception)) 1656 1657 def testHashBadAlgo(self): 1658 with self.assertRaises(ValueError) as e: 1659 self._DoReadFileDtb('092_hash_bad_algo.dts', update_dtb=True) 1660 self.assertIn("Node '/binman/u-boot': Unknown hash algorithm", 1661 str(e.exception)) 1662 1663 def testHashSection(self): 1664 """Test hashing of the contents of an entry""" 1665 _, _, _, out_dtb_fname = self._DoReadFileDtb('099_hash_section.dts', 1666 use_real_dtb=True, update_dtb=True) 1667 dtb = fdt.Fdt(out_dtb_fname) 1668 dtb.Scan() 1669 hash_node = dtb.GetNode('/binman/section/hash').props['value'] 1670 m = hashlib.sha256() 1671 m.update(U_BOOT_DATA) 1672 m.update(16 * 'a') 1673 self.assertEqual(m.digest(), ''.join(hash_node.value)) 1674 1675 def testPackUBootTplMicrocode(self): 1676 """Test that x86 microcode can be handled correctly in TPL 1677 1678 We expect to see the following in the image, in order: 1679 u-boot-tpl-nodtb.bin with a microcode pointer inserted at the correct 1680 place 1681 u-boot-tpl.dtb with the microcode removed 1682 the microcode 1683 """ 1684 with open(self.TestFile('u_boot_ucode_ptr')) as fd: 1685 TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read()) 1686 first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts', 1687 U_BOOT_TPL_NODTB_DATA) 1688 self.assertEqual('tplnodtb with microc' + pos_and_size + 1689 'ter somewhere in here', first) 1690 1691 def testFmapX86(self): 1692 """Basic test of generation of a flashrom fmap""" 1693 data = self._DoReadFile('094_fmap_x86.dts') 1694 fhdr, fentries = fmap_util.DecodeFmap(data[32:]) 1695 expected = U_BOOT_DATA + MRC_DATA + 'a' * (32 - 7) 1696 self.assertEqual(expected, data[:32]) 1697 fhdr, fentries = fmap_util.DecodeFmap(data[32:]) 1698 1699 self.assertEqual(0x100, fhdr.image_size) 1700 1701 self.assertEqual(0, fentries[0].offset) 1702 self.assertEqual(4, fentries[0].size) 1703 self.assertEqual('U_BOOT', fentries[0].name) 1704 1705 self.assertEqual(4, fentries[1].offset) 1706 self.assertEqual(3, fentries[1].size) 1707 self.assertEqual('INTEL_MRC', fentries[1].name) 1708 1709 self.assertEqual(32, fentries[2].offset) 1710 self.assertEqual(fmap_util.FMAP_HEADER_LEN + 1711 fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) 1712 self.assertEqual('FMAP', fentries[2].name) 1713 1714 def testFmapX86Section(self): 1715 """Basic test of generation of a flashrom fmap""" 1716 data = self._DoReadFile('095_fmap_x86_section.dts') 1717 expected = U_BOOT_DATA + MRC_DATA + 'b' * (32 - 7) 1718 self.assertEqual(expected, data[:32]) 1719 fhdr, fentries = fmap_util.DecodeFmap(data[36:]) 1720 1721 self.assertEqual(0x100, fhdr.image_size) 1722 1723 self.assertEqual(0, fentries[0].offset) 1724 self.assertEqual(4, fentries[0].size) 1725 self.assertEqual('U_BOOT', fentries[0].name) 1726 1727 self.assertEqual(4, fentries[1].offset) 1728 self.assertEqual(3, fentries[1].size) 1729 self.assertEqual('INTEL_MRC', fentries[1].name) 1730 1731 self.assertEqual(36, fentries[2].offset) 1732 self.assertEqual(fmap_util.FMAP_HEADER_LEN + 1733 fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) 1734 self.assertEqual('FMAP', fentries[2].name) 1735 1736 def testElf(self): 1737 """Basic test of ELF entries""" 1738 self._SetupSplElf() 1739 with open(self.TestFile('bss_data')) as fd: 1740 TestFunctional._MakeInputFile('-boot', fd.read()) 1741 data = self._DoReadFile('096_elf.dts') 1742 1743 def testElfStripg(self): 1744 """Basic test of ELF entries""" 1745 self._SetupSplElf() 1746 with open(self.TestFile('bss_data')) as fd: 1747 TestFunctional._MakeInputFile('-boot', fd.read()) 1748 data = self._DoReadFile('097_elf_strip.dts') 1749 1750 def testPackOverlapMap(self): 1751 """Test that overlapping regions are detected""" 1752 with test_util.capture_sys_output() as (stdout, stderr): 1753 with self.assertRaises(ValueError) as e: 1754 self._DoTestFile('014_pack_overlap.dts', map=True) 1755 map_fname = tools.GetOutputFilename('image.map') 1756 self.assertEqual("Wrote map file '%s' to show errors\n" % map_fname, 1757 stdout.getvalue()) 1758 1759 # We should not get an inmage, but there should be a map file 1760 self.assertFalse(os.path.exists(tools.GetOutputFilename('image.bin'))) 1761 self.assertTrue(os.path.exists(map_fname)) 1762 map_data = tools.ReadFile(map_fname) 1763 self.assertEqual('''ImagePos Offset Size Name 1764<none> 00000000 00000007 main-section 1765<none> 00000000 00000004 u-boot 1766<none> 00000003 00000004 u-boot-align 1767''', map_data) 1768 1769 def testPacRefCode(self): 1770 """Test that an image with an Intel Reference code binary works""" 1771 data = self._DoReadFile('100_intel_refcode.dts') 1772 self.assertEqual(REFCODE_DATA, data[:len(REFCODE_DATA)]) 1773 1774 1775if __name__ == "__main__": 1776 unittest.main() 1777