tools/binman/ftest.py

   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
   9 from optparse import OptionParser
  10 import os
  11 import shutil
  12 import struct
  13 import sys
  14 import tempfile
  15 import unittest
  16
  17 import binman
  18 import cmdline
  19 import command
  20 import control
  21 import elf
  22 import fdt
  23 import fdt_util
  24 import fmap_util
  25 import test_util
  26 import tools
  27 import tout
  28
  29 # Contents of test files, corresponding to different entry types
  30 U_BOOT_DATA           = '1234'
  31 U_BOOT_IMG_DATA       = 'img'
  32 U_BOOT_SPL_DATA       = '56780123456789abcde'
  33 U_BOOT_TPL_DATA       = 'tpl'
  34 BLOB_DATA             = '89'
  35 ME_DATA               = '0abcd'
  36 VGA_DATA              = 'vga'
  37 U_BOOT_DTB_DATA       = 'udtb'
  38 U_BOOT_SPL_DTB_DATA   = 'spldtb'
  39 U_BOOT_TPL_DTB_DATA   = 'tpldtb'
  40 X86_START16_DATA      = 'start16'
  41 X86_START16_SPL_DATA  = 'start16spl'
  42 U_BOOT_NODTB_DATA     = 'nodtb with microcode pointer somewhere in here'
  43 U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here'
  44 FSP_DATA              = 'fsp'
  45 CMC_DATA              = 'cmc'
  46 VBT_DATA              = 'vbt'
  47 MRC_DATA              = 'mrc'
  48 TEXT_DATA             = 'text'
  49 TEXT_DATA2            = 'text2'
  50 TEXT_DATA3            = 'text3'
  51 CROS_EC_RW_DATA       = 'ecrw'
  52 GBB_DATA              = 'gbbd'
  53 BMPBLK_DATA           = 'bmp'
  54 VBLOCK_DATA           = 'vblk'
  55
  56
  57 class TestFunctional(unittest.TestCase):
  58     """Functional tests for binman
  59
  60     Most of these use a sample .dts file to build an image and then check
  61     that it looks correct. The sample files are in the test/ subdirectory
  62     and are numbered.
  63
  64     For each entry type a very small test file is created using fixed
  65     string contents. This makes it easy to test that things look right, and
  66     debug problems.
  67
  68     In some cases a 'real' file must be used - these are also supplied in
  69     the test/ diurectory.
  70     """
  71     @classmethod
  72     def setUpClass(self):
  73         global entry
  74         import entry
  75
  76         # Handle the case where argv[0] is 'python'
  77         self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
  78         self._binman_pathname = os.path.join(self._binman_dir, 'binman')
  79
  80         # Create a temporary directory for input files
  81         self._indir = tempfile.mkdtemp(prefix='binmant.')
  82
  83         # Create some test files
  84         TestFunctional._MakeInputFile('u-boot.bin', U_BOOT_DATA)
  85         TestFunctional._MakeInputFile('u-boot.img', U_BOOT_IMG_DATA)
  86         TestFunctional._MakeInputFile('spl/u-boot-spl.bin', U_BOOT_SPL_DATA)
  87         TestFunctional._MakeInputFile('tpl/u-boot-tpl.bin', U_BOOT_TPL_DATA)
  88         TestFunctional._MakeInputFile('blobfile', BLOB_DATA)
  89         TestFunctional._MakeInputFile('me.bin', ME_DATA)
  90         TestFunctional._MakeInputFile('vga.bin', VGA_DATA)
  91         self._ResetDtbs()
  92         TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA)
  93         TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin',
  94                                       X86_START16_SPL_DATA)
  95         TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA)
  96         TestFunctional._MakeInputFile('spl/u-boot-spl-nodtb.bin',
  97                                       U_BOOT_SPL_NODTB_DATA)
  98         TestFunctional._MakeInputFile('fsp.bin', FSP_DATA)
  99         TestFunctional._MakeInputFile('cmc.bin', CMC_DATA)
 100         TestFunctional._MakeInputFile('vbt.bin', VBT_DATA)
 101         TestFunctional._MakeInputFile('mrc.bin', MRC_DATA)
 102         TestFunctional._MakeInputFile('ecrw.bin', CROS_EC_RW_DATA)
 103         TestFunctional._MakeInputDir('devkeys')
 104         TestFunctional._MakeInputFile('bmpblk.bin', BMPBLK_DATA)
 105         self._output_setup = False
 106
 107         # ELF file with a '_dt_ucode_base_size' symbol
 108         with open(self.TestFile('u_boot_ucode_ptr')) as fd:
 109             TestFunctional._MakeInputFile('u-boot', fd.read())
 110
 111         # Intel flash descriptor file
 112         with open(self.TestFile('descriptor.bin')) as fd:
 113             TestFunctional._MakeInputFile('descriptor.bin', fd.read())
 114
 115     @classmethod
 116     def tearDownClass(self):
 117         """Remove the temporary input directory and its contents"""
 118         if self._indir:
 119             shutil.rmtree(self._indir)
 120         self._indir = None
 121
 122     def setUp(self):
 123         # Enable this to turn on debugging output
 124         # tout.Init(tout.DEBUG)
 125         command.test_result = None
 126
 127     def tearDown(self):
 128         """Remove the temporary output directory"""
 129         tools._FinaliseForTest()
 130
 131     @classmethod
 132     def _ResetDtbs(self):
 133         TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA)
 134         TestFunctional._MakeInputFile('spl/u-boot-spl.dtb', U_BOOT_SPL_DTB_DATA)
 135         TestFunctional._MakeInputFile('tpl/u-boot-tpl.dtb', U_BOOT_TPL_DTB_DATA)
 136
 137     def _RunBinman(self, *args, **kwargs):
 138         """Run binman using the command line
 139
 140         Args:
 141             Arguments to pass, as a list of strings
 142             kwargs: Arguments to pass to Command.RunPipe()
 143         """
 144         result = command.RunPipe([[self._binman_pathname] + list(args)],
 145                 capture=True, capture_stderr=True, raise_on_error=False)
 146         if result.return_code and kwargs.get('raise_on_error', True):
 147             raise Exception("Error running '%s': %s" % (' '.join(args),
 148                             result.stdout + result.stderr))
 149         return result
 150
 151     def _DoBinman(self, *args):
 152         """Run binman using directly (in the same process)
 153
 154         Args:
 155             Arguments to pass, as a list of strings
 156         Returns:
 157             Return value (0 for success)
 158         """
 159         args = list(args)
 160         if '-D' in sys.argv:
 161             args = args + ['-D']
 162         (options, args) = cmdline.ParseArgs(args)
 163         options.pager = 'binman-invalid-pager'
 164         options.build_dir = self._indir
 165
 166         # For testing, you can force an increase in verbosity here
 167         # options.verbosity = tout.DEBUG
 168         return control.Binman(options, args)
 169
 170     def _DoTestFile(self, fname, debug=False, map=False, update_dtb=False,
 171                     entry_args=None):
 172         """Run binman with a given test file
 173
 174         Args:
 175             fname: Device-tree source filename to use (e.g. 05_simple.dts)
 176             debug: True to enable debugging output
 177             map: True to output map files for the images
 178             update_dtb: Update the offset and size of each entry in the device
 179                 tree before packing it into the image
 180         """
 181         args = ['-p', '-I', self._indir, '-d', self.TestFile(fname)]
 182         if debug:
 183             args.append('-D')
 184         if map:
 185             args.append('-m')
 186         if update_dtb:
 187             args.append('-up')
 188         if entry_args:
 189             for arg, value in entry_args.iteritems():
 190                 args.append('-a%s=%s' % (arg, value))
 191         return self._DoBinman(*args)
 192
 193     def _SetupDtb(self, fname, outfile='u-boot.dtb'):
 194         """Set up a new test device-tree file
 195
 196         The given file is compiled and set up as the device tree to be used
 197         for ths test.
 198
 199         Args:
 200             fname: Filename of .dts file to read
 201             outfile: Output filename for compiled device-tree binary
 202
 203         Returns:
 204             Contents of device-tree binary
 205         """
 206         if not self._output_setup:
 207             tools.PrepareOutputDir(self._indir, True)
 208             self._output_setup = True
 209         dtb = fdt_util.EnsureCompiled(self.TestFile(fname))
 210         with open(dtb) as fd:
 211             data = fd.read()
 212             TestFunctional._MakeInputFile(outfile, data)
 213             return data
 214
 215     def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False,
 216                        update_dtb=False, entry_args=None):
 217         """Run binman and return the resulting image
 218
 219         This runs binman with a given test file and then reads the resulting
 220         output file. It is a shortcut function since most tests need to do
 221         these steps.
 222
 223         Raises an assertion failure if binman returns a non-zero exit code.
 224
 225         Args:
 226             fname: Device-tree source filename to use (e.g. 05_simple.dts)
 227             use_real_dtb: True to use the test file as the contents of
 228                 the u-boot-dtb entry. Normally this is not needed and the
 229                 test contents (the U_BOOT_DTB_DATA string) can be used.
 230                 But in some test we need the real contents.
 231             map: True to output map files for the images
 232             update_dtb: Update the offset and size of each entry in the device
 233                 tree before packing it into the image
 234
 235         Returns:
 236             Tuple:
 237                 Resulting image contents
 238                 Device tree contents
 239                 Map data showing contents of image (or None if none)
 240                 Output device tree binary filename ('u-boot.dtb' path)
 241         """
 242         dtb_data = None
 243         # Use the compiled test file as the u-boot-dtb input
 244         if use_real_dtb:
 245             dtb_data = self._SetupDtb(fname)
 246
 247         try:
 248             retcode = self._DoTestFile(fname, map=map, update_dtb=update_dtb,
 249                                        entry_args=entry_args)
 250             self.assertEqual(0, retcode)
 251             out_dtb_fname = control.GetFdtPath('u-boot.dtb')
 252
 253             # Find the (only) image, read it and return its contents
 254             image = control.images['image']
 255             image_fname = tools.GetOutputFilename('image.bin')
 256             self.assertTrue(os.path.exists(image_fname))
 257             if map:
 258                 map_fname = tools.GetOutputFilename('image.map')
 259                 with open(map_fname) as fd:
 260                     map_data = fd.read()
 261             else:
 262                 map_data = None
 263             with open(image_fname) as fd:
 264                 return fd.read(), dtb_data, map_data, out_dtb_fname
 265         finally:
 266             # Put the test file back
 267             if use_real_dtb:
 268                 self._ResetDtbs()
 269
 270     def _DoReadFile(self, fname, use_real_dtb=False):
 271         """Helper function which discards the device-tree binary
 272
 273         Args:
 274             fname: Device-tree source filename to use (e.g. 05_simple.dts)
 275             use_real_dtb: True to use the test file as the contents of
 276                 the u-boot-dtb entry. Normally this is not needed and the
 277                 test contents (the U_BOOT_DTB_DATA string) can be used.
 278                 But in some test we need the real contents.
 279
 280         Returns:
 281             Resulting image contents
 282         """
 283         return self._DoReadFileDtb(fname, use_real_dtb)[0]
 284
 285     @classmethod
 286     def _MakeInputFile(self, fname, contents):
 287         """Create a new test input file, creating directories as needed
 288
 289         Args:
 290             fname: Filename to create
 291             contents: File contents to write in to the file
 292         Returns:
 293             Full pathname of file created
 294         """
 295         pathname = os.path.join(self._indir, fname)
 296         dirname = os.path.dirname(pathname)
 297         if dirname and not os.path.exists(dirname):
 298             os.makedirs(dirname)
 299         with open(pathname, 'wb') as fd:
 300             fd.write(contents)
 301         return pathname
 302
 303     @classmethod
 304     def _MakeInputDir(self, dirname):
 305         """Create a new test input directory, creating directories as needed
 306
 307         Args:
 308             dirname: Directory name to create
 309
 310         Returns:
 311             Full pathname of directory created
 312         """
 313         pathname = os.path.join(self._indir, dirname)
 314         if not os.path.exists(pathname):
 315             os.makedirs(pathname)
 316         return pathname
 317
 318     @classmethod
 319     def TestFile(self, fname):
 320         return os.path.join(self._binman_dir, 'test', fname)
 321
 322     def AssertInList(self, grep_list, target):
 323         """Assert that at least one of a list of things is in a target
 324
 325         Args:
 326             grep_list: List of strings to check
 327             target: Target string
 328         """
 329         for grep in grep_list:
 330             if grep in target:
 331                 return
 332         self.fail("Error: '%' not found in '%s'" % (grep_list, target))
 333
 334     def CheckNoGaps(self, entries):
 335         """Check that all entries fit together without gaps
 336
 337         Args:
 338             entries: List of entries to check
 339         """
 340         offset = 0
 341         for entry in entries.values():
 342             self.assertEqual(offset, entry.offset)
 343             offset += entry.size
 344
 345     def GetFdtLen(self, dtb):
 346         """Get the totalsize field from a device-tree binary
 347
 348         Args:
 349             dtb: Device-tree binary contents
 350
 351         Returns:
 352             Total size of device-tree binary, from the header
 353         """
 354         return struct.unpack('>L', dtb[4:8])[0]
 355
 356     def _GetPropTree(self, dtb, prop_names):
 357         def AddNode(node, path):
 358             if node.name != '/':
 359                 path += '/' + node.name
 360             for subnode in node.subnodes:
 361                 for prop in subnode.props.values():
 362                     if prop.name in prop_names:
 363                         prop_path = path + '/' + subnode.name + ':' + prop.name
 364                         tree[prop_path[len('/binman/'):]] = fdt_util.fdt32_to_cpu(
 365                             prop.value)
 366                 AddNode(subnode, path)
 367
 368         tree = {}
 369         AddNode(dtb.GetRoot(), '')
 370         return tree
 371
 372     def testRun(self):
 373         """Test a basic run with valid args"""
 374         result = self._RunBinman('-h')
 375
 376     def testFullHelp(self):
 377         """Test that the full help is displayed with -H"""
 378         result = self._RunBinman('-H')
 379         help_file = os.path.join(self._binman_dir, 'README')
 380         # Remove possible extraneous strings
 381         extra = '::::::::::::::\n' + help_file + '\n::::::::::::::\n'
 382         gothelp = result.stdout.replace(extra, '')
 383         self.assertEqual(len(gothelp), os.path.getsize(help_file))
 384         self.assertEqual(0, len(result.stderr))
 385         self.assertEqual(0, result.return_code)
 386
 387     def testFullHelpInternal(self):
 388         """Test that the full help is displayed with -H"""
 389         try:
 390             command.test_result = command.CommandResult()
 391             result = self._DoBinman('-H')
 392             help_file = os.path.join(self._binman_dir, 'README')
 393         finally:
 394             command.test_result = None
 395
 396     def testHelp(self):
 397         """Test that the basic help is displayed with -h"""
 398         result = self._RunBinman('-h')
 399         self.assertTrue(len(result.stdout) > 200)
 400         self.assertEqual(0, len(result.stderr))
 401         self.assertEqual(0, result.return_code)
 402
 403     def testBoard(self):
 404         """Test that we can run it with a specific board"""
 405         self._SetupDtb('05_simple.dts', 'sandbox/u-boot.dtb')
 406         TestFunctional._MakeInputFile('sandbox/u-boot.bin', U_BOOT_DATA)
 407         result = self._DoBinman('-b', 'sandbox')
 408         self.assertEqual(0, result)
 409
 410     def testNeedBoard(self):
 411         """Test that we get an error when no board ius supplied"""
 412         with self.assertRaises(ValueError) as e:
 413             result = self._DoBinman()
 414         self.assertIn("Must provide a board to process (use -b <board>)",
 415                 str(e.exception))
 416
 417     def testMissingDt(self):
 418         """Test that an invalid device-tree file generates an error"""
 419         with self.assertRaises(Exception) as e:
 420             self._RunBinman('-d', 'missing_file')
 421         # We get one error from libfdt, and a different one from fdtget.
 422         self.AssertInList(["Couldn't open blob from 'missing_file'",
 423                            'No such file or directory'], str(e.exception))
 424
 425     def testBrokenDt(self):
 426         """Test that an invalid device-tree source file generates an error
 427
 428         Since this is a source file it should be compiled and the error
 429         will come from the device-tree compiler (dtc).
 430         """
 431         with self.assertRaises(Exception) as e:
 432             self._RunBinman('-d', self.TestFile('01_invalid.dts'))
 433         self.assertIn("FATAL ERROR: Unable to parse input tree",
 434                 str(e.exception))
 435
 436     def testMissingNode(self):
 437         """Test that a device tree without a 'binman' node generates an error"""
 438         with self.assertRaises(Exception) as e:
 439             self._DoBinman('-d', self.TestFile('02_missing_node.dts'))
 440         self.assertIn("does not have a 'binman' node", str(e.exception))
 441
 442     def testEmpty(self):
 443         """Test that an empty binman node works OK (i.e. does nothing)"""
 444         result = self._RunBinman('-d', self.TestFile('03_empty.dts'))
 445         self.assertEqual(0, len(result.stderr))
 446         self.assertEqual(0, result.return_code)
 447
 448     def testInvalidEntry(self):
 449         """Test that an invalid entry is flagged"""
 450         with self.assertRaises(Exception) as e:
 451             result = self._RunBinman('-d',
 452                                      self.TestFile('04_invalid_entry.dts'))
 453         self.assertIn("Unknown entry type 'not-a-valid-type' in node "
 454                 "'/binman/not-a-valid-type'", str(e.exception))
 455
 456     def testSimple(self):
 457         """Test a simple binman with a single file"""
 458         data = self._DoReadFile('05_simple.dts')
 459         self.assertEqual(U_BOOT_DATA, data)
 460
 461     def testSimpleDebug(self):
 462         """Test a simple binman run with debugging enabled"""
 463         data = self._DoTestFile('05_simple.dts', debug=True)
 464
 465     def testDual(self):
 466         """Test that we can handle creating two images
 467
 468         This also tests image padding.
 469         """
 470         retcode = self._DoTestFile('06_dual_image.dts')
 471         self.assertEqual(0, retcode)
 472
 473         image = control.images['image1']
 474         self.assertEqual(len(U_BOOT_DATA), image._size)
 475         fname = tools.GetOutputFilename('image1.bin')
 476         self.assertTrue(os.path.exists(fname))
 477         with open(fname) as fd:
 478             data = fd.read()
 479             self.assertEqual(U_BOOT_DATA, data)
 480
 481         image = control.images['image2']
 482         self.assertEqual(3 + len(U_BOOT_DATA) + 5, image._size)
 483         fname = tools.GetOutputFilename('image2.bin')
 484         self.assertTrue(os.path.exists(fname))
 485         with open(fname) as fd:
 486             data = fd.read()
 487             self.assertEqual(U_BOOT_DATA, data[3:7])
 488             self.assertEqual(chr(0) * 3, data[:3])
 489             self.assertEqual(chr(0) * 5, data[7:])
 490
 491     def testBadAlign(self):
 492         """Test that an invalid alignment value is detected"""
 493         with self.assertRaises(ValueError) as e:
 494             self._DoTestFile('07_bad_align.dts')
 495         self.assertIn("Node '/binman/u-boot': Alignment 23 must be a power "
 496                       "of two", str(e.exception))
 497
 498     def testPackSimple(self):
 499         """Test that packing works as expected"""
 500         retcode = self._DoTestFile('08_pack.dts')
 501         self.assertEqual(0, retcode)
 502         self.assertIn('image', control.images)
 503         image = control.images['image']
 504         entries = image.GetEntries()
 505         self.assertEqual(5, len(entries))
 506
 507         # First u-boot
 508         self.assertIn('u-boot', entries)
 509         entry = entries['u-boot']
 510         self.assertEqual(0, entry.offset)
 511         self.assertEqual(len(U_BOOT_DATA), entry.size)
 512
 513         # Second u-boot, aligned to 16-byte boundary
 514         self.assertIn('u-boot-align', entries)
 515         entry = entries['u-boot-align']
 516         self.assertEqual(16, entry.offset)
 517         self.assertEqual(len(U_BOOT_DATA), entry.size)
 518
 519         # Third u-boot, size 23 bytes
 520         self.assertIn('u-boot-size', entries)
 521         entry = entries['u-boot-size']
 522         self.assertEqual(20, entry.offset)
 523         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
 524         self.assertEqual(23, entry.size)
 525
 526         # Fourth u-boot, placed immediate after the above
 527         self.assertIn('u-boot-next', entries)
 528         entry = entries['u-boot-next']
 529         self.assertEqual(43, entry.offset)
 530         self.assertEqual(len(U_BOOT_DATA), entry.size)
 531
 532         # Fifth u-boot, placed at a fixed offset
 533         self.assertIn('u-boot-fixed', entries)
 534         entry = entries['u-boot-fixed']
 535         self.assertEqual(61, entry.offset)
 536         self.assertEqual(len(U_BOOT_DATA), entry.size)
 537
 538         self.assertEqual(65, image._size)
 539
 540     def testPackExtra(self):
 541         """Test that extra packing feature works as expected"""
 542         retcode = self._DoTestFile('09_pack_extra.dts')
 543
 544         self.assertEqual(0, retcode)
 545         self.assertIn('image', control.images)
 546         image = control.images['image']
 547         entries = image.GetEntries()
 548         self.assertEqual(5, len(entries))
 549
 550         # First u-boot with padding before and after
 551         self.assertIn('u-boot', entries)
 552         entry = entries['u-boot']
 553         self.assertEqual(0, entry.offset)
 554         self.assertEqual(3, entry.pad_before)
 555         self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size)
 556
 557         # Second u-boot has an aligned size, but it has no effect
 558         self.assertIn('u-boot-align-size-nop', entries)
 559         entry = entries['u-boot-align-size-nop']
 560         self.assertEqual(12, entry.offset)
 561         self.assertEqual(4, entry.size)
 562
 563         # Third u-boot has an aligned size too
 564         self.assertIn('u-boot-align-size', entries)
 565         entry = entries['u-boot-align-size']
 566         self.assertEqual(16, entry.offset)
 567         self.assertEqual(32, entry.size)
 568
 569         # Fourth u-boot has an aligned end
 570         self.assertIn('u-boot-align-end', entries)
 571         entry = entries['u-boot-align-end']
 572         self.assertEqual(48, entry.offset)
 573         self.assertEqual(16, entry.size)
 574
 575         # Fifth u-boot immediately afterwards
 576         self.assertIn('u-boot-align-both', entries)
 577         entry = entries['u-boot-align-both']
 578         self.assertEqual(64, entry.offset)
 579         self.assertEqual(64, entry.size)
 580
 581         self.CheckNoGaps(entries)
 582         self.assertEqual(128, image._size)
 583
 584     def testPackAlignPowerOf2(self):
 585         """Test that invalid entry alignment is detected"""
 586         with self.assertRaises(ValueError) as e:
 587             self._DoTestFile('10_pack_align_power2.dts')
 588         self.assertIn("Node '/binman/u-boot': Alignment 5 must be a power "
 589                       "of two", str(e.exception))
 590
 591     def testPackAlignSizePowerOf2(self):
 592         """Test that invalid entry size alignment is detected"""
 593         with self.assertRaises(ValueError) as e:
 594             self._DoTestFile('11_pack_align_size_power2.dts')
 595         self.assertIn("Node '/binman/u-boot': Alignment size 55 must be a "
 596                       "power of two", str(e.exception))
 597
 598     def testPackInvalidAlign(self):
 599         """Test detection of an offset that does not match its alignment"""
 600         with self.assertRaises(ValueError) as e:
 601             self._DoTestFile('12_pack_inv_align.dts')
 602         self.assertIn("Node '/binman/u-boot': Offset 0x5 (5) does not match "
 603                       "align 0x4 (4)", str(e.exception))
 604
 605     def testPackInvalidSizeAlign(self):
 606         """Test that invalid entry size alignment is detected"""
 607         with self.assertRaises(ValueError) as e:
 608             self._DoTestFile('13_pack_inv_size_align.dts')
 609         self.assertIn("Node '/binman/u-boot': Size 0x5 (5) does not match "
 610                       "align-size 0x4 (4)", str(e.exception))
 611
 612     def testPackOverlap(self):
 613         """Test that overlapping regions are detected"""
 614         with self.assertRaises(ValueError) as e:
 615             self._DoTestFile('14_pack_overlap.dts')
 616         self.assertIn("Node '/binman/u-boot-align': Offset 0x3 (3) overlaps "
 617                       "with previous entry '/binman/u-boot' ending at 0x4 (4)",
 618                       str(e.exception))
 619
 620     def testPackEntryOverflow(self):
 621         """Test that entries that overflow their size are detected"""
 622         with self.assertRaises(ValueError) as e:
 623             self._DoTestFile('15_pack_overflow.dts')
 624         self.assertIn("Node '/binman/u-boot': Entry contents size is 0x4 (4) "
 625                       "but entry size is 0x3 (3)", str(e.exception))
 626
 627     def testPackImageOverflow(self):
 628         """Test that entries which overflow the image size are detected"""
 629         with self.assertRaises(ValueError) as e:
 630             self._DoTestFile('16_pack_image_overflow.dts')
 631         self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section "
 632                       "size 0x3 (3)", str(e.exception))
 633
 634     def testPackImageSize(self):
 635         """Test that the image size can be set"""
 636         retcode = self._DoTestFile('17_pack_image_size.dts')
 637         self.assertEqual(0, retcode)
 638         self.assertIn('image', control.images)
 639         image = control.images['image']
 640         self.assertEqual(7, image._size)
 641
 642     def testPackImageSizeAlign(self):
 643         """Test that image size alignemnt works as expected"""
 644         retcode = self._DoTestFile('18_pack_image_align.dts')
 645         self.assertEqual(0, retcode)
 646         self.assertIn('image', control.images)
 647         image = control.images['image']
 648         self.assertEqual(16, image._size)
 649
 650     def testPackInvalidImageAlign(self):
 651         """Test that invalid image alignment is detected"""
 652         with self.assertRaises(ValueError) as e:
 653             self._DoTestFile('19_pack_inv_image_align.dts')
 654         self.assertIn("Section '/binman': Size 0x7 (7) does not match "
 655                       "align-size 0x8 (8)", str(e.exception))
 656
 657     def testPackAlignPowerOf2(self):
 658         """Test that invalid image alignment is detected"""
 659         with self.assertRaises(ValueError) as e:
 660             self._DoTestFile('20_pack_inv_image_align_power2.dts')
 661         self.assertIn("Section '/binman': Alignment size 131 must be a power of "
 662                       "two", str(e.exception))
 663
 664     def testImagePadByte(self):
 665         """Test that the image pad byte can be specified"""
 666         with open(self.TestFile('bss_data')) as fd:
 667             TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
 668         data = self._DoReadFile('21_image_pad.dts')
 669         self.assertEqual(U_BOOT_SPL_DATA + (chr(0xff) * 1) + U_BOOT_DATA, data)
 670
 671     def testImageName(self):
 672         """Test that image files can be named"""
 673         retcode = self._DoTestFile('22_image_name.dts')
 674         self.assertEqual(0, retcode)
 675         image = control.images['image1']
 676         fname = tools.GetOutputFilename('test-name')
 677         self.assertTrue(os.path.exists(fname))
 678
 679         image = control.images['image2']
 680         fname = tools.GetOutputFilename('test-name.xx')
 681         self.assertTrue(os.path.exists(fname))
 682
 683     def testBlobFilename(self):
 684         """Test that generic blobs can be provided by filename"""
 685         data = self._DoReadFile('23_blob.dts')
 686         self.assertEqual(BLOB_DATA, data)
 687
 688     def testPackSorted(self):
 689         """Test that entries can be sorted"""
 690         data = self._DoReadFile('24_sorted.dts')
 691         self.assertEqual(chr(0) * 1 + U_BOOT_SPL_DATA + chr(0) * 2 +
 692                          U_BOOT_DATA, data)
 693
 694     def testPackZeroOffset(self):
 695         """Test that an entry at offset 0 is not given a new offset"""
 696         with self.assertRaises(ValueError) as e:
 697             self._DoTestFile('25_pack_zero_size.dts')
 698         self.assertIn("Node '/binman/u-boot-spl': Offset 0x0 (0) overlaps "
 699                       "with previous entry '/binman/u-boot' ending at 0x4 (4)",
 700                       str(e.exception))
 701
 702     def testPackUbootDtb(self):
 703         """Test that a device tree can be added to U-Boot"""
 704         data = self._DoReadFile('26_pack_u_boot_dtb.dts')
 705         self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA, data)
 706
 707     def testPackX86RomNoSize(self):
 708         """Test that the end-at-4gb property requires a size property"""
 709         with self.assertRaises(ValueError) as e:
 710             self._DoTestFile('27_pack_4gb_no_size.dts')
 711         self.assertIn("Section '/binman': Section size must be provided when "
 712                       "using end-at-4gb", str(e.exception))
 713
 714     def testPackX86RomOutside(self):
 715         """Test that the end-at-4gb property checks for offset boundaries"""
 716         with self.assertRaises(ValueError) as e:
 717             self._DoTestFile('28_pack_4gb_outside.dts')
 718         self.assertIn("Node '/binman/u-boot': Offset 0x0 (0) is outside "
 719                       "the section starting at 0xffffffe0 (4294967264)",
 720                       str(e.exception))
 721
 722     def testPackX86Rom(self):
 723         """Test that a basic x86 ROM can be created"""
 724         data = self._DoReadFile('29_x86-rom.dts')
 725         self.assertEqual(U_BOOT_DATA + chr(0) * 7 + U_BOOT_SPL_DATA +
 726                          chr(0) * 2, data)
 727
 728     def testPackX86RomMeNoDesc(self):
 729         """Test that an invalid Intel descriptor entry is detected"""
 730         TestFunctional._MakeInputFile('descriptor.bin', '')
 731         with self.assertRaises(ValueError) as e:
 732             self._DoTestFile('31_x86-rom-me.dts')
 733         self.assertIn("Node '/binman/intel-descriptor': Cannot find FD "
 734                       "signature", str(e.exception))
 735
 736     def testPackX86RomBadDesc(self):
 737         """Test that the Intel requires a descriptor entry"""
 738         with self.assertRaises(ValueError) as e:
 739             self._DoTestFile('30_x86-rom-me-no-desc.dts')
 740         self.assertIn("Node '/binman/intel-me': No offset set with "
 741                       "offset-unset: should another entry provide this correct "
 742                       "offset?", str(e.exception))
 743
 744     def testPackX86RomMe(self):
 745         """Test that an x86 ROM with an ME region can be created"""
 746         data = self._DoReadFile('31_x86-rom-me.dts')
 747         self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
 748
 749     def testPackVga(self):
 750         """Test that an image with a VGA binary can be created"""
 751         data = self._DoReadFile('32_intel-vga.dts')
 752         self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
 753
 754     def testPackStart16(self):
 755         """Test that an image with an x86 start16 region can be created"""
 756         data = self._DoReadFile('33_x86-start16.dts')
 757         self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
 758
 759     def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False):
 760         """Handle running a test for insertion of microcode
 761
 762         Args:
 763             dts_fname: Name of test .dts file
 764             nodtb_data: Data that we expect in the first section
 765             ucode_second: True if the microsecond entry is second instead of
 766                 third
 767
 768         Returns:
 769             Tuple:
 770                 Contents of first region (U-Boot or SPL)
 771                 Offset and size components of microcode pointer, as inserted
 772                     in the above (two 4-byte words)
 773         """
 774         data = self._DoReadFile(dts_fname, True)
 775
 776         # Now check the device tree has no microcode
 777         if ucode_second:
 778             ucode_content = data[len(nodtb_data):]
 779             ucode_pos = len(nodtb_data)
 780             dtb_with_ucode = ucode_content[16:]
 781             fdt_len = self.GetFdtLen(dtb_with_ucode)
 782         else:
 783             dtb_with_ucode = data[len(nodtb_data):]
 784             fdt_len = self.GetFdtLen(dtb_with_ucode)
 785             ucode_content = dtb_with_ucode[fdt_len:]
 786             ucode_pos = len(nodtb_data) + fdt_len
 787         fname = tools.GetOutputFilename('test.dtb')
 788         with open(fname, 'wb') as fd:
 789             fd.write(dtb_with_ucode)
 790         dtb = fdt.FdtScan(fname)
 791         ucode = dtb.GetNode('/microcode')
 792         self.assertTrue(ucode)
 793         for node in ucode.subnodes:
 794             self.assertFalse(node.props.get('data'))
 795
 796         # Check that the microcode appears immediately after the Fdt
 797         # This matches the concatenation of the data properties in
 798         # the /microcode/update@xxx nodes in 34_x86_ucode.dts.
 799         ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000,
 800                                  0x78235609)
 801         self.assertEqual(ucode_data, ucode_content[:len(ucode_data)])
 802
 803         # Check that the microcode pointer was inserted. It should match the
 804         # expected offset and size
 805         pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
 806                                    len(ucode_data))
 807         u_boot = data[:len(nodtb_data)]
 808         return u_boot, pos_and_size
 809
 810     def testPackUbootMicrocode(self):
 811         """Test that x86 microcode can be handled correctly
 812
 813         We expect to see the following in the image, in order:
 814             u-boot-nodtb.bin with a microcode pointer inserted at the correct
 815                 place
 816             u-boot.dtb with the microcode removed
 817             the microcode
 818         """
 819         first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts',
 820                                                      U_BOOT_NODTB_DATA)
 821         self.assertEqual('nodtb with microcode' + pos_and_size +
 822                          ' somewhere in here', first)
 823
 824     def _RunPackUbootSingleMicrocode(self):
 825         """Test that x86 microcode can be handled correctly
 826
 827         We expect to see the following in the image, in order:
 828             u-boot-nodtb.bin with a microcode pointer inserted at the correct
 829                 place
 830             u-boot.dtb with the microcode
 831             an empty microcode region
 832         """
 833         # We need the libfdt library to run this test since only that allows
 834         # finding the offset of a property. This is required by
 835         # Entry_u_boot_dtb_with_ucode.ObtainContents().
 836         data = self._DoReadFile('35_x86_single_ucode.dts', True)
 837
 838         second = data[len(U_BOOT_NODTB_DATA):]
 839
 840         fdt_len = self.GetFdtLen(second)
 841         third = second[fdt_len:]
 842         second = second[:fdt_len]
 843
 844         ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
 845         self.assertIn(ucode_data, second)
 846         ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
 847
 848         # Check that the microcode pointer was inserted. It should match the
 849         # expected offset and size
 850         pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
 851                                    len(ucode_data))
 852         first = data[:len(U_BOOT_NODTB_DATA)]
 853         self.assertEqual('nodtb with microcode' + pos_and_size +
 854                          ' somewhere in here', first)
 855
 856     def testPackUbootSingleMicrocode(self):
 857         """Test that x86 microcode can be handled correctly with fdt_normal.
 858         """
 859         self._RunPackUbootSingleMicrocode()
 860
 861     def testUBootImg(self):
 862         """Test that u-boot.img can be put in a file"""
 863         data = self._DoReadFile('36_u_boot_img.dts')
 864         self.assertEqual(U_BOOT_IMG_DATA, data)
 865
 866     def testNoMicrocode(self):
 867         """Test that a missing microcode region is detected"""
 868         with self.assertRaises(ValueError) as e:
 869             self._DoReadFile('37_x86_no_ucode.dts', True)
 870         self.assertIn("Node '/binman/u-boot-dtb-with-ucode': No /microcode "
 871                       "node found in ", str(e.exception))
 872
 873     def testMicrocodeWithoutNode(self):
 874         """Test that a missing u-boot-dtb-with-ucode node is detected"""
 875         with self.assertRaises(ValueError) as e:
 876             self._DoReadFile('38_x86_ucode_missing_node.dts', True)
 877         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
 878                 "microcode region u-boot-dtb-with-ucode", str(e.exception))
 879
 880     def testMicrocodeWithoutNode2(self):
 881         """Test that a missing u-boot-ucode node is detected"""
 882         with self.assertRaises(ValueError) as e:
 883             self._DoReadFile('39_x86_ucode_missing_node2.dts', True)
 884         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
 885             "microcode region u-boot-ucode", str(e.exception))
 886
 887     def testMicrocodeWithoutPtrInElf(self):
 888         """Test that a U-Boot binary without the microcode symbol is detected"""
 889         # ELF file without a '_dt_ucode_base_size' symbol
 890         try:
 891             with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
 892                 TestFunctional._MakeInputFile('u-boot', fd.read())
 893
 894             with self.assertRaises(ValueError) as e:
 895                 self._RunPackUbootSingleMicrocode()
 896             self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate "
 897                     "_dt_ucode_base_size symbol in u-boot", str(e.exception))
 898
 899         finally:
 900             # Put the original file back
 901             with open(self.TestFile('u_boot_ucode_ptr')) as fd:
 902                 TestFunctional._MakeInputFile('u-boot', fd.read())
 903
 904     def testMicrocodeNotInImage(self):
 905         """Test that microcode must be placed within the image"""
 906         with self.assertRaises(ValueError) as e:
 907             self._DoReadFile('40_x86_ucode_not_in_image.dts', True)
 908         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode "
 909                 "pointer _dt_ucode_base_size at fffffe14 is outside the "
 910                 "section ranging from 00000000 to 0000002e", str(e.exception))
 911
 912     def testWithoutMicrocode(self):
 913         """Test that we can cope with an image without microcode (e.g. qemu)"""
 914         with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
 915             TestFunctional._MakeInputFile('u-boot', fd.read())
 916         data, dtb, _, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)
 917
 918         # Now check the device tree has no microcode
 919         self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
 920         second = data[len(U_BOOT_NODTB_DATA):]
 921
 922         fdt_len = self.GetFdtLen(second)
 923         self.assertEqual(dtb, second[:fdt_len])
 924
 925         used_len = len(U_BOOT_NODTB_DATA) + fdt_len
 926         third = data[used_len:]
 927         self.assertEqual(chr(0) * (0x200 - used_len), third)
 928
 929     def testUnknownPosSize(self):
 930         """Test that microcode must be placed within the image"""
 931         with self.assertRaises(ValueError) as e:
 932             self._DoReadFile('41_unknown_pos_size.dts', True)
 933         self.assertIn("Section '/binman': Unable to set offset/size for unknown "
 934                 "entry 'invalid-entry'", str(e.exception))
 935
 936     def testPackFsp(self):
 937         """Test that an image with a FSP binary can be created"""
 938         data = self._DoReadFile('42_intel-fsp.dts')
 939         self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
 940
 941     def testPackCmc(self):
 942         """Test that an image with a CMC binary can be created"""
 943         data = self._DoReadFile('43_intel-cmc.dts')
 944         self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
 945
 946     def testPackVbt(self):
 947         """Test that an image with a VBT binary can be created"""
 948         data = self._DoReadFile('46_intel-vbt.dts')
 949         self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
 950
 951     def testSplBssPad(self):
 952         """Test that we can pad SPL's BSS with zeros"""
 953         # ELF file with a '__bss_size' symbol
 954         with open(self.TestFile('bss_data')) as fd:
 955             TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
 956         data = self._DoReadFile('47_spl_bss_pad.dts')
 957         self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)
 958
 959         with open(self.TestFile('u_boot_ucode_ptr')) as fd:
 960             TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
 961         with self.assertRaises(ValueError) as e:
 962             data = self._DoReadFile('47_spl_bss_pad.dts')
 963         self.assertIn('Expected __bss_size symbol in spl/u-boot-spl',
 964                       str(e.exception))
 965
 966     def testPackStart16Spl(self):
 967         """Test that an image with an x86 start16 region can be created"""
 968         data = self._DoReadFile('48_x86-start16-spl.dts')
 969         self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
 970
 971     def _PackUbootSplMicrocode(self, dts, ucode_second=False):
 972         """Helper function for microcode tests
 973
 974         We expect to see the following in the image, in order:
 975             u-boot-spl-nodtb.bin with a microcode pointer inserted at the
 976                 correct place
 977             u-boot.dtb with the microcode removed
 978             the microcode
 979
 980         Args:
 981             dts: Device tree file to use for test
 982             ucode_second: True if the microsecond entry is second instead of
 983                 third
 984         """
 985         # ELF file with a '_dt_ucode_base_size' symbol
 986         with open(self.TestFile('u_boot_ucode_ptr')) as fd:
 987             TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
 988         first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA,
 989                                                      ucode_second=ucode_second)
 990         self.assertEqual('splnodtb with microc' + pos_and_size +
 991                          'ter somewhere in here', first)
 992
 993     def testPackUbootSplMicrocode(self):
 994         """Test that x86 microcode can be handled correctly in SPL"""
 995         self._PackUbootSplMicrocode('49_x86_ucode_spl.dts')
 996
 997     def testPackUbootSplMicrocodeReorder(self):
 998         """Test that order doesn't matter for microcode entries
 999
1000         This is the same as testPackUbootSplMicrocode but when we process the
1001         u-boot-ucode entry we have not yet seen the u-boot-dtb-with-ucode
1002         entry, so we reply on binman to try later.
1003         """
1004         self._PackUbootSplMicrocode('58_x86_ucode_spl_needs_retry.dts',
1005                                     ucode_second=True)
1006
1007     def testPackMrc(self):
1008         """Test that an image with an MRC binary can be created"""
1009         data = self._DoReadFile('50_intel_mrc.dts')
1010         self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
1011
1012     def testSplDtb(self):
1013         """Test that an image with spl/u-boot-spl.dtb can be created"""
1014         data = self._DoReadFile('51_u_boot_spl_dtb.dts')
1015         self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)])
1016
1017     def testSplNoDtb(self):
1018         """Test that an image with spl/u-boot-spl-nodtb.bin can be created"""
1019         data = self._DoReadFile('52_u_boot_spl_nodtb.dts')
1020         self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)])
1021
1022     def testSymbols(self):
1023         """Test binman can assign symbols embedded in U-Boot"""
1024         elf_fname = self.TestFile('u_boot_binman_syms')
1025         syms = elf.GetSymbols(elf_fname, ['binman', 'image'])
1026         addr = elf.GetSymbolAddress(elf_fname, '__image_copy_start')
1027         self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
1028
1029         with open(self.TestFile('u_boot_binman_syms')) as fd:
1030             TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
1031         data = self._DoReadFile('53_symbols.dts')
1032         sym_values = struct.pack('<LQL', 0x24 + 0, 0x24 + 24, 0x24 + 20)
1033         expected = (sym_values + U_BOOT_SPL_DATA[16:] + chr(0xff) +
1034                     U_BOOT_DATA +
1035                     sym_values + U_BOOT_SPL_DATA[16:])
1036         self.assertEqual(expected, data)
1037
1038     def testPackUnitAddress(self):
1039         """Test that we support multiple binaries with the same name"""
1040         data = self._DoReadFile('54_unit_address.dts')
1041         self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data)
1042
1043     def testSections(self):
1044         """Basic test of sections"""
1045         data = self._DoReadFile('55_sections.dts')
1046         expected = (U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 +
1047                     U_BOOT_DATA + '&' * 4)
1048         self.assertEqual(expected, data)
1049
1050     def testMap(self):
1051         """Tests outputting a map of the images"""
1052         _, _, map_data, _ = self._DoReadFileDtb('55_sections.dts', map=True)
1053         self.assertEqual('''ImagePos    Offset      Size  Name
1054 00000000  00000000  00000028  main-section
1055 00000000   00000000  00000010  section@0
1056 00000000    00000000  00000004  u-boot
1057 00000010   00000010  00000010  section@1
1058 00000010    00000000  00000004  u-boot
1059 00000020   00000020  00000004  section@2
1060 00000020    00000000  00000004  u-boot
1061 ''', map_data)
1062
1063     def testNamePrefix(self):
1064         """Tests that name prefixes are used"""
1065         _, _, map_data, _ = self._DoReadFileDtb('56_name_prefix.dts', map=True)
1066         self.assertEqual('''ImagePos    Offset      Size  Name
1067 00000000  00000000  00000028  main-section
1068 00000000   00000000  00000010  section@0
1069 00000000    00000000  00000004  ro-u-boot
1070 00000010   00000010  00000010  section@1
1071 00000010    00000000  00000004  rw-u-boot
1072 ''', map_data)
1073
1074     def testUnknownContents(self):
1075         """Test that obtaining the contents works as expected"""
1076         with self.assertRaises(ValueError) as e:
1077             self._DoReadFile('57_unknown_contents.dts', True)
1078         self.assertIn("Section '/binman': Internal error: Could not complete "
1079                 "processing of contents: remaining [<_testing.Entry__testing ",
1080                 str(e.exception))
1081
1082     def testBadChangeSize(self):
1083         """Test that trying to change the size of an entry fails"""
1084         with self.assertRaises(ValueError) as e:
1085             self._DoReadFile('59_change_size.dts', True)
1086         self.assertIn("Node '/binman/_testing': Cannot update entry size from "
1087                       '2 to 1', str(e.exception))
1088
1089     def testUpdateFdt(self):
1090         """Test that we can update the device tree with offset/size info"""
1091         _, _, _, out_dtb_fname = self._DoReadFileDtb('60_fdt_update.dts',
1092                                                      update_dtb=True)
1093         dtb = fdt.Fdt(out_dtb_fname)
1094         dtb.Scan()
1095         props = self._GetPropTree(dtb, ['offset', 'size', 'image-pos'])
1096         self.assertEqual({
1097             'image-pos': 0,
1098             'offset': 0,
1099             '_testing:offset': 32,
1100             '_testing:size': 1,
1101             '_testing:image-pos': 32,
1102             'section@0/u-boot:offset': 0,
1103             'section@0/u-boot:size': len(U_BOOT_DATA),
1104             'section@0/u-boot:image-pos': 0,
1105             'section@0:offset': 0,
1106             'section@0:size': 16,
1107             'section@0:image-pos': 0,
1108
1109             'section@1/u-boot:offset': 0,
1110             'section@1/u-boot:size': len(U_BOOT_DATA),
1111             'section@1/u-boot:image-pos': 16,
1112             'section@1:offset': 16,
1113             'section@1:size': 16,
1114             'section@1:image-pos': 16,
1115             'size': 40
1116         }, props)
1117
1118     def testUpdateFdtBad(self):
1119         """Test that we detect when ProcessFdt never completes"""
1120         with self.assertRaises(ValueError) as e:
1121             self._DoReadFileDtb('61_fdt_update_bad.dts', update_dtb=True)
1122         self.assertIn('Could not complete processing of Fdt: remaining '
1123                       '[<_testing.Entry__testing', str(e.exception))
1124
1125     def testEntryArgs(self):
1126         """Test passing arguments to entries from the command line"""
1127         entry_args = {
1128             'test-str-arg': 'test1',
1129             'test-int-arg': '456',
1130         }
1131         self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
1132         self.assertIn('image', control.images)
1133         entry = control.images['image'].GetEntries()['_testing']
1134         self.assertEqual('test0', entry.test_str_fdt)
1135         self.assertEqual('test1', entry.test_str_arg)
1136         self.assertEqual(123, entry.test_int_fdt)
1137         self.assertEqual(456, entry.test_int_arg)
1138
1139     def testEntryArgsMissing(self):
1140         """Test missing arguments and properties"""
1141         entry_args = {
1142             'test-int-arg': '456',
1143         }
1144         self._DoReadFileDtb('63_entry_args_missing.dts', entry_args=entry_args)
1145         entry = control.images['image'].GetEntries()['_testing']
1146         self.assertEqual('test0', entry.test_str_fdt)
1147         self.assertEqual(None, entry.test_str_arg)
1148         self.assertEqual(None, entry.test_int_fdt)
1149         self.assertEqual(456, entry.test_int_arg)
1150
1151     def testEntryArgsRequired(self):
1152         """Test missing arguments and properties"""
1153         entry_args = {
1154             'test-int-arg': '456',
1155         }
1156         with self.assertRaises(ValueError) as e:
1157             self._DoReadFileDtb('64_entry_args_required.dts')
1158         self.assertIn("Node '/binman/_testing': Missing required "
1159             'properties/entry args: test-str-arg, test-int-fdt, test-int-arg',
1160             str(e.exception))
1161
1162     def testEntryArgsInvalidFormat(self):
1163         """Test that an invalid entry-argument format is detected"""
1164         args = ['-d', self.TestFile('64_entry_args_required.dts'), '-ano-value']
1165         with self.assertRaises(ValueError) as e:
1166             self._DoBinman(*args)
1167         self.assertIn("Invalid entry arguemnt 'no-value'", str(e.exception))
1168
1169     def testEntryArgsInvalidInteger(self):
1170         """Test that an invalid entry-argument integer is detected"""
1171         entry_args = {
1172             'test-int-arg': 'abc',
1173         }
1174         with self.assertRaises(ValueError) as e:
1175             self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
1176         self.assertIn("Node '/binman/_testing': Cannot convert entry arg "
1177                       "'test-int-arg' (value 'abc') to integer",
1178             str(e.exception))
1179
1180     def testEntryArgsInvalidDatatype(self):
1181         """Test that an invalid entry-argument datatype is detected
1182
1183         This test could be written in entry_test.py except that it needs
1184         access to control.entry_args, which seems more than that module should
1185         be able to see.
1186         """
1187         entry_args = {
1188             'test-bad-datatype-arg': '12',
1189         }
1190         with self.assertRaises(ValueError) as e:
1191             self._DoReadFileDtb('65_entry_args_unknown_datatype.dts',
1192                                 entry_args=entry_args)
1193         self.assertIn('GetArg() internal error: Unknown data type ',
1194                       str(e.exception))
1195
1196     def testText(self):
1197         """Test for a text entry type"""
1198         entry_args = {
1199             'test-id': TEXT_DATA,
1200             'test-id2': TEXT_DATA2,
1201             'test-id3': TEXT_DATA3,
1202         }
1203         data, _, _, _ = self._DoReadFileDtb('66_text.dts',
1204                                             entry_args=entry_args)
1205         expected = (TEXT_DATA + chr(0) * (8 - len(TEXT_DATA)) + TEXT_DATA2 +
1206                     TEXT_DATA3 + 'some text')
1207         self.assertEqual(expected, data)
1208
1209     def testEntryDocs(self):
1210         """Test for creation of entry documentation"""
1211         with test_util.capture_sys_output() as (stdout, stderr):
1212             control.WriteEntryDocs(binman.GetEntryModules())
1213         self.assertTrue(len(stdout.getvalue()) > 0)
1214
1215     def testEntryDocsMissing(self):
1216         """Test handling of missing entry documentation"""
1217         with self.assertRaises(ValueError) as e:
1218             with test_util.capture_sys_output() as (stdout, stderr):
1219                 control.WriteEntryDocs(binman.GetEntryModules(), 'u_boot')
1220         self.assertIn('Documentation is missing for modules: u_boot',
1221                       str(e.exception))
1222
1223     def testFmap(self):
1224         """Basic test of generation of a flashrom fmap"""
1225         data = self._DoReadFile('67_fmap.dts')
1226         fhdr, fentries = fmap_util.DecodeFmap(data[32:])
1227         expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12
1228         self.assertEqual(expected, data[:32])
1229         self.assertEqual('__FMAP__', fhdr.signature)
1230         self.assertEqual(1, fhdr.ver_major)
1231         self.assertEqual(0, fhdr.ver_minor)
1232         self.assertEqual(0, fhdr.base)
1233         self.assertEqual(16 + 16 +
1234                          fmap_util.FMAP_HEADER_LEN +
1235                          fmap_util.FMAP_AREA_LEN * 3, fhdr.image_size)
1236         self.assertEqual('FMAP', fhdr.name)
1237         self.assertEqual(3, fhdr.nareas)
1238         for fentry in fentries:
1239             self.assertEqual(0, fentry.flags)
1240
1241         self.assertEqual(0, fentries[0].offset)
1242         self.assertEqual(4, fentries[0].size)
1243         self.assertEqual('RO_U_BOOT', fentries[0].name)
1244
1245         self.assertEqual(16, fentries[1].offset)
1246         self.assertEqual(4, fentries[1].size)
1247         self.assertEqual('RW_U_BOOT', fentries[1].name)
1248
1249         self.assertEqual(32, fentries[2].offset)
1250         self.assertEqual(fmap_util.FMAP_HEADER_LEN +
1251                          fmap_util.FMAP_AREA_LEN * 3, fentries[2].size)
1252         self.assertEqual('FMAP', fentries[2].name)
1253
1254     def testBlobNamedByArg(self):
1255         """Test we can add a blob with the filename coming from an entry arg"""
1256         entry_args = {
1257             'cros-ec-rw-path': 'ecrw.bin',
1258         }
1259         data, _, _, _ = self._DoReadFileDtb('68_blob_named_by_arg.dts',
1260                                             entry_args=entry_args)
1261
1262     def testFill(self):
1263         """Test for an fill entry type"""
1264         data = self._DoReadFile('69_fill.dts')
1265         expected = 8 * chr(0xff) + 8 * chr(0)
1266         self.assertEqual(expected, data)
1267
1268     def testFillNoSize(self):
1269         """Test for an fill entry type with no size"""
1270         with self.assertRaises(ValueError) as e:
1271             self._DoReadFile('70_fill_no_size.dts')
1272         self.assertIn("'fill' entry must have a size property",
1273                       str(e.exception))
1274
1275     def _HandleGbbCommand(self, pipe_list):
1276         """Fake calls to the futility utility"""
1277         if pipe_list[0][0] == 'futility':
1278             fname = pipe_list[0][-1]
1279             # Append our GBB data to the file, which will happen every time the
1280             # futility command is called.
1281             with open(fname, 'a') as fd:
1282                 fd.write(GBB_DATA)
1283             return command.CommandResult()
1284
1285     def testGbb(self):
1286         """Test for the Chromium OS Google Binary Block"""
1287         command.test_result = self._HandleGbbCommand
1288         entry_args = {
1289             'keydir': 'devkeys',
1290             'bmpblk': 'bmpblk.bin',
1291         }
1292         data, _, _, _ = self._DoReadFileDtb('71_gbb.dts', entry_args=entry_args)
1293
1294         # Since futility
1295         expected = GBB_DATA + GBB_DATA + 8 * chr(0) + (0x2180 - 16) * chr(0)
1296         self.assertEqual(expected, data)
1297
1298     def testGbbTooSmall(self):
1299         """Test for the Chromium OS Google Binary Block being large enough"""
1300         with self.assertRaises(ValueError) as e:
1301             self._DoReadFileDtb('72_gbb_too_small.dts')
1302         self.assertIn("Node '/binman/gbb': GBB is too small",
1303                       str(e.exception))
1304
1305     def testGbbNoSize(self):
1306         """Test for the Chromium OS Google Binary Block having a size"""
1307         with self.assertRaises(ValueError) as e:
1308             self._DoReadFileDtb('73_gbb_no_size.dts')
1309         self.assertIn("Node '/binman/gbb': GBB must have a fixed size",
1310                       str(e.exception))
1311
1312     def _HandleVblockCommand(self, pipe_list):
1313         """Fake calls to the futility utility"""
1314         if pipe_list[0][0] == 'futility':
1315             fname = pipe_list[0][3]
1316             with open(fname, 'w') as fd:
1317                 fd.write(VBLOCK_DATA)
1318             return command.CommandResult()
1319
1320     def testVblock(self):
1321         """Test for the Chromium OS Verified Boot Block"""
1322         command.test_result = self._HandleVblockCommand
1323         entry_args = {
1324             'keydir': 'devkeys',
1325         }
1326         data, _, _, _ = self._DoReadFileDtb('74_vblock.dts',
1327                                             entry_args=entry_args)
1328         expected = U_BOOT_DATA + VBLOCK_DATA + U_BOOT_DTB_DATA
1329         self.assertEqual(expected, data)
1330
1331     def testVblockNoContent(self):
1332         """Test we detect a vblock which has no content to sign"""
1333         with self.assertRaises(ValueError) as e:
1334             self._DoReadFile('75_vblock_no_content.dts')
1335         self.assertIn("Node '/binman/vblock': Vblock must have a 'content' "
1336                       'property', str(e.exception))
1337
1338     def testVblockBadPhandle(self):
1339         """Test that we detect a vblock with an invalid phandle in contents"""
1340         with self.assertRaises(ValueError) as e:
1341             self._DoReadFile('76_vblock_bad_phandle.dts')
1342         self.assertIn("Node '/binman/vblock': Cannot find node for phandle "
1343                       '1000', str(e.exception))
1344
1345     def testVblockBadEntry(self):
1346         """Test that we detect an entry that points to a non-entry"""
1347         with self.assertRaises(ValueError) as e:
1348             self._DoReadFile('77_vblock_bad_entry.dts')
1349         self.assertIn("Node '/binman/vblock': Cannot find entry for node "
1350                       "'other'", str(e.exception))
1351
1352     def testTpl(self):
1353         """Test that an image with TPL and ots device tree can be created"""
1354         # ELF file with a '__bss_size' symbol
1355         with open(self.TestFile('bss_data')) as fd:
1356             TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
1357         data = self._DoReadFile('78_u_boot_tpl.dts')
1358         self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data)
1359
1360     def testUsesPos(self):
1361         """Test that the 'pos' property cannot be used anymore"""
1362         with self.assertRaises(ValueError) as e:
1363            data = self._DoReadFile('79_uses_pos.dts')
1364         self.assertIn("Node '/binman/u-boot': Please use 'offset' instead of "
1365                       "'pos'", str(e.exception))
1366
1367
1368 if __name__ == "__main__":
1369     unittest.main()