1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2016 Google, Inc
3 # Written by Simon Glass <sjg@chromium.org>
5 # To run a single test, change to this directory, and:
7 # python -m unittest func_test.TestFunctional.testHelp
9 from optparse import OptionParser
29 # Contents of test files, corresponding to different entry types
31 U_BOOT_IMG_DATA = 'img'
32 U_BOOT_SPL_DATA = '56780123456789abcde'
33 U_BOOT_TPL_DATA = 'tpl'
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'
51 CROS_EC_RW_DATA = 'ecrw'
57 class TestFunctional(unittest.TestCase):
58 """Functional tests for binman
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
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
68 In some cases a 'real' file must be used - these are also supplied in
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')
80 # Create a temporary directory for input files
81 self._indir = tempfile.mkdtemp(prefix='binmant.')
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)
92 TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA)
93 TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin',
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
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())
111 # Intel flash descriptor file
112 with open(self.TestFile('descriptor.bin')) as fd:
113 TestFunctional._MakeInputFile('descriptor.bin', fd.read())
116 def tearDownClass(self):
117 """Remove the temporary input directory and its contents"""
119 shutil.rmtree(self._indir)
123 # Enable this to turn on debugging output
124 # tout.Init(tout.DEBUG)
125 command.test_result = None
128 """Remove the temporary output directory"""
129 tools._FinaliseForTest()
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)
137 def _RunBinman(self, *args, **kwargs):
138 """Run binman using the command line
141 Arguments to pass, as a list of strings
142 kwargs: Arguments to pass to Command.RunPipe()
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))
151 def _DoBinman(self, *args):
152 """Run binman using directly (in the same process)
155 Arguments to pass, as a list of strings
157 Return value (0 for success)
162 (options, args) = cmdline.ParseArgs(args)
163 options.pager = 'binman-invalid-pager'
164 options.build_dir = self._indir
166 # For testing, you can force an increase in verbosity here
167 # options.verbosity = tout.DEBUG
168 return control.Binman(options, args)
170 def _DoTestFile(self, fname, debug=False, map=False, update_dtb=False,
172 """Run binman with a given test file
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
181 args = ['-p', '-I', self._indir, '-d', self.TestFile(fname)]
189 for arg, value in entry_args.iteritems():
190 args.append('-a%s=%s' % (arg, value))
191 return self._DoBinman(*args)
193 def _SetupDtb(self, fname, outfile='u-boot.dtb'):
194 """Set up a new test device-tree file
196 The given file is compiled and set up as the device tree to be used
200 fname: Filename of .dts file to read
201 outfile: Output filename for compiled device-tree binary
204 Contents of device-tree binary
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:
212 TestFunctional._MakeInputFile(outfile, data)
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
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
223 Raises an assertion failure if binman returns a non-zero exit code.
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
237 Resulting image contents
239 Map data showing contents of image (or None if none)
240 Output device tree binary filename ('u-boot.dtb' path)
243 # Use the compiled test file as the u-boot-dtb input
245 dtb_data = self._SetupDtb(fname)
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')
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))
258 map_fname = tools.GetOutputFilename('image.map')
259 with open(map_fname) as fd:
263 with open(image_fname) as fd:
264 return fd.read(), dtb_data, map_data, out_dtb_fname
266 # Put the test file back
270 def _DoReadFile(self, fname, use_real_dtb=False):
271 """Helper function which discards the device-tree binary
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.
281 Resulting image contents
283 return self._DoReadFileDtb(fname, use_real_dtb)[0]
286 def _MakeInputFile(self, fname, contents):
287 """Create a new test input file, creating directories as needed
290 fname: Filename to create
291 contents: File contents to write in to the file
293 Full pathname of file created
295 pathname = os.path.join(self._indir, fname)
296 dirname = os.path.dirname(pathname)
297 if dirname and not os.path.exists(dirname):
299 with open(pathname, 'wb') as fd:
304 def _MakeInputDir(self, dirname):
305 """Create a new test input directory, creating directories as needed
308 dirname: Directory name to create
311 Full pathname of directory created
313 pathname = os.path.join(self._indir, dirname)
314 if not os.path.exists(pathname):
315 os.makedirs(pathname)
319 def TestFile(self, fname):
320 return os.path.join(self._binman_dir, 'test', fname)
322 def AssertInList(self, grep_list, target):
323 """Assert that at least one of a list of things is in a target
326 grep_list: List of strings to check
327 target: Target string
329 for grep in grep_list:
332 self.fail("Error: '%' not found in '%s'" % (grep_list, target))
334 def CheckNoGaps(self, entries):
335 """Check that all entries fit together without gaps
338 entries: List of entries to check
341 for entry in entries.values():
342 self.assertEqual(offset, entry.offset)
345 def GetFdtLen(self, dtb):
346 """Get the totalsize field from a device-tree binary
349 dtb: Device-tree binary contents
352 Total size of device-tree binary, from the header
354 return struct.unpack('>L', dtb[4:8])[0]
356 def _GetPropTree(self, dtb_data, node_names):
357 def AddNode(node, path):
359 path += '/' + node.name
360 for subnode in node.subnodes:
361 for prop in subnode.props.values():
362 if prop.name in node_names:
363 prop_path = path + '/' + subnode.name + ':' + prop.name
364 tree[prop_path[len('/binman/'):]] = fdt_util.fdt32_to_cpu(
366 AddNode(subnode, path)
369 dtb = fdt.Fdt(dtb_data)
371 AddNode(dtb.GetRoot(), '')
375 """Test a basic run with valid args"""
376 result = self._RunBinman('-h')
378 def testFullHelp(self):
379 """Test that the full help is displayed with -H"""
380 result = self._RunBinman('-H')
381 help_file = os.path.join(self._binman_dir, 'README')
382 # Remove possible extraneous strings
383 extra = '::::::::::::::\n' + help_file + '\n::::::::::::::\n'
384 gothelp = result.stdout.replace(extra, '')
385 self.assertEqual(len(gothelp), os.path.getsize(help_file))
386 self.assertEqual(0, len(result.stderr))
387 self.assertEqual(0, result.return_code)
389 def testFullHelpInternal(self):
390 """Test that the full help is displayed with -H"""
392 command.test_result = command.CommandResult()
393 result = self._DoBinman('-H')
394 help_file = os.path.join(self._binman_dir, 'README')
396 command.test_result = None
399 """Test that the basic help is displayed with -h"""
400 result = self._RunBinman('-h')
401 self.assertTrue(len(result.stdout) > 200)
402 self.assertEqual(0, len(result.stderr))
403 self.assertEqual(0, result.return_code)
406 """Test that we can run it with a specific board"""
407 self._SetupDtb('05_simple.dts', 'sandbox/u-boot.dtb')
408 TestFunctional._MakeInputFile('sandbox/u-boot.bin', U_BOOT_DATA)
409 result = self._DoBinman('-b', 'sandbox')
410 self.assertEqual(0, result)
412 def testNeedBoard(self):
413 """Test that we get an error when no board ius supplied"""
414 with self.assertRaises(ValueError) as e:
415 result = self._DoBinman()
416 self.assertIn("Must provide a board to process (use -b <board>)",
419 def testMissingDt(self):
420 """Test that an invalid device-tree file generates an error"""
421 with self.assertRaises(Exception) as e:
422 self._RunBinman('-d', 'missing_file')
423 # We get one error from libfdt, and a different one from fdtget.
424 self.AssertInList(["Couldn't open blob from 'missing_file'",
425 'No such file or directory'], str(e.exception))
427 def testBrokenDt(self):
428 """Test that an invalid device-tree source file generates an error
430 Since this is a source file it should be compiled and the error
431 will come from the device-tree compiler (dtc).
433 with self.assertRaises(Exception) as e:
434 self._RunBinman('-d', self.TestFile('01_invalid.dts'))
435 self.assertIn("FATAL ERROR: Unable to parse input tree",
438 def testMissingNode(self):
439 """Test that a device tree without a 'binman' node generates an error"""
440 with self.assertRaises(Exception) as e:
441 self._DoBinman('-d', self.TestFile('02_missing_node.dts'))
442 self.assertIn("does not have a 'binman' node", str(e.exception))
445 """Test that an empty binman node works OK (i.e. does nothing)"""
446 result = self._RunBinman('-d', self.TestFile('03_empty.dts'))
447 self.assertEqual(0, len(result.stderr))
448 self.assertEqual(0, result.return_code)
450 def testInvalidEntry(self):
451 """Test that an invalid entry is flagged"""
452 with self.assertRaises(Exception) as e:
453 result = self._RunBinman('-d',
454 self.TestFile('04_invalid_entry.dts'))
455 self.assertIn("Unknown entry type 'not-a-valid-type' in node "
456 "'/binman/not-a-valid-type'", str(e.exception))
458 def testSimple(self):
459 """Test a simple binman with a single file"""
460 data = self._DoReadFile('05_simple.dts')
461 self.assertEqual(U_BOOT_DATA, data)
463 def testSimpleDebug(self):
464 """Test a simple binman run with debugging enabled"""
465 data = self._DoTestFile('05_simple.dts', debug=True)
468 """Test that we can handle creating two images
470 This also tests image padding.
472 retcode = self._DoTestFile('06_dual_image.dts')
473 self.assertEqual(0, retcode)
475 image = control.images['image1']
476 self.assertEqual(len(U_BOOT_DATA), image._size)
477 fname = tools.GetOutputFilename('image1.bin')
478 self.assertTrue(os.path.exists(fname))
479 with open(fname) as fd:
481 self.assertEqual(U_BOOT_DATA, data)
483 image = control.images['image2']
484 self.assertEqual(3 + len(U_BOOT_DATA) + 5, image._size)
485 fname = tools.GetOutputFilename('image2.bin')
486 self.assertTrue(os.path.exists(fname))
487 with open(fname) as fd:
489 self.assertEqual(U_BOOT_DATA, data[3:7])
490 self.assertEqual(chr(0) * 3, data[:3])
491 self.assertEqual(chr(0) * 5, data[7:])
493 def testBadAlign(self):
494 """Test that an invalid alignment value is detected"""
495 with self.assertRaises(ValueError) as e:
496 self._DoTestFile('07_bad_align.dts')
497 self.assertIn("Node '/binman/u-boot': Alignment 23 must be a power "
498 "of two", str(e.exception))
500 def testPackSimple(self):
501 """Test that packing works as expected"""
502 retcode = self._DoTestFile('08_pack.dts')
503 self.assertEqual(0, retcode)
504 self.assertIn('image', control.images)
505 image = control.images['image']
506 entries = image.GetEntries()
507 self.assertEqual(5, len(entries))
510 self.assertIn('u-boot', entries)
511 entry = entries['u-boot']
512 self.assertEqual(0, entry.offset)
513 self.assertEqual(len(U_BOOT_DATA), entry.size)
515 # Second u-boot, aligned to 16-byte boundary
516 self.assertIn('u-boot-align', entries)
517 entry = entries['u-boot-align']
518 self.assertEqual(16, entry.offset)
519 self.assertEqual(len(U_BOOT_DATA), entry.size)
521 # Third u-boot, size 23 bytes
522 self.assertIn('u-boot-size', entries)
523 entry = entries['u-boot-size']
524 self.assertEqual(20, entry.offset)
525 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
526 self.assertEqual(23, entry.size)
528 # Fourth u-boot, placed immediate after the above
529 self.assertIn('u-boot-next', entries)
530 entry = entries['u-boot-next']
531 self.assertEqual(43, entry.offset)
532 self.assertEqual(len(U_BOOT_DATA), entry.size)
534 # Fifth u-boot, placed at a fixed offset
535 self.assertIn('u-boot-fixed', entries)
536 entry = entries['u-boot-fixed']
537 self.assertEqual(61, entry.offset)
538 self.assertEqual(len(U_BOOT_DATA), entry.size)
540 self.assertEqual(65, image._size)
542 def testPackExtra(self):
543 """Test that extra packing feature works as expected"""
544 retcode = self._DoTestFile('09_pack_extra.dts')
546 self.assertEqual(0, retcode)
547 self.assertIn('image', control.images)
548 image = control.images['image']
549 entries = image.GetEntries()
550 self.assertEqual(5, len(entries))
552 # First u-boot with padding before and after
553 self.assertIn('u-boot', entries)
554 entry = entries['u-boot']
555 self.assertEqual(0, entry.offset)
556 self.assertEqual(3, entry.pad_before)
557 self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size)
559 # Second u-boot has an aligned size, but it has no effect
560 self.assertIn('u-boot-align-size-nop', entries)
561 entry = entries['u-boot-align-size-nop']
562 self.assertEqual(12, entry.offset)
563 self.assertEqual(4, entry.size)
565 # Third u-boot has an aligned size too
566 self.assertIn('u-boot-align-size', entries)
567 entry = entries['u-boot-align-size']
568 self.assertEqual(16, entry.offset)
569 self.assertEqual(32, entry.size)
571 # Fourth u-boot has an aligned end
572 self.assertIn('u-boot-align-end', entries)
573 entry = entries['u-boot-align-end']
574 self.assertEqual(48, entry.offset)
575 self.assertEqual(16, entry.size)
577 # Fifth u-boot immediately afterwards
578 self.assertIn('u-boot-align-both', entries)
579 entry = entries['u-boot-align-both']
580 self.assertEqual(64, entry.offset)
581 self.assertEqual(64, entry.size)
583 self.CheckNoGaps(entries)
584 self.assertEqual(128, image._size)
586 def testPackAlignPowerOf2(self):
587 """Test that invalid entry alignment is detected"""
588 with self.assertRaises(ValueError) as e:
589 self._DoTestFile('10_pack_align_power2.dts')
590 self.assertIn("Node '/binman/u-boot': Alignment 5 must be a power "
591 "of two", str(e.exception))
593 def testPackAlignSizePowerOf2(self):
594 """Test that invalid entry size alignment is detected"""
595 with self.assertRaises(ValueError) as e:
596 self._DoTestFile('11_pack_align_size_power2.dts')
597 self.assertIn("Node '/binman/u-boot': Alignment size 55 must be a "
598 "power of two", str(e.exception))
600 def testPackInvalidAlign(self):
601 """Test detection of an offset that does not match its alignment"""
602 with self.assertRaises(ValueError) as e:
603 self._DoTestFile('12_pack_inv_align.dts')
604 self.assertIn("Node '/binman/u-boot': Offset 0x5 (5) does not match "
605 "align 0x4 (4)", str(e.exception))
607 def testPackInvalidSizeAlign(self):
608 """Test that invalid entry size alignment is detected"""
609 with self.assertRaises(ValueError) as e:
610 self._DoTestFile('13_pack_inv_size_align.dts')
611 self.assertIn("Node '/binman/u-boot': Size 0x5 (5) does not match "
612 "align-size 0x4 (4)", str(e.exception))
614 def testPackOverlap(self):
615 """Test that overlapping regions are detected"""
616 with self.assertRaises(ValueError) as e:
617 self._DoTestFile('14_pack_overlap.dts')
618 self.assertIn("Node '/binman/u-boot-align': Offset 0x3 (3) overlaps "
619 "with previous entry '/binman/u-boot' ending at 0x4 (4)",
622 def testPackEntryOverflow(self):
623 """Test that entries that overflow their size are detected"""
624 with self.assertRaises(ValueError) as e:
625 self._DoTestFile('15_pack_overflow.dts')
626 self.assertIn("Node '/binman/u-boot': Entry contents size is 0x4 (4) "
627 "but entry size is 0x3 (3)", str(e.exception))
629 def testPackImageOverflow(self):
630 """Test that entries which overflow the image size are detected"""
631 with self.assertRaises(ValueError) as e:
632 self._DoTestFile('16_pack_image_overflow.dts')
633 self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section "
634 "size 0x3 (3)", str(e.exception))
636 def testPackImageSize(self):
637 """Test that the image size can be set"""
638 retcode = self._DoTestFile('17_pack_image_size.dts')
639 self.assertEqual(0, retcode)
640 self.assertIn('image', control.images)
641 image = control.images['image']
642 self.assertEqual(7, image._size)
644 def testPackImageSizeAlign(self):
645 """Test that image size alignemnt works as expected"""
646 retcode = self._DoTestFile('18_pack_image_align.dts')
647 self.assertEqual(0, retcode)
648 self.assertIn('image', control.images)
649 image = control.images['image']
650 self.assertEqual(16, image._size)
652 def testPackInvalidImageAlign(self):
653 """Test that invalid image alignment is detected"""
654 with self.assertRaises(ValueError) as e:
655 self._DoTestFile('19_pack_inv_image_align.dts')
656 self.assertIn("Section '/binman': Size 0x7 (7) does not match "
657 "align-size 0x8 (8)", str(e.exception))
659 def testPackAlignPowerOf2(self):
660 """Test that invalid image alignment is detected"""
661 with self.assertRaises(ValueError) as e:
662 self._DoTestFile('20_pack_inv_image_align_power2.dts')
663 self.assertIn("Section '/binman': Alignment size 131 must be a power of "
664 "two", str(e.exception))
666 def testImagePadByte(self):
667 """Test that the image pad byte can be specified"""
668 with open(self.TestFile('bss_data')) as fd:
669 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
670 data = self._DoReadFile('21_image_pad.dts')
671 self.assertEqual(U_BOOT_SPL_DATA + (chr(0xff) * 1) + U_BOOT_DATA, data)
673 def testImageName(self):
674 """Test that image files can be named"""
675 retcode = self._DoTestFile('22_image_name.dts')
676 self.assertEqual(0, retcode)
677 image = control.images['image1']
678 fname = tools.GetOutputFilename('test-name')
679 self.assertTrue(os.path.exists(fname))
681 image = control.images['image2']
682 fname = tools.GetOutputFilename('test-name.xx')
683 self.assertTrue(os.path.exists(fname))
685 def testBlobFilename(self):
686 """Test that generic blobs can be provided by filename"""
687 data = self._DoReadFile('23_blob.dts')
688 self.assertEqual(BLOB_DATA, data)
690 def testPackSorted(self):
691 """Test that entries can be sorted"""
692 data = self._DoReadFile('24_sorted.dts')
693 self.assertEqual(chr(0) * 1 + U_BOOT_SPL_DATA + chr(0) * 2 +
696 def testPackZeroOffset(self):
697 """Test that an entry at offset 0 is not given a new offset"""
698 with self.assertRaises(ValueError) as e:
699 self._DoTestFile('25_pack_zero_size.dts')
700 self.assertIn("Node '/binman/u-boot-spl': Offset 0x0 (0) overlaps "
701 "with previous entry '/binman/u-boot' ending at 0x4 (4)",
704 def testPackUbootDtb(self):
705 """Test that a device tree can be added to U-Boot"""
706 data = self._DoReadFile('26_pack_u_boot_dtb.dts')
707 self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA, data)
709 def testPackX86RomNoSize(self):
710 """Test that the end-at-4gb property requires a size property"""
711 with self.assertRaises(ValueError) as e:
712 self._DoTestFile('27_pack_4gb_no_size.dts')
713 self.assertIn("Section '/binman': Section size must be provided when "
714 "using end-at-4gb", str(e.exception))
716 def testPackX86RomOutside(self):
717 """Test that the end-at-4gb property checks for offset boundaries"""
718 with self.assertRaises(ValueError) as e:
719 self._DoTestFile('28_pack_4gb_outside.dts')
720 self.assertIn("Node '/binman/u-boot': Offset 0x0 (0) is outside "
721 "the section starting at 0xffffffe0 (4294967264)",
724 def testPackX86Rom(self):
725 """Test that a basic x86 ROM can be created"""
726 data = self._DoReadFile('29_x86-rom.dts')
727 self.assertEqual(U_BOOT_DATA + chr(0) * 7 + U_BOOT_SPL_DATA +
730 def testPackX86RomMeNoDesc(self):
731 """Test that an invalid Intel descriptor entry is detected"""
732 TestFunctional._MakeInputFile('descriptor.bin', '')
733 with self.assertRaises(ValueError) as e:
734 self._DoTestFile('31_x86-rom-me.dts')
735 self.assertIn("Node '/binman/intel-descriptor': Cannot find FD "
736 "signature", str(e.exception))
738 def testPackX86RomBadDesc(self):
739 """Test that the Intel requires a descriptor entry"""
740 with self.assertRaises(ValueError) as e:
741 self._DoTestFile('30_x86-rom-me-no-desc.dts')
742 self.assertIn("Node '/binman/intel-me': No offset set with "
743 "offset-unset: should another entry provide this correct "
744 "offset?", str(e.exception))
746 def testPackX86RomMe(self):
747 """Test that an x86 ROM with an ME region can be created"""
748 data = self._DoReadFile('31_x86-rom-me.dts')
749 self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
751 def testPackVga(self):
752 """Test that an image with a VGA binary can be created"""
753 data = self._DoReadFile('32_intel-vga.dts')
754 self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
756 def testPackStart16(self):
757 """Test that an image with an x86 start16 region can be created"""
758 data = self._DoReadFile('33_x86-start16.dts')
759 self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
761 def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False):
762 """Handle running a test for insertion of microcode
765 dts_fname: Name of test .dts file
766 nodtb_data: Data that we expect in the first section
767 ucode_second: True if the microsecond entry is second instead of
772 Contents of first region (U-Boot or SPL)
773 Offset and size components of microcode pointer, as inserted
774 in the above (two 4-byte words)
776 data = self._DoReadFile(dts_fname, True)
778 # Now check the device tree has no microcode
780 ucode_content = data[len(nodtb_data):]
781 ucode_pos = len(nodtb_data)
782 dtb_with_ucode = ucode_content[16:]
783 fdt_len = self.GetFdtLen(dtb_with_ucode)
785 dtb_with_ucode = data[len(nodtb_data):]
786 fdt_len = self.GetFdtLen(dtb_with_ucode)
787 ucode_content = dtb_with_ucode[fdt_len:]
788 ucode_pos = len(nodtb_data) + fdt_len
789 fname = tools.GetOutputFilename('test.dtb')
790 with open(fname, 'wb') as fd:
791 fd.write(dtb_with_ucode)
792 dtb = fdt.FdtScan(fname)
793 ucode = dtb.GetNode('/microcode')
794 self.assertTrue(ucode)
795 for node in ucode.subnodes:
796 self.assertFalse(node.props.get('data'))
798 # Check that the microcode appears immediately after the Fdt
799 # This matches the concatenation of the data properties in
800 # the /microcode/update@xxx nodes in 34_x86_ucode.dts.
801 ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000,
803 self.assertEqual(ucode_data, ucode_content[:len(ucode_data)])
805 # Check that the microcode pointer was inserted. It should match the
806 # expected offset and size
807 pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
809 u_boot = data[:len(nodtb_data)]
810 return u_boot, pos_and_size
812 def testPackUbootMicrocode(self):
813 """Test that x86 microcode can be handled correctly
815 We expect to see the following in the image, in order:
816 u-boot-nodtb.bin with a microcode pointer inserted at the correct
818 u-boot.dtb with the microcode removed
821 first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts',
823 self.assertEqual('nodtb with microcode' + pos_and_size +
824 ' somewhere in here', first)
826 def _RunPackUbootSingleMicrocode(self):
827 """Test that x86 microcode can be handled correctly
829 We expect to see the following in the image, in order:
830 u-boot-nodtb.bin with a microcode pointer inserted at the correct
832 u-boot.dtb with the microcode
833 an empty microcode region
835 # We need the libfdt library to run this test since only that allows
836 # finding the offset of a property. This is required by
837 # Entry_u_boot_dtb_with_ucode.ObtainContents().
838 data = self._DoReadFile('35_x86_single_ucode.dts', True)
840 second = data[len(U_BOOT_NODTB_DATA):]
842 fdt_len = self.GetFdtLen(second)
843 third = second[fdt_len:]
844 second = second[:fdt_len]
846 ucode_data = struct.pack('>2L', 0x12345678, 0x12345679)
847 self.assertIn(ucode_data, second)
848 ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
850 # Check that the microcode pointer was inserted. It should match the
851 # expected offset and size
852 pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
854 first = data[:len(U_BOOT_NODTB_DATA)]
855 self.assertEqual('nodtb with microcode' + pos_and_size +
856 ' somewhere in here', first)
858 def testPackUbootSingleMicrocode(self):
859 """Test that x86 microcode can be handled correctly with fdt_normal.
861 self._RunPackUbootSingleMicrocode()
863 def testUBootImg(self):
864 """Test that u-boot.img can be put in a file"""
865 data = self._DoReadFile('36_u_boot_img.dts')
866 self.assertEqual(U_BOOT_IMG_DATA, data)
868 def testNoMicrocode(self):
869 """Test that a missing microcode region is detected"""
870 with self.assertRaises(ValueError) as e:
871 self._DoReadFile('37_x86_no_ucode.dts', True)
872 self.assertIn("Node '/binman/u-boot-dtb-with-ucode': No /microcode "
873 "node found in ", str(e.exception))
875 def testMicrocodeWithoutNode(self):
876 """Test that a missing u-boot-dtb-with-ucode node is detected"""
877 with self.assertRaises(ValueError) as e:
878 self._DoReadFile('38_x86_ucode_missing_node.dts', True)
879 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
880 "microcode region u-boot-dtb-with-ucode", str(e.exception))
882 def testMicrocodeWithoutNode2(self):
883 """Test that a missing u-boot-ucode node is detected"""
884 with self.assertRaises(ValueError) as e:
885 self._DoReadFile('39_x86_ucode_missing_node2.dts', True)
886 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
887 "microcode region u-boot-ucode", str(e.exception))
889 def testMicrocodeWithoutPtrInElf(self):
890 """Test that a U-Boot binary without the microcode symbol is detected"""
891 # ELF file without a '_dt_ucode_base_size' symbol
893 with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
894 TestFunctional._MakeInputFile('u-boot', fd.read())
896 with self.assertRaises(ValueError) as e:
897 self._RunPackUbootSingleMicrocode()
898 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate "
899 "_dt_ucode_base_size symbol in u-boot", str(e.exception))
902 # Put the original file back
903 with open(self.TestFile('u_boot_ucode_ptr')) as fd:
904 TestFunctional._MakeInputFile('u-boot', fd.read())
906 def testMicrocodeNotInImage(self):
907 """Test that microcode must be placed within the image"""
908 with self.assertRaises(ValueError) as e:
909 self._DoReadFile('40_x86_ucode_not_in_image.dts', True)
910 self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode "
911 "pointer _dt_ucode_base_size at fffffe14 is outside the "
912 "section ranging from 00000000 to 0000002e", str(e.exception))
914 def testWithoutMicrocode(self):
915 """Test that we can cope with an image without microcode (e.g. qemu)"""
916 with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
917 TestFunctional._MakeInputFile('u-boot', fd.read())
918 data, dtb, _, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)
920 # Now check the device tree has no microcode
921 self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
922 second = data[len(U_BOOT_NODTB_DATA):]
924 fdt_len = self.GetFdtLen(second)
925 self.assertEqual(dtb, second[:fdt_len])
927 used_len = len(U_BOOT_NODTB_DATA) + fdt_len
928 third = data[used_len:]
929 self.assertEqual(chr(0) * (0x200 - used_len), third)
931 def testUnknownPosSize(self):
932 """Test that microcode must be placed within the image"""
933 with self.assertRaises(ValueError) as e:
934 self._DoReadFile('41_unknown_pos_size.dts', True)
935 self.assertIn("Section '/binman': Unable to set offset/size for unknown "
936 "entry 'invalid-entry'", str(e.exception))
938 def testPackFsp(self):
939 """Test that an image with a FSP binary can be created"""
940 data = self._DoReadFile('42_intel-fsp.dts')
941 self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
943 def testPackCmc(self):
944 """Test that an image with a CMC binary can be created"""
945 data = self._DoReadFile('43_intel-cmc.dts')
946 self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
948 def testPackVbt(self):
949 """Test that an image with a VBT binary can be created"""
950 data = self._DoReadFile('46_intel-vbt.dts')
951 self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
953 def testSplBssPad(self):
954 """Test that we can pad SPL's BSS with zeros"""
955 # ELF file with a '__bss_size' symbol
956 with open(self.TestFile('bss_data')) as fd:
957 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
958 data = self._DoReadFile('47_spl_bss_pad.dts')
959 self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)
961 with open(self.TestFile('u_boot_ucode_ptr')) as fd:
962 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
963 with self.assertRaises(ValueError) as e:
964 data = self._DoReadFile('47_spl_bss_pad.dts')
965 self.assertIn('Expected __bss_size symbol in spl/u-boot-spl',
968 def testPackStart16Spl(self):
969 """Test that an image with an x86 start16 region can be created"""
970 data = self._DoReadFile('48_x86-start16-spl.dts')
971 self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
973 def _PackUbootSplMicrocode(self, dts, ucode_second=False):
974 """Helper function for microcode tests
976 We expect to see the following in the image, in order:
977 u-boot-spl-nodtb.bin with a microcode pointer inserted at the
979 u-boot.dtb with the microcode removed
983 dts: Device tree file to use for test
984 ucode_second: True if the microsecond entry is second instead of
987 # ELF file with a '_dt_ucode_base_size' symbol
988 with open(self.TestFile('u_boot_ucode_ptr')) as fd:
989 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
990 first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA,
991 ucode_second=ucode_second)
992 self.assertEqual('splnodtb with microc' + pos_and_size +
993 'ter somewhere in here', first)
995 def testPackUbootSplMicrocode(self):
996 """Test that x86 microcode can be handled correctly in SPL"""
997 self._PackUbootSplMicrocode('49_x86_ucode_spl.dts')
999 def testPackUbootSplMicrocodeReorder(self):
1000 """Test that order doesn't matter for microcode entries
1002 This is the same as testPackUbootSplMicrocode but when we process the
1003 u-boot-ucode entry we have not yet seen the u-boot-dtb-with-ucode
1004 entry, so we reply on binman to try later.
1006 self._PackUbootSplMicrocode('58_x86_ucode_spl_needs_retry.dts',
1009 def testPackMrc(self):
1010 """Test that an image with an MRC binary can be created"""
1011 data = self._DoReadFile('50_intel_mrc.dts')
1012 self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
1014 def testSplDtb(self):
1015 """Test that an image with spl/u-boot-spl.dtb can be created"""
1016 data = self._DoReadFile('51_u_boot_spl_dtb.dts')
1017 self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)])
1019 def testSplNoDtb(self):
1020 """Test that an image with spl/u-boot-spl-nodtb.bin can be created"""
1021 data = self._DoReadFile('52_u_boot_spl_nodtb.dts')
1022 self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)])
1024 def testSymbols(self):
1025 """Test binman can assign symbols embedded in U-Boot"""
1026 elf_fname = self.TestFile('u_boot_binman_syms')
1027 syms = elf.GetSymbols(elf_fname, ['binman', 'image'])
1028 addr = elf.GetSymbolAddress(elf_fname, '__image_copy_start')
1029 self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
1031 with open(self.TestFile('u_boot_binman_syms')) as fd:
1032 TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read())
1033 data = self._DoReadFile('53_symbols.dts')
1034 sym_values = struct.pack('<LQL', 0x24 + 0, 0x24 + 24, 0x24 + 20)
1035 expected = (sym_values + U_BOOT_SPL_DATA[16:] + chr(0xff) +
1037 sym_values + U_BOOT_SPL_DATA[16:])
1038 self.assertEqual(expected, data)
1040 def testPackUnitAddress(self):
1041 """Test that we support multiple binaries with the same name"""
1042 data = self._DoReadFile('54_unit_address.dts')
1043 self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data)
1045 def testSections(self):
1046 """Basic test of sections"""
1047 data = self._DoReadFile('55_sections.dts')
1048 expected = (U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 +
1049 U_BOOT_DATA + '&' * 4)
1050 self.assertEqual(expected, data)
1053 """Tests outputting a map of the images"""
1054 _, _, map_data, _ = self._DoReadFileDtb('55_sections.dts', map=True)
1055 self.assertEqual('''ImagePos Offset Size Name
1056 00000000 00000000 00000028 main-section
1057 00000000 00000000 00000010 section@0
1058 00000000 00000000 00000004 u-boot
1059 00000010 00000010 00000010 section@1
1060 00000010 00000000 00000004 u-boot
1061 00000020 00000020 00000004 section@2
1062 00000020 00000000 00000004 u-boot
1065 def testNamePrefix(self):
1066 """Tests that name prefixes are used"""
1067 _, _, map_data, _ = self._DoReadFileDtb('56_name_prefix.dts', map=True)
1068 self.assertEqual('''ImagePos Offset Size Name
1069 00000000 00000000 00000028 main-section
1070 00000000 00000000 00000010 section@0
1071 00000000 00000000 00000004 ro-u-boot
1072 00000010 00000010 00000010 section@1
1073 00000010 00000000 00000004 rw-u-boot
1076 def testUnknownContents(self):
1077 """Test that obtaining the contents works as expected"""
1078 with self.assertRaises(ValueError) as e:
1079 self._DoReadFile('57_unknown_contents.dts', True)
1080 self.assertIn("Section '/binman': Internal error: Could not complete "
1081 "processing of contents: remaining [<_testing.Entry__testing ",
1084 def testBadChangeSize(self):
1085 """Test that trying to change the size of an entry fails"""
1086 with self.assertRaises(ValueError) as e:
1087 self._DoReadFile('59_change_size.dts', True)
1088 self.assertIn("Node '/binman/_testing': Cannot update entry size from "
1089 '2 to 1', str(e.exception))
1091 def testUpdateFdt(self):
1092 """Test that we can update the device tree with offset/size info"""
1093 _, _, _, out_dtb_fname = self._DoReadFileDtb('60_fdt_update.dts',
1095 props = self._GetPropTree(out_dtb_fname, ['offset', 'size',
1097 with open('/tmp/x.dtb', 'wb') as outf:
1098 with open(out_dtb_fname) as inf:
1099 outf.write(inf.read())
1103 '_testing:offset': 32,
1105 '_testing:image-pos': 32,
1106 'section@0/u-boot:offset': 0,
1107 'section@0/u-boot:size': len(U_BOOT_DATA),
1108 'section@0/u-boot:image-pos': 0,
1109 'section@0:offset': 0,
1110 'section@0:size': 16,
1111 'section@0:image-pos': 0,
1113 'section@1/u-boot:offset': 0,
1114 'section@1/u-boot:size': len(U_BOOT_DATA),
1115 'section@1/u-boot:image-pos': 16,
1116 'section@1:offset': 16,
1117 'section@1:size': 16,
1118 'section@1:image-pos': 16,
1122 def testUpdateFdtBad(self):
1123 """Test that we detect when ProcessFdt never completes"""
1124 with self.assertRaises(ValueError) as e:
1125 self._DoReadFileDtb('61_fdt_update_bad.dts', update_dtb=True)
1126 self.assertIn('Could not complete processing of Fdt: remaining '
1127 '[<_testing.Entry__testing', str(e.exception))
1129 def testEntryArgs(self):
1130 """Test passing arguments to entries from the command line"""
1132 'test-str-arg': 'test1',
1133 'test-int-arg': '456',
1135 self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
1136 self.assertIn('image', control.images)
1137 entry = control.images['image'].GetEntries()['_testing']
1138 self.assertEqual('test0', entry.test_str_fdt)
1139 self.assertEqual('test1', entry.test_str_arg)
1140 self.assertEqual(123, entry.test_int_fdt)
1141 self.assertEqual(456, entry.test_int_arg)
1143 def testEntryArgsMissing(self):
1144 """Test missing arguments and properties"""
1146 'test-int-arg': '456',
1148 self._DoReadFileDtb('63_entry_args_missing.dts', entry_args=entry_args)
1149 entry = control.images['image'].GetEntries()['_testing']
1150 self.assertEqual('test0', entry.test_str_fdt)
1151 self.assertEqual(None, entry.test_str_arg)
1152 self.assertEqual(None, entry.test_int_fdt)
1153 self.assertEqual(456, entry.test_int_arg)
1155 def testEntryArgsRequired(self):
1156 """Test missing arguments and properties"""
1158 'test-int-arg': '456',
1160 with self.assertRaises(ValueError) as e:
1161 self._DoReadFileDtb('64_entry_args_required.dts')
1162 self.assertIn("Node '/binman/_testing': Missing required "
1163 'properties/entry args: test-str-arg, test-int-fdt, test-int-arg',
1166 def testEntryArgsInvalidFormat(self):
1167 """Test that an invalid entry-argument format is detected"""
1168 args = ['-d', self.TestFile('64_entry_args_required.dts'), '-ano-value']
1169 with self.assertRaises(ValueError) as e:
1170 self._DoBinman(*args)
1171 self.assertIn("Invalid entry arguemnt 'no-value'", str(e.exception))
1173 def testEntryArgsInvalidInteger(self):
1174 """Test that an invalid entry-argument integer is detected"""
1176 'test-int-arg': 'abc',
1178 with self.assertRaises(ValueError) as e:
1179 self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
1180 self.assertIn("Node '/binman/_testing': Cannot convert entry arg "
1181 "'test-int-arg' (value 'abc') to integer",
1184 def testEntryArgsInvalidDatatype(self):
1185 """Test that an invalid entry-argument datatype is detected
1187 This test could be written in entry_test.py except that it needs
1188 access to control.entry_args, which seems more than that module should
1192 'test-bad-datatype-arg': '12',
1194 with self.assertRaises(ValueError) as e:
1195 self._DoReadFileDtb('65_entry_args_unknown_datatype.dts',
1196 entry_args=entry_args)
1197 self.assertIn('GetArg() internal error: Unknown data type ',
1201 """Test for a text entry type"""
1203 'test-id': TEXT_DATA,
1204 'test-id2': TEXT_DATA2,
1205 'test-id3': TEXT_DATA3,
1207 data, _, _, _ = self._DoReadFileDtb('66_text.dts',
1208 entry_args=entry_args)
1209 expected = (TEXT_DATA + chr(0) * (8 - len(TEXT_DATA)) + TEXT_DATA2 +
1210 TEXT_DATA3 + 'some text')
1211 self.assertEqual(expected, data)
1213 def testEntryDocs(self):
1214 """Test for creation of entry documentation"""
1215 with test_util.capture_sys_output() as (stdout, stderr):
1216 control.WriteEntryDocs(binman.GetEntryModules())
1217 self.assertTrue(len(stdout.getvalue()) > 0)
1219 def testEntryDocsMissing(self):
1220 """Test handling of missing entry documentation"""
1221 with self.assertRaises(ValueError) as e:
1222 with test_util.capture_sys_output() as (stdout, stderr):
1223 control.WriteEntryDocs(binman.GetEntryModules(), 'u_boot')
1224 self.assertIn('Documentation is missing for modules: u_boot',
1228 """Basic test of generation of a flashrom fmap"""
1229 data = self._DoReadFile('67_fmap.dts')
1230 fhdr, fentries = fmap_util.DecodeFmap(data[32:])
1231 expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12
1232 self.assertEqual(expected, data[:32])
1233 self.assertEqual('__FMAP__', fhdr.signature)
1234 self.assertEqual(1, fhdr.ver_major)
1235 self.assertEqual(0, fhdr.ver_minor)
1236 self.assertEqual(0, fhdr.base)
1237 self.assertEqual(16 + 16 +
1238 fmap_util.FMAP_HEADER_LEN +
1239 fmap_util.FMAP_AREA_LEN * 3, fhdr.image_size)
1240 self.assertEqual('FMAP', fhdr.name)
1241 self.assertEqual(3, fhdr.nareas)
1242 for fentry in fentries:
1243 self.assertEqual(0, fentry.flags)
1245 self.assertEqual(0, fentries[0].offset)
1246 self.assertEqual(4, fentries[0].size)
1247 self.assertEqual('RO_U_BOOT', fentries[0].name)
1249 self.assertEqual(16, fentries[1].offset)
1250 self.assertEqual(4, fentries[1].size)
1251 self.assertEqual('RW_U_BOOT', fentries[1].name)
1253 self.assertEqual(32, fentries[2].offset)
1254 self.assertEqual(fmap_util.FMAP_HEADER_LEN +
1255 fmap_util.FMAP_AREA_LEN * 3, fentries[2].size)
1256 self.assertEqual('FMAP', fentries[2].name)
1258 def testBlobNamedByArg(self):
1259 """Test we can add a blob with the filename coming from an entry arg"""
1261 'cros-ec-rw-path': 'ecrw.bin',
1263 data, _, _, _ = self._DoReadFileDtb('68_blob_named_by_arg.dts',
1264 entry_args=entry_args)
1267 """Test for an fill entry type"""
1268 data = self._DoReadFile('69_fill.dts')
1269 expected = 8 * chr(0xff) + 8 * chr(0)
1270 self.assertEqual(expected, data)
1272 def testFillNoSize(self):
1273 """Test for an fill entry type with no size"""
1274 with self.assertRaises(ValueError) as e:
1275 self._DoReadFile('70_fill_no_size.dts')
1276 self.assertIn("'fill' entry must have a size property",
1279 def _HandleGbbCommand(self, pipe_list):
1280 """Fake calls to the futility utility"""
1281 if pipe_list[0][0] == 'futility':
1282 fname = pipe_list[0][-1]
1283 # Append our GBB data to the file, which will happen every time the
1284 # futility command is called.
1285 with open(fname, 'a') as fd:
1287 return command.CommandResult()
1290 """Test for the Chromium OS Google Binary Block"""
1291 command.test_result = self._HandleGbbCommand
1293 'keydir': 'devkeys',
1294 'bmpblk': 'bmpblk.bin',
1296 data, _, _, _ = self._DoReadFileDtb('71_gbb.dts', entry_args=entry_args)
1299 expected = GBB_DATA + GBB_DATA + 8 * chr(0) + (0x2180 - 16) * chr(0)
1300 self.assertEqual(expected, data)
1302 def testGbbTooSmall(self):
1303 """Test for the Chromium OS Google Binary Block being large enough"""
1304 with self.assertRaises(ValueError) as e:
1305 self._DoReadFileDtb('72_gbb_too_small.dts')
1306 self.assertIn("Node '/binman/gbb': GBB is too small",
1309 def testGbbNoSize(self):
1310 """Test for the Chromium OS Google Binary Block having a size"""
1311 with self.assertRaises(ValueError) as e:
1312 self._DoReadFileDtb('73_gbb_no_size.dts')
1313 self.assertIn("Node '/binman/gbb': GBB must have a fixed size",
1316 def _HandleVblockCommand(self, pipe_list):
1317 """Fake calls to the futility utility"""
1318 if pipe_list[0][0] == 'futility':
1319 fname = pipe_list[0][3]
1320 with open(fname, 'w') as fd:
1321 fd.write(VBLOCK_DATA)
1322 return command.CommandResult()
1324 def testVblock(self):
1325 """Test for the Chromium OS Verified Boot Block"""
1326 command.test_result = self._HandleVblockCommand
1328 'keydir': 'devkeys',
1330 data, _, _, _ = self._DoReadFileDtb('74_vblock.dts',
1331 entry_args=entry_args)
1332 expected = U_BOOT_DATA + VBLOCK_DATA + U_BOOT_DTB_DATA
1333 self.assertEqual(expected, data)
1335 def testVblockNoContent(self):
1336 """Test we detect a vblock which has no content to sign"""
1337 with self.assertRaises(ValueError) as e:
1338 self._DoReadFile('75_vblock_no_content.dts')
1339 self.assertIn("Node '/binman/vblock': Vblock must have a 'content' "
1340 'property', str(e.exception))
1342 def testVblockBadPhandle(self):
1343 """Test that we detect a vblock with an invalid phandle in contents"""
1344 with self.assertRaises(ValueError) as e:
1345 self._DoReadFile('76_vblock_bad_phandle.dts')
1346 self.assertIn("Node '/binman/vblock': Cannot find node for phandle "
1347 '1000', str(e.exception))
1349 def testVblockBadEntry(self):
1350 """Test that we detect an entry that points to a non-entry"""
1351 with self.assertRaises(ValueError) as e:
1352 self._DoReadFile('77_vblock_bad_entry.dts')
1353 self.assertIn("Node '/binman/vblock': Cannot find entry for node "
1354 "'other'", str(e.exception))
1357 """Test that an image with TPL and ots device tree can be created"""
1358 # ELF file with a '__bss_size' symbol
1359 with open(self.TestFile('bss_data')) as fd:
1360 TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
1361 data = self._DoReadFile('78_u_boot_tpl.dts')
1362 self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data)
1364 def testUsesPos(self):
1365 """Test that the 'pos' property cannot be used anymore"""
1366 with self.assertRaises(ValueError) as e:
1367 data = self._DoReadFile('79_uses_pos.dts')
1368 self.assertIn("Node '/binman/u-boot': Please use 'offset' instead of "
1369 "'pos'", str(e.exception))
1372 if __name__ == "__main__":