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