xref: /u-boot/tools/binman/ftest.py

227     def _CheckLz4(self):  argument
228         if not self.have_lz4:
229             self.skipTest('lz4 --no-frame-crc not available')
231     def _CleanupOutputDir(self):  argument
233         if self.preserve_outdirs:
238     def setUp(self):  argument
243     def tearDown(self):  argument
245         self._CleanupOutputDir()
247     def _SetupImageInTmpdir(self):  argument
266         self._CleanupOutputDir()
275     def _RunBinman(self, *args, **kwargs):  argument
282         result = command.RunPipe([[self._binman_pathname] + list(args)],
289     def _DoBinman(self, *argv):  argument
300         args.build_dir = self._indir
306     def _DoTestFile(self, fname, debug=False, map=False, update_dtb=False,  argument
335         elif self.verbosity:
336             args.append('-v%d' % self.verbosity)
337         if self.toolpath:
338             for path in self.toolpath:
340         args += ['build', '-p', '-I', self._indir, '-d', self.TestFile(fname)]
358         return self._DoBinman(*args)
360     def _SetupDtb(self, fname, outfile='u-boot.dtb'):  argument
374         dtb = fdt_util.EnsureCompiled(self.TestFile(fname), tmpdir)
381     def _GetDtbContentsForSplTpl(self, dtb_data, name):  argument
406     def _DoReadFileDtb(self, fname, use_real_dtb=False, map=False,  argument
444             dtb_data = self._SetupDtb(fname)
450                 outfile = os.path.join(self._indir, dtb_fname)
452                         self._GetDtbContentsForSplTpl(dtb_data, name))
455             retcode = self._DoTestFile(fname, map=map, update_dtb=update_dtb,
458             self.assertEqual(0, retcode)
464             self.assertTrue(os.path.exists(image_fname))
476                 self._ResetDtbs()
478     def _DoReadFileRealDtb(self, fname):  argument
487         return self._DoReadFileDtb(fname, use_real_dtb=True, update_dtb=True)[0]
489     def _DoReadFile(self, fname, use_real_dtb=False):  argument
502         return self._DoReadFileDtb(fname, use_real_dtb)[0]
570     def AssertInList(self, grep_list, target):  argument
580         self.fail("Error: '%s' not found in '%s'" % (grep_list, target))
582     def CheckNoGaps(self, entries):  argument
590             self.assertEqual(offset, entry.offset)
593     def GetFdtLen(self, dtb):  argument
604     def _GetPropTree(self, dtb, prop_names, prefix='/binman/'):  argument
620     def testRun(self):  argument
622         result = self._RunBinman('-h')
624     def testFullHelp(self):  argument
626         result = self._RunBinman('-H')
627         help_file = os.path.join(self._binman_dir, 'README')
631         self.assertEqual(len(gothelp), os.path.getsize(help_file))
632         self.assertEqual(0, len(result.stderr))
633         self.assertEqual(0, result.return_code)
635     def testFullHelpInternal(self):  argument
639             result = self._DoBinman('-H')
640             help_file = os.path.join(self._binman_dir, 'README')
644     def testHelp(self):  argument
646         result = self._RunBinman('-h')
647         self.assertTrue(len(result.stdout) > 200)
648         self.assertEqual(0, len(result.stderr))
649         self.assertEqual(0, result.return_code)
651     def testBoard(self):  argument
653         self._SetupDtb('005_simple.dts', 'sandbox/u-boot.dtb')
655         result = self._DoBinman('build', '-b', 'sandbox')
656         self.assertEqual(0, result)
658     def testNeedBoard(self):  argument
660         with self.assertRaises(ValueError) as e:
661             result = self._DoBinman('build')
662         self.assertIn("Must provide a board to process (use -b <board>)",
665     def testMissingDt(self):  argument
667         with self.assertRaises(Exception) as e:
668             self._RunBinman('build', '-d', 'missing_file')
670         self.AssertInList(["Couldn't open blob from 'missing_file'",
673     def testBrokenDt(self):  argument
679         with self.assertRaises(Exception) as e:
680             self._RunBinman('build', '-d', self.TestFile('001_invalid.dts'))
681         self.assertIn("FATAL ERROR: Unable to parse input tree",
684     def testMissingNode(self):  argument
686         with self.assertRaises(Exception) as e:
687             self._DoBinman('build', '-d', self.TestFile('002_missing_node.dts'))
688         self.assertIn("does not have a 'binman' node", str(e.exception))
690     def testEmpty(self):  argument
692         result = self._RunBinman('build', '-d', self.TestFile('003_empty.dts'))
693         self.assertEqual(0, len(result.stderr))
694         self.assertEqual(0, result.return_code)
696     def testInvalidEntry(self):  argument
698         with self.assertRaises(Exception) as e:
699             result = self._RunBinman('build', '-d',
700                                      self.TestFile('004_invalid_entry.dts'))
701         self.assertIn("Unknown entry type 'not-a-valid-type' in node "
704     def testSimple(self):  argument
706         data = self._DoReadFile('005_simple.dts')
707         self.assertEqual(U_BOOT_DATA, data)
709     def testSimpleDebug(self):  argument
711         self._DoTestFile('005_simple.dts', debug=True)
713     def testDual(self):  argument
718         retcode = self._DoTestFile('006_dual_image.dts')
719         self.assertEqual(0, retcode)
722         self.assertEqual(len(U_BOOT_DATA), image.size)
724         self.assertTrue(os.path.exists(fname))
727             self.assertEqual(U_BOOT_DATA, data)
730         self.assertEqual(3 + len(U_BOOT_DATA) + 5, image.size)
732         self.assertTrue(os.path.exists(fname))
735             self.assertEqual(U_BOOT_DATA, data[3:7])
736             self.assertEqual(tools.GetBytes(0, 3), data[:3])
737             self.assertEqual(tools.GetBytes(0, 5), data[7:])
739     def testBadAlign(self):  argument
741         with self.assertRaises(ValueError) as e:
742             self._DoTestFile('007_bad_align.dts')
743         self.assertIn("Node '/binman/u-boot': Alignment 23 must be a power "
746     def testPackSimple(self):  argument
748         retcode = self._DoTestFile('008_pack.dts')
749         self.assertEqual(0, retcode)
750         self.assertIn('image', control.images)
753         self.assertEqual(5, len(entries))
756         self.assertIn('u-boot', entries)
758         self.assertEqual(0, entry.offset)
759         self.assertEqual(len(U_BOOT_DATA), entry.size)
762         self.assertIn('u-boot-align', entries)
764         self.assertEqual(16, entry.offset)
765         self.assertEqual(len(U_BOOT_DATA), entry.size)
768         self.assertIn('u-boot-size', entries)
770         self.assertEqual(20, entry.offset)
771         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
772         self.assertEqual(23, entry.size)
775         self.assertIn('u-boot-next', entries)
777         self.assertEqual(43, entry.offset)
778         self.assertEqual(len(U_BOOT_DATA), entry.size)
781         self.assertIn('u-boot-fixed', entries)
783         self.assertEqual(61, entry.offset)
784         self.assertEqual(len(U_BOOT_DATA), entry.size)
786         self.assertEqual(65, image.size)
788     def testPackExtra(self):  argument
790         data, _, _, out_dtb_fname = self._DoReadFileDtb('009_pack_extra.dts',
793         self.assertIn('image', control.images)
796         self.assertEqual(5, len(entries))
799         self.assertIn('u-boot', entries)
801         self.assertEqual(0, entry.offset)
802         self.assertEqual(3, entry.pad_before)
803         self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size)
804         self.assertEqual(U_BOOT_DATA, entry.data)
805         self.assertEqual(tools.GetBytes(0, 3) + U_BOOT_DATA +
810         self.assertIn('u-boot-align-size-nop', entries)
812         self.assertEqual(pos, entry.offset)
813         self.assertEqual(len(U_BOOT_DATA), entry.size)
814         self.assertEqual(U_BOOT_DATA, entry.data)
815         self.assertEqual(U_BOOT_DATA, data[pos:pos + entry.size])
819         self.assertIn('u-boot-align-size', entries)
821         self.assertEqual(pos, entry.offset)
822         self.assertEqual(32, entry.size)
823         self.assertEqual(U_BOOT_DATA, entry.data)
824         self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 32 - len(U_BOOT_DATA)),
829         self.assertIn('u-boot-align-end', entries)
831         self.assertEqual(48, entry.offset)
832         self.assertEqual(16, entry.size)
833         self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
834         self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 16 - len(U_BOOT_DATA)),
839         self.assertIn('u-boot-align-both', entries)
841         self.assertEqual(64, entry.offset)
842         self.assertEqual(64, entry.size)
843         self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
844         self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 64 - len(U_BOOT_DATA)),
847         self.CheckNoGaps(entries)
848         self.assertEqual(128, image.size)
852         props = self._GetPropTree(dtb, ['size', 'offset', 'image-pos'])
878         self.assertEqual(expected, props)
880     def testPackAlignPowerOf2(self):  argument
882         with self.assertRaises(ValueError) as e:
883             self._DoTestFile('010_pack_align_power2.dts')
884         self.assertIn("Node '/binman/u-boot': Alignment 5 must be a power "
887     def testPackAlignSizePowerOf2(self):  argument
889         with self.assertRaises(ValueError) as e:
890             self._DoTestFile('011_pack_align_size_power2.dts')
891         self.assertIn("Node '/binman/u-boot': Alignment size 55 must be a "
894     def testPackInvalidAlign(self):  argument
896         with self.assertRaises(ValueError) as e:
897             self._DoTestFile('012_pack_inv_align.dts')
898         self.assertIn("Node '/binman/u-boot': Offset 0x5 (5) does not match "
901     def testPackInvalidSizeAlign(self):  argument
903         with self.assertRaises(ValueError) as e:
904             self._DoTestFile('013_pack_inv_size_align.dts')
905         self.assertIn("Node '/binman/u-boot': Size 0x5 (5) does not match "
908     def testPackOverlap(self):  argument
910         with self.assertRaises(ValueError) as e:
911             self._DoTestFile('014_pack_overlap.dts')
912         self.assertIn("Node '/binman/u-boot-align': Offset 0x3 (3) overlaps "
916     def testPackEntryOverflow(self):  argument
918         with self.assertRaises(ValueError) as e:
919             self._DoTestFile('015_pack_overflow.dts')
920         self.assertIn("Node '/binman/u-boot': Entry contents size is 0x4 (4) "
923     def testPackImageOverflow(self):  argument
925         with self.assertRaises(ValueError) as e:
926             self._DoTestFile('016_pack_image_overflow.dts')
927         self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section "
930     def testPackImageSize(self):  argument
932         retcode = self._DoTestFile('017_pack_image_size.dts')
933         self.assertEqual(0, retcode)
934         self.assertIn('image', control.images)
936         self.assertEqual(7, image.size)
938     def testPackImageSizeAlign(self):  argument
940         retcode = self._DoTestFile('018_pack_image_align.dts')
941         self.assertEqual(0, retcode)
942         self.assertIn('image', control.images)
944         self.assertEqual(16, image.size)
946     def testPackInvalidImageAlign(self):  argument
948         with self.assertRaises(ValueError) as e:
949             self._DoTestFile('019_pack_inv_image_align.dts')
950         self.assertIn("Section '/binman': Size 0x7 (7) does not match "
953     def testPackAlignPowerOf2(self):  argument
955         with self.assertRaises(ValueError) as e:
956             self._DoTestFile('020_pack_inv_image_align_power2.dts')
957         self.assertIn("Image '/binman': Alignment size 131 must be a power of "
960     def testImagePadByte(self):  argument
962         self._SetupSplElf()
963         data = self._DoReadFile('021_image_pad.dts')
964         self.assertEqual(U_BOOT_SPL_DATA + tools.GetBytes(0xff, 1) +
967     def testImageName(self):  argument
969         retcode = self._DoTestFile('022_image_name.dts')
970         self.assertEqual(0, retcode)
973         self.assertTrue(os.path.exists(fname))
977         self.assertTrue(os.path.exists(fname))
979     def testBlobFilename(self):  argument
981         data = self._DoReadFile('023_blob.dts')
982         self.assertEqual(BLOB_DATA, data)
984     def testPackSorted(self):  argument
986         self._SetupSplElf()
987         data = self._DoReadFile('024_sorted.dts')
988         self.assertEqual(tools.GetBytes(0, 1) + U_BOOT_SPL_DATA +
991     def testPackZeroOffset(self):  argument
993         with self.assertRaises(ValueError) as e:
994             self._DoTestFile('025_pack_zero_size.dts')
995         self.assertIn("Node '/binman/u-boot-spl': Offset 0x0 (0) overlaps "
999     def testPackUbootDtb(self):  argument
1001         data = self._DoReadFile('026_pack_u_boot_dtb.dts')
1002         self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA, data)
1004     def testPackX86RomNoSize(self):  argument
1006         with self.assertRaises(ValueError) as e:
1007             self._DoTestFile('027_pack_4gb_no_size.dts')
1008         self.assertIn("Image '/binman': Section size must be provided when "
1011     def test4gbAndSkipAtStartTogether(self):  argument
1014         with self.assertRaises(ValueError) as e:
1015             self._DoTestFile('098_4gb_and_skip_at_start_together.dts')
1016         self.assertIn("Image '/binman': Provide either 'end-at-4gb' or "
1019     def testPackX86RomOutside(self):  argument
1021         with self.assertRaises(ValueError) as e:
1022             self._DoTestFile('028_pack_4gb_outside.dts')
1023         self.assertIn("Node '/binman/u-boot': Offset 0x0 (0) size 0x4 (4) "
1028     def testPackX86Rom(self):  argument
1030         self._SetupSplElf()
1031         data = self._DoReadFile('029_x86_rom.dts')
1032         self.assertEqual(U_BOOT_DATA + tools.GetBytes(0, 3) + U_BOOT_SPL_DATA +
1035     def testPackX86RomMeNoDesc(self):  argument
1039             with self.assertRaises(ValueError) as e:
1040                 self._DoTestFile('163_x86_rom_me_empty.dts')
1041 …self.assertIn("Node '/binman/intel-descriptor': Cannot find Intel Flash Descriptor (FD) signature",
1044             self._SetupDescriptor()
1046     def testPackX86RomBadDesc(self):  argument
1048         with self.assertRaises(ValueError) as e:
1049             self._DoTestFile('030_x86_rom_me_no_desc.dts')
1050         self.assertIn("Node '/binman/intel-me': No offset set with "
1054     def testPackX86RomMe(self):  argument
1056         data = self._DoReadFile('031_x86_rom_me.dts')
1057         expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
1059             self.fail('Expected descriptor binary at start of image')
1060         self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
1062     def testPackVga(self):  argument
1064         data = self._DoReadFile('032_intel_vga.dts')
1065         self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
1067     def testPackStart16(self):  argument
1069         data = self._DoReadFile('033_x86_start16.dts')
1070         self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
1072     def testPackPowerpcMpc85xxBootpgResetvec(self):  argument
1075         data = self._DoReadFile('150_powerpc_mpc85xx_bootpg_resetvec.dts')
1076         self.assertEqual(PPC_MPC85XX_BR_DATA, data[:len(PPC_MPC85XX_BR_DATA)])
1078     def _RunMicrocodeTest(self, dts_fname, nodtb_data, ucode_second=False):  argument
1093         data = self._DoReadFile(dts_fname, True)
1100             fdt_len = self.GetFdtLen(dtb_with_ucode)
1103             fdt_len = self.GetFdtLen(dtb_with_ucode)
1111         self.assertTrue(ucode)
1113             self.assertFalse(node.props.get('data'))
1120         self.assertEqual(ucode_data, ucode_content[:len(ucode_data)])
1129     def testPackUbootMicrocode(self):  argument
1138         first, pos_and_size = self._RunMicrocodeTest('034_x86_ucode.dts',
1140         self.assertEqual(b'nodtb with microcode' + pos_and_size +
1143     def _RunPackUbootSingleMicrocode(self):  argument
1155         data = self._DoReadFile('035_x86_single_ucode.dts', True)
1159         fdt_len = self.GetFdtLen(second)
1164         self.assertIn(ucode_data, second)
1172         self.assertEqual(b'nodtb with microcode' + pos_and_size +
1175     def testPackUbootSingleMicrocode(self):  argument
1178         self._RunPackUbootSingleMicrocode()
1180     def testUBootImg(self):  argument
1182         data = self._DoReadFile('036_u_boot_img.dts')
1183         self.assertEqual(U_BOOT_IMG_DATA, data)
1185     def testNoMicrocode(self):  argument
1187         with self.assertRaises(ValueError) as e:
1188             self._DoReadFile('037_x86_no_ucode.dts', True)
1189         self.assertIn("Node '/binman/u-boot-dtb-with-ucode': No /microcode "
1192     def testMicrocodeWithoutNode(self):  argument
1194         with self.assertRaises(ValueError) as e:
1195             self._DoReadFile('038_x86_ucode_missing_node.dts', True)
1196         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
1199     def testMicrocodeWithoutNode2(self):  argument
1201         with self.assertRaises(ValueError) as e:
1202             self._DoReadFile('039_x86_ucode_missing_node2.dts', True)
1203         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
1206     def testMicrocodeWithoutPtrInElf(self):  argument
1211                 tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
1213             with self.assertRaises(ValueError) as e:
1214                 self._RunPackUbootSingleMicrocode()
1215             self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot locate "
1221                 tools.ReadFile(self.ElfTestFile('u_boot_ucode_ptr')))
1223     def testMicrocodeNotInImage(self):  argument
1225         with self.assertRaises(ValueError) as e:
1226             self._DoReadFile('040_x86_ucode_not_in_image.dts', True)
1227         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode "
1231     def testWithoutMicrocode(self):  argument
1234             tools.ReadFile(self.ElfTestFile('u_boot_no_ucode_ptr')))
1235         data, dtb, _, _ = self._DoReadFileDtb('044_x86_optional_ucode.dts', True)
1238         self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
1241         fdt_len = self.GetFdtLen(second)
1242         self.assertEqual(dtb, second[:fdt_len])
1246         self.assertEqual(tools.GetBytes(0, 0x200 - used_len), third)
1248     def testUnknownPosSize(self):  argument
1250         with self.assertRaises(ValueError) as e:
1251             self._DoReadFile('041_unknown_pos_size.dts', True)
1252         self.assertIn("Section '/binman': Unable to set offset/size for unknown "
1255     def testPackFsp(self):  argument
1257         data = self._DoReadFile('042_intel_fsp.dts')
1258         self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
1260     def testPackCmc(self):  argument
1262         data = self._DoReadFile('043_intel_cmc.dts')
1263         self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
1265     def testPackVbt(self):  argument
1267         data = self._DoReadFile('046_intel_vbt.dts')
1268         self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
1270     def testSplBssPad(self):  argument
1273         self._SetupSplElf()
1274         data = self._DoReadFile('047_spl_bss_pad.dts')
1275         self.assertEqual(U_BOOT_SPL_DATA + tools.GetBytes(0, 10) + U_BOOT_DATA,
1278     def testSplBssPadMissing(self):  argument
1280         self._SetupSplElf('u_boot_ucode_ptr')
1281         with self.assertRaises(ValueError) as e:
1282             self._DoReadFile('047_spl_bss_pad.dts')
1283         self.assertIn('Expected __bss_size symbol in spl/u-boot-spl',
1286     def testPackStart16Spl(self):  argument
1288         data = self._DoReadFile('048_x86_start16_spl.dts')
1289         self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
1291     def _PackUbootSplMicrocode(self, dts, ucode_second=False):  argument
1305         self._SetupSplElf('u_boot_ucode_ptr')
1306         first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA,
1308         self.assertEqual(b'splnodtb with microc' + pos_and_size +
1311     def testPackUbootSplMicrocode(self):  argument
1313         self._PackUbootSplMicrocode('049_x86_ucode_spl.dts')
1315     def testPackUbootSplMicrocodeReorder(self):  argument
1322         self._PackUbootSplMicrocode('058_x86_ucode_spl_needs_retry.dts',
1325     def testPackMrc(self):  argument
1327         data = self._DoReadFile('050_intel_mrc.dts')
1328         self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
1330     def testSplDtb(self):  argument
1332         data = self._DoReadFile('051_u_boot_spl_dtb.dts')
1333         self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)])
1335     def testSplNoDtb(self):  argument
1337         data = self._DoReadFile('052_u_boot_spl_nodtb.dts')
1338         self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)])
1340     def testSymbols(self):  argument
1342         elf_fname = self.ElfTestFile('u_boot_binman_syms')
1345         self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
1347         self._SetupSplElf('u_boot_binman_syms')
1348         data = self._DoReadFile('053_symbols.dts')
1353         self.assertEqual(expected, data)
1355     def testPackUnitAddress(self):  argument
1357         data = self._DoReadFile('054_unit_address.dts')
1358         self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data)
1360     def testSections(self):  argument
1362         data = self._DoReadFile('055_sections.dts')
1366         self.assertEqual(expected, data)
1368     def testMap(self):  argument
1370         _, _, map_data, _ = self._DoReadFileDtb('055_sections.dts', map=True)
1371         self.assertEqual('''ImagePos    Offset      Size  Name
1381     def testNamePrefix(self):  argument
1383         _, _, map_data, _ = self._DoReadFileDtb('056_name_prefix.dts', map=True)
1384         self.assertEqual('''ImagePos    Offset      Size  Name
1392     def testUnknownContents(self):  argument
1394         with self.assertRaises(ValueError) as e:
1395             self._DoReadFile('057_unknown_contents.dts', True)
1396         self.assertIn("Image '/binman': Internal error: Could not complete "
1400     def testBadChangeSize(self):  argument
1404             with self.assertRaises(ValueError) as e:
1405                 self._DoReadFile('059_change_size.dts', True)
1406             self.assertIn("Node '/binman/_testing': Cannot update entry size from 2 to 3",
1411     def testUpdateFdt(self):  argument
1413         _, _, _, out_dtb_fname = self._DoReadFileDtb('060_fdt_update.dts',
1417         props = self._GetPropTree(dtb, BASE_DTB_PROPS + REPACK_DTB_PROPS)
1418         self.assertEqual({
1440     def testUpdateFdtBad(self):  argument
1442         with self.assertRaises(ValueError) as e:
1443             self._DoReadFileDtb('061_fdt_update_bad.dts', update_dtb=True)
1444         self.assertIn('Could not complete processing of Fdt: remaining '
1448     def testEntryArgs(self):  argument
1454         self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args)
1455         self.assertIn('image', control.images)
1457         self.assertEqual('test0', entry.test_str_fdt)
1458         self.assertEqual('test1', entry.test_str_arg)
1459         self.assertEqual(123, entry.test_int_fdt)
1460         self.assertEqual(456, entry.test_int_arg)
1462     def testEntryArgsMissing(self):  argument
1467         self._DoReadFileDtb('063_entry_args_missing.dts', entry_args=entry_args)
1469         self.assertEqual('test0', entry.test_str_fdt)
1470         self.assertEqual(None, entry.test_str_arg)
1471         self.assertEqual(None, entry.test_int_fdt)
1472         self.assertEqual(456, entry.test_int_arg)
1474     def testEntryArgsRequired(self):  argument
1479         with self.assertRaises(ValueError) as e:
1480             self._DoReadFileDtb('064_entry_args_required.dts')
1481         self.assertIn("Node '/binman/_testing': "
1486     def testEntryArgsInvalidFormat(self):  argument
1488         args = ['build', '-d', self.TestFile('064_entry_args_required.dts'),
1490         with self.assertRaises(ValueError) as e:
1491             self._DoBinman(*args)
1492         self.assertIn("Invalid entry arguemnt 'no-value'", str(e.exception))
1494     def testEntryArgsInvalidInteger(self):  argument
1499         with self.assertRaises(ValueError) as e:
1500             self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args)
1501         self.assertIn("Node '/binman/_testing': Cannot convert entry arg "
1505     def testEntryArgsInvalidDatatype(self):  argument
1515         with self.assertRaises(ValueError) as e:
1516             self._DoReadFileDtb('065_entry_args_unknown_datatype.dts',
1518         self.assertIn('GetArg() internal error: Unknown data type ',
1521     def testText(self):  argument
1528         data, _, _, _ = self._DoReadFileDtb('066_text.dts',
1534         self.assertEqual(expected, data)
1536     def testEntryDocs(self):  argument
1540         self.assertTrue(len(stdout.getvalue()) > 0)
1542     def testEntryDocsMissing(self):  argument
1544         with self.assertRaises(ValueError) as e:
1547         self.assertIn('Documentation is missing for modules: u_boot',
1550     def testFmap(self):  argument
1552         data = self._DoReadFile('067_fmap.dts')
1556         self.assertEqual(expected, data[:32])
1557         self.assertEqual(b'__FMAP__', fhdr.signature)
1558         self.assertEqual(1, fhdr.ver_major)
1559         self.assertEqual(0, fhdr.ver_minor)
1560         self.assertEqual(0, fhdr.base)
1561         self.assertEqual(16 + 16 +
1564         self.assertEqual(b'FMAP', fhdr.name)
1565         self.assertEqual(3, fhdr.nareas)
1567             self.assertEqual(0, fentry.flags)
1569         self.assertEqual(0, fentries[0].offset)
1570         self.assertEqual(4, fentries[0].size)
1571         self.assertEqual(b'RO_U_BOOT', fentries[0].name)
1573         self.assertEqual(16, fentries[1].offset)
1574         self.assertEqual(4, fentries[1].size)
1575         self.assertEqual(b'RW_U_BOOT', fentries[1].name)
1577         self.assertEqual(32, fentries[2].offset)
1578         self.assertEqual(fmap_util.FMAP_HEADER_LEN +
1580         self.assertEqual(b'FMAP', fentries[2].name)
1582     def testBlobNamedByArg(self):  argument
1587         self._DoReadFileDtb('068_blob_named_by_arg.dts', entry_args=entry_args)
1589     def testFill(self):  argument
1591         data = self._DoReadFile('069_fill.dts')
1593         self.assertEqual(expected, data)
1595     def testFillNoSize(self):  argument
1597         with self.assertRaises(ValueError) as e:
1598             self._DoReadFile('070_fill_no_size.dts')
1599         self.assertIn("'fill' entry must have a size property",
1602     def _HandleGbbCommand(self, pipe_list):  argument
1612     def testGbb(self):  argument
1614         command.test_result = self._HandleGbbCommand
1619         data, _, _, _ = self._DoReadFileDtb('071_gbb.dts', entry_args=entry_args)
1624         self.assertEqual(expected, data)
1626     def testGbbTooSmall(self):  argument
1628         with self.assertRaises(ValueError) as e:
1629             self._DoReadFileDtb('072_gbb_too_small.dts')
1630         self.assertIn("Node '/binman/gbb': GBB is too small",
1633     def testGbbNoSize(self):  argument
1635         with self.assertRaises(ValueError) as e:
1636             self._DoReadFileDtb('073_gbb_no_size.dts')
1637         self.assertIn("Node '/binman/gbb': GBB must have a fixed size",
1640     def _HandleVblockCommand(self, pipe_list):  argument
1658                 if self._hash_data:
1669     def testVblock(self):  argument
1671         self._hash_data = False
1672         command.test_result = self._HandleVblockCommand
1676         data, _, _, _ = self._DoReadFileDtb('074_vblock.dts',
1679         self.assertEqual(expected, data)
1681     def testVblockNoContent(self):  argument
1683         with self.assertRaises(ValueError) as e:
1684             self._DoReadFile('075_vblock_no_content.dts')
1685         self.assertIn("Node '/binman/vblock': Vblock must have a 'content' "
1688     def testVblockBadPhandle(self):  argument
1690         with self.assertRaises(ValueError) as e:
1691             self._DoReadFile('076_vblock_bad_phandle.dts')
1692         self.assertIn("Node '/binman/vblock': Cannot find node for phandle "
1695     def testVblockBadEntry(self):  argument
1697         with self.assertRaises(ValueError) as e:
1698             self._DoReadFile('077_vblock_bad_entry.dts')
1699         self.assertIn("Node '/binman/vblock': Cannot find entry for node "
1702     def testVblockContent(self):  argument
1704         self._hash_data = True
1705         command.test_result = self._HandleVblockCommand
1709         data = self._DoReadFileDtb(
1713         self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
1723         self.assertEqual(expected_hashval, hashval)
1725     def testTpl(self):  argument
1728         self._SetupTplElf()
1729         data = self._DoReadFile('078_u_boot_tpl.dts')
1730         self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data)
1732     def testUsesPos(self):  argument
1734         with self.assertRaises(ValueError) as e:
1735            data = self._DoReadFile('079_uses_pos.dts')
1736         self.assertIn("Node '/binman/u-boot': Please use 'offset' instead of "
1739     def testFillZero(self):  argument
1741         data = self._DoReadFile('080_fill_empty.dts')
1742         self.assertEqual(tools.GetBytes(0, 16), data)
1744     def testTextMissing(self):  argument
1746         with self.assertRaises(ValueError) as e:
1747             self._DoReadFileDtb('066_text.dts',)
1748         self.assertIn("Node '/binman/text': No value provided for text label "
1751     def testPackStart16Tpl(self):  argument
1753         data = self._DoReadFile('081_x86_start16_tpl.dts')
1754         self.assertEqual(X86_START16_TPL_DATA, data[:len(X86_START16_TPL_DATA)])
1756     def testSelectImage(self):  argument
1763                 retcode = self._DoTestFile('006_dual_image.dts',
1766             self.assertEqual(0, retcode)
1768                 self.assertIn(expected, stdout.getvalue())
1770                 self.assertNotIn(expected, stdout.getvalue())
1772             self.assertFalse(os.path.exists(tools.GetOutputFilename('image1.bin')))
1773             self.assertTrue(os.path.exists(tools.GetOutputFilename('image2.bin')))
1774             self._CleanupOutputDir()
1776     def testUpdateFdtAll(self):  argument
1778         data = self._DoReadFileRealDtb('082_fdt_update_all.dts')
1806             props = self._GetPropTree(dtb, BASE_DTB_PROPS + REPACK_DTB_PROPS +
1811             self.assertEqual(expected, props)
1814     def testUpdateFdtOutput(self):  argument
1817             data, dtb_data, _, _ = self._DoReadFileDtb('082_fdt_update_all.dts',
1835                     orig_indata = self._GetDtbContentsForSplTpl(dtb_data, name)
1838                 self.assertNotEqual(outdata, orig_indata,
1840                 self.assertEqual(outdata, data[start:start + size],
1845             self._ResetDtbs()
1847     def _decompress(self, data):  argument
1850     def testCompress(self):  argument
1852         self._CheckLz4()
1853         data, _, _, out_dtb_fname = self._DoReadFileDtb('083_compress.dts',
1857         props = self._GetPropTree(dtb, ['size', 'uncomp-size'])
1858         orig = self._decompress(data)
1859         self.assertEquals(COMPRESS_DATA, orig)
1864         self.assertEqual(1, len(entries))
1867         self.assertEqual(COMPRESS_DATA, entry.uncomp_data)
1868         self.assertEqual(len(COMPRESS_DATA), entry.uncomp_size)
1869         orig = self._decompress(entry.data)
1870         self.assertEqual(orig, entry.uncomp_data)
1872         self.assertEqual(image.data, entry.data)
1879         self.assertEqual(expected, props)
1881     def testFiles(self):  argument
1883         data = self._DoReadFile('084_files.dts')
1884         self.assertEqual(FILES_DATA, data)
1886     def testFilesCompress(self):  argument
1888         self._CheckLz4()
1889         data = self._DoReadFile('085_files_compress.dts')
1902             orig += self._decompress(chunk)
1904         self.assertEqual(FILES_DATA, orig)
1906     def testFilesMissing(self):  argument
1908         with self.assertRaises(ValueError) as e:
1909             data = self._DoReadFile('086_files_none.dts')
1910         self.assertIn("Node '/binman/files': Pattern \'files/*.none\' matched "
1913     def testFilesNoPattern(self):  argument
1915         with self.assertRaises(ValueError) as e:
1916             data = self._DoReadFile('087_files_no_pattern.dts')
1917         self.assertIn("Node '/binman/files': Missing 'pattern' property",
1920     def testExpandSize(self):  argument
1922         data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts',
1928         self.assertEqual(expect, data)
1929         self.assertEqual('''ImagePos    Offset      Size  Name
1942     def testExpandSizeBad(self):  argument
1945             with self.assertRaises(ValueError) as e:
1946                 self._DoReadFileDtb('089_expand_size_bad.dts', map=True)
1947         self.assertIn("Node '/binman/_testing': Cannot obtain contents when "
1950     def testHash(self):  argument
1952         _, _, _, out_dtb_fname = self._DoReadFileDtb('090_hash.dts',
1959         self.assertEqual(m.digest(), b''.join(hash_node.value))
1961     def testHashNoAlgo(self):  argument
1962         with self.assertRaises(ValueError) as e:
1963             self._DoReadFileDtb('091_hash_no_algo.dts', update_dtb=True)
1964         self.assertIn("Node \'/binman/u-boot\': Missing \'algo\' property for "
1967     def testHashBadAlgo(self):  argument
1968         with self.assertRaises(ValueError) as e:
1969             self._DoReadFileDtb('092_hash_bad_algo.dts', update_dtb=True)
1970         self.assertIn("Node '/binman/u-boot': Unknown hash algorithm",
1973     def testHashSection(self):  argument
1975         _, _, _, out_dtb_fname = self._DoReadFileDtb('099_hash_section.dts',
1983         self.assertEqual(m.digest(), b''.join(hash_node.value))
1985     def testPackUBootTplMicrocode(self):  argument
1994         self._SetupTplElf('u_boot_ucode_ptr')
1995         first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts',
1997         self.assertEqual(b'tplnodtb with microc' + pos_and_size +
2000     def testFmapX86(self):  argument
2002         data = self._DoReadFile('094_fmap_x86.dts')
2005         self.assertEqual(expected, data[:32])
2008         self.assertEqual(0x100, fhdr.image_size)
2010         self.assertEqual(0, fentries[0].offset)
2011         self.assertEqual(4, fentries[0].size)
2012         self.assertEqual(b'U_BOOT', fentries[0].name)
2014         self.assertEqual(4, fentries[1].offset)
2015         self.assertEqual(3, fentries[1].size)
2016         self.assertEqual(b'INTEL_MRC', fentries[1].name)
2018         self.assertEqual(32, fentries[2].offset)
2019         self.assertEqual(fmap_util.FMAP_HEADER_LEN +
2021         self.assertEqual(b'FMAP', fentries[2].name)
2023     def testFmapX86Section(self):  argument
2025         data = self._DoReadFile('095_fmap_x86_section.dts')
2027         self.assertEqual(expected, data[:32])
2030         self.assertEqual(0x100, fhdr.image_size)
2032         self.assertEqual(0, fentries[0].offset)
2033         self.assertEqual(4, fentries[0].size)
2034         self.assertEqual(b'U_BOOT', fentries[0].name)
2036         self.assertEqual(4, fentries[1].offset)
2037         self.assertEqual(3, fentries[1].size)
2038         self.assertEqual(b'INTEL_MRC', fentries[1].name)
2040         self.assertEqual(36, fentries[2].offset)
2041         self.assertEqual(fmap_util.FMAP_HEADER_LEN +
2043         self.assertEqual(b'FMAP', fentries[2].name)
2045     def testElf(self):  argument
2047         self._SetupSplElf()
2048         self._SetupTplElf()
2049         with open(self.ElfTestFile('bss_data'), 'rb') as fd:
2051         data = self._DoReadFile('096_elf.dts')
2053     def testElfStrip(self):  argument
2055         self._SetupSplElf()
2056         with open(self.ElfTestFile('bss_data'), 'rb') as fd:
2058         data = self._DoReadFile('097_elf_strip.dts')
2060     def testPackOverlapMap(self):  argument
2063             with self.assertRaises(ValueError) as e:
2064                 self._DoTestFile('014_pack_overlap.dts', map=True)
2066         self.assertEqual("Wrote map file '%s' to show errors\n" % map_fname,
2070         self.assertFalse(os.path.exists(tools.GetOutputFilename('image.bin')))
2071         self.assertTrue(os.path.exists(map_fname))
2073         self.assertEqual('''ImagePos    Offset      Size  Name
2079     def testPackRefCode(self):  argument
2081         data = self._DoReadFile('100_intel_refcode.dts')
2082         self.assertEqual(REFCODE_DATA, data[:len(REFCODE_DATA)])
2084     def testSectionOffset(self):  argument
2086         data, _, map_data, _ = self._DoReadFileDtb('101_sections_offset.dts',
2088         self.assertEqual('''ImagePos    Offset      Size  Name
2097         self.assertEqual(data,
2105     def testCbfsRaw(self):  argument
2112         data = self._DoReadFile('102_cbfs_raw.dts')
2116         self.assertEqual(size, cbfs.rom_size)
2118         self.assertIn('u-boot-dtb', cbfs.files)
2120         self.assertEqual(U_BOOT_DTB_DATA, cfile.data)
2122     def testCbfsArch(self):  argument
2124         data = self._DoReadFile('103_cbfs_raw_ppc.dts')
2128         self.assertEqual(size, cbfs.rom_size)
2130         self.assertIn('u-boot-dtb', cbfs.files)
2132         self.assertEqual(U_BOOT_DTB_DATA, cfile.data)
2134     def testCbfsStage(self):  argument
2137             self.skipTest('Python elftools not available')
2138         elf_fname = os.path.join(self._indir, 'cbfs-stage.elf')
2142         data = self._DoReadFile('104_cbfs_stage.dts')
2144         self.assertEqual(size, cbfs.rom_size)
2146         self.assertIn('u-boot', cbfs.files)
2148         self.assertEqual(U_BOOT_DATA + U_BOOT_DTB_DATA, cfile.data)
2150     def testCbfsRawCompress(self):  argument
2152         self._CheckLz4()
2153         data = self._DoReadFile('105_cbfs_raw_compress.dts')
2157         self.assertIn('u-boot', cbfs.files)
2159         self.assertEqual(COMPRESS_DATA, cfile.data)
2161     def testCbfsBadArch(self):  argument
2163         with self.assertRaises(ValueError) as e:
2164             self._DoReadFile('106_cbfs_bad_arch.dts')
2165         self.assertIn("Invalid architecture 'bad-arch'", str(e.exception))
2167     def testCbfsNoSize(self):  argument
2169         with self.assertRaises(ValueError) as e:
2170             self._DoReadFile('107_cbfs_no_size.dts')
2171         self.assertIn('entry must have a size property', str(e.exception))
2173     def testCbfsNoCOntents(self):  argument
2175         with self.assertRaises(ValueError) as e:
2176             self._DoReadFile('108_cbfs_no_contents.dts')
2177         self.assertIn('Could not complete processing of contents',
2180     def testCbfsBadCompress(self):  argument
2182         with self.assertRaises(ValueError) as e:
2183             self._DoReadFile('109_cbfs_bad_compress.dts')
2184         self.assertIn("Invalid compression in 'u-boot': 'invalid-algo'",
2187     def testCbfsNamedEntries(self):  argument
2189         data = self._DoReadFile('110_cbfs_name.dts')
2192         self.assertIn('FRED', cbfs.files)
2194         self.assertEqual(U_BOOT_DATA, cfile1.data)
2196         self.assertIn('hello', cbfs.files)
2198         self.assertEqual(U_BOOT_DTB_DATA, cfile2.data)
2200     def _SetupIfwi(self, fname):  argument
2206         self._SetupSplElf()
2207         self._SetupTplElf()
2210         with gzip.open(self.TestFile('%s.gz' % fname), 'rb') as fd:
2214     def _CheckIfwi(self, data):  argument
2220         expected_desc = tools.ReadFile(self.TestFile('descriptor.bin'))
2222             self.fail('Expected descriptor binary at start of image')
2231         self.assertEqual(U_BOOT_TPL_DATA, tpl_data[:len(U_BOOT_TPL_DATA)])
2233     def testPackX86RomIfwi(self):  argument
2235         self._SetupIfwi('fitimage.bin')
2236         data = self._DoReadFile('111_x86_rom_ifwi.dts')
2237         self._CheckIfwi(data)
2239     def testPackX86RomIfwiNoDesc(self):  argument
2241         self._SetupIfwi('ifwi.bin')
2242         data = self._DoReadFile('112_x86_rom_ifwi_nodesc.dts')
2243         self._CheckIfwi(data)
2245     def testPackX86RomIfwiNoData(self):  argument
2247         self._SetupIfwi('ifwi.bin')
2248         with self.assertRaises(ValueError) as e:
2249             data = self._DoReadFile('113_x86_rom_ifwi_nodata.dts')
2250         self.assertIn('Could not complete processing of contents',
2253     def testCbfsOffset(self):  argument
2259         data = self._DoReadFile('114_cbfs_offset.dts')
2263         self.assertEqual(size, cbfs.rom_size)
2265         self.assertIn('u-boot', cbfs.files)
2267         self.assertEqual(U_BOOT_DATA, cfile.data)
2268         self.assertEqual(0x40, cfile.cbfs_offset)
2270         self.assertIn('u-boot-dtb', cbfs.files)
2272         self.assertEqual(U_BOOT_DTB_DATA, cfile2.data)
2273         self.assertEqual(0x140, cfile2.cbfs_offset)
2275     def testFdtmap(self):  argument
2277         data = self.data = self._DoReadFileRealDtb('115_fdtmap.dts')
2280         self.assertEqual(b'_FDTMAP_', magic)
2281         self.assertEqual(tools.GetBytes(0, 8), fdtmap_data[8:16])
2286         props = self._GetPropTree(dtb, BASE_DTB_PROPS, prefix='/')
2287         self.assertEqual({
2299     def testFdtmapNoMatch(self):  argument
2301         self.data = self._DoReadFileRealDtb('115_fdtmap.dts')
2309         with self.assertRaises(ValueError) as e:
2311         self.assertIn("Cannot locate node for path '/binman-suffix'",
2314     def testFdtmapHeader(self):  argument
2316         data = self.data = self._DoReadFileRealDtb('116_fdtmap_hdr.dts')
2323         self.assertEqual(b'BinM', hdr_data[:4])
2325         self.assertEqual(fdtmap_pos - 0x400, offset - (1 << 32))
2327     def testFdtmapHeaderStart(self):  argument
2329         data = self.data = self._DoReadFileRealDtb('117_fdtmap_hdr_start.dts')
2332         self.assertEqual(b'BinM', hdr_data[:4])
2334         self.assertEqual(fdtmap_pos, offset)
2336     def testFdtmapHeaderPos(self):  argument
2338         data = self.data = self._DoReadFileRealDtb('118_fdtmap_hdr_pos.dts')
2341         self.assertEqual(b'BinM', hdr_data[:4])
2343         self.assertEqual(fdtmap_pos, offset)
2345     def testHeaderMissingFdtmap(self):  argument
2347         with self.assertRaises(ValueError) as e:
2348             self.data = self._DoReadFileRealDtb('119_fdtmap_hdr_missing.dts')
2349         self.assertIn("'image_header' section must have an 'fdtmap' sibling",
2352     def testHeaderNoLocation(self):  argument
2354         with self.assertRaises(ValueError) as e:
2355             self.data = self._DoReadFileRealDtb('120_hdr_no_location.dts')
2356         self.assertIn("Invalid location 'None', expected 'start' or 'end'",
2359     def testEntryExpand(self):  argument
2361         data = self._DoReadFile('121_entry_expand.dts')
2362         self.assertEqual(b'aaa', data[:3])
2363         self.assertEqual(U_BOOT_DATA, data[3:3 + len(U_BOOT_DATA)])
2364         self.assertEqual(b'aaa', data[-3:])
2366     def testEntryExpandBad(self):  argument
2368         with self.assertRaises(ValueError) as e:
2369             self._DoReadFile('122_entry_expand_twice.dts')
2370         self.assertIn("Image '/binman': Entries changed size after packing",
2373     def testEntryExpandSection(self):  argument
2375         data = self._DoReadFile('123_entry_expand_section.dts')
2376         self.assertEqual(b'aaa', data[:3])
2377         self.assertEqual(U_BOOT_DATA, data[3:3 + len(U_BOOT_DATA)])
2378         self.assertEqual(b'aaa', data[-3:])
2380     def testCompressDtb(self):  argument
2382         self._CheckLz4()
2383         data = self.data = self._DoReadFileRealDtb('124_compress_dtb.dts')
2384         self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
2386         orig = self._decompress(comp_data)
2389         props = self._GetPropTree(dtb, ['size', 'uncomp-size'])
2396         self.assertEqual(expected, props)
2398     def testCbfsUpdateFdt(self):  argument
2400         self._CheckLz4()
2401         data, _, _, out_dtb_fname = self._DoReadFileDtb('125_cbfs_update.dts',
2405         props = self._GetPropTree(dtb, BASE_DTB_PROPS + ['uncomp-size'])
2407         self.assertEqual({
2422     def testCbfsBadType(self):  argument
2424         with self.assertRaises(ValueError) as e:
2425             self._DoReadFile('126_cbfs_bad_type.dts')
2426         self.assertIn("Unknown cbfs-type 'badtype'", str(e.exception))
2428     def testList(self):  argument
2430         self._CheckLz4()
2431         data = self._DoReadFile('127_list.dts')
2434         self.assertEqual(7, len(entries))
2437         self.assertEqual(0, ent.indent)
2438         self.assertEqual('main-section', ent.name)
2439         self.assertEqual('section', ent.etype)
2440         self.assertEqual(len(data), ent.size)
2441         self.assertEqual(0, ent.image_pos)
2442         self.assertEqual(None, ent.uncomp_size)
2443         self.assertEqual(0, ent.offset)
2446         self.assertEqual(1, ent.indent)
2447         self.assertEqual('u-boot', ent.name)
2448         self.assertEqual('u-boot', ent.etype)
2449         self.assertEqual(len(U_BOOT_DATA), ent.size)
2450         self.assertEqual(0, ent.image_pos)
2451         self.assertEqual(None, ent.uncomp_size)
2452         self.assertEqual(0, ent.offset)
2455         self.assertEqual(1, ent.indent)
2456         self.assertEqual('section', ent.name)
2457         self.assertEqual('section', ent.etype)
2459         self.assertEqual(0x100, ent.image_pos)
2460         self.assertEqual(None, ent.uncomp_size)
2461         self.assertEqual(0x100, ent.offset)
2464         self.assertEqual(2, ent.indent)
2465         self.assertEqual('cbfs', ent.name)
2466         self.assertEqual('cbfs', ent.etype)
2467         self.assertEqual(0x400, ent.size)
2468         self.assertEqual(0x100, ent.image_pos)
2469         self.assertEqual(None, ent.uncomp_size)
2470         self.assertEqual(0, ent.offset)
2473         self.assertEqual(3, ent.indent)
2474         self.assertEqual('u-boot', ent.name)
2475         self.assertEqual('u-boot', ent.etype)
2476         self.assertEqual(len(U_BOOT_DATA), ent.size)
2477         self.assertEqual(0x138, ent.image_pos)
2478         self.assertEqual(None, ent.uncomp_size)
2479         self.assertEqual(0x38, ent.offset)
2482         self.assertEqual(3, ent.indent)
2483         self.assertEqual('u-boot-dtb', ent.name)
2484         self.assertEqual('text', ent.etype)
2485         self.assertGreater(len(COMPRESS_DATA), ent.size)
2486         self.assertEqual(0x178, ent.image_pos)
2487         self.assertEqual(len(COMPRESS_DATA), ent.uncomp_size)
2488         self.assertEqual(0x78, ent.offset)
2491         self.assertEqual(2, ent.indent)
2492         self.assertEqual('u-boot-dtb', ent.name)
2493         self.assertEqual('u-boot-dtb', ent.etype)
2494         self.assertEqual(0x500, ent.image_pos)
2495         self.assertEqual(len(U_BOOT_DTB_DATA), ent.uncomp_size)
2498         self.assertGreater(dtb_size, len(U_BOOT_DTB_DATA))
2499         self.assertEqual(0x400, ent.offset)
2501         self.assertEqual(len(data), 0x100 + section_size)
2502         self.assertEqual(section_size, 0x400 + dtb_size)
2504     def testFindFdtmap(self):  argument
2506         self._CheckLz4()
2507         data = self.data = self._DoReadFileRealDtb('128_decode_image.dts')
2511         self.assertEqual(entry.image_pos, fdtmap.LocateFdtmap(data))
2513     def testFindFdtmapMissing(self):  argument
2515         data = self._DoReadFile('005_simple.dts')
2516         self.assertEqual(None, fdtmap.LocateFdtmap(data))
2518     def testFindImageHeader(self):  argument
2520         self._CheckLz4()
2521         data = self.data = self._DoReadFileRealDtb('128_decode_image.dts')
2526         self.assertEqual(entry.image_pos, image_header.LocateHeaderOffset(data))
2528     def testFindImageHeaderStart(self):  argument
2530         data = self.data = self._DoReadFileRealDtb('117_fdtmap_hdr_start.dts')
2535         self.assertEqual(entry.image_pos, image_header.LocateHeaderOffset(data))
2537     def testFindImageHeaderMissing(self):  argument
2539         data = self._DoReadFile('005_simple.dts')
2540         self.assertEqual(None, image_header.LocateHeaderOffset(data))
2542     def testReadImage(self):  argument
2544         self._CheckLz4()
2545         data = self.data = self._DoReadFileRealDtb('128_decode_image.dts')
2549         self.assertEqual(orig_image.GetEntries().keys(),
2554         self.assertEquals(orig_entry.offset, entry.offset)
2555         self.assertEquals(orig_entry.size, entry.size)
2556         self.assertEquals(orig_entry.image_pos, entry.image_pos)
2558     def testReadImageNoHeader(self):  argument
2560         self._CheckLz4()
2561         data = self._DoReadFileRealDtb('129_decode_image_nohdr.dts')
2564         self.assertTrue(isinstance(image, Image))
2565         self.assertEqual('image', image.image_name[-5:])
2567     def testReadImageFail(self):  argument
2569         self._DoReadFile('005_simple.dts')
2571         with self.assertRaises(ValueError) as e:
2573         self.assertIn("Cannot find FDT map in image", str(e.exception))
2575     def testListCmd(self):  argument
2577         self._CheckLz4()
2578         data = self._DoReadFileRealDtb('130_list_fdtmap.dts')
2588             tmpdir, updated_fname = self._SetupImageInTmpdir()
2590                 self._DoBinman('ls', '-i', updated_fname)
2608         self.assertEqual(expected, lines)
2610     def testListCmdFail(self):  argument
2612         self._DoReadFile('005_simple.dts')
2614             tmpdir, updated_fname = self._SetupImageInTmpdir()
2615             with self.assertRaises(ValueError) as e:
2616                 self._DoBinman('ls', '-i', updated_fname)
2619         self.assertIn("Cannot find FDT map in image", str(e.exception))
2621     def _RunListCmd(self, paths, expected):  argument
2628         self._CheckLz4()
2629         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2634         self.assertEqual(expected, files)
2636     def testListCmdSection(self):  argument
2638         self._RunListCmd(['section'],
2641     def testListCmdFile(self):  argument
2643         self._RunListCmd(['*u-boot-dtb'], ['u-boot-dtb', 'u-boot-dtb'])
2645     def testListCmdWildcard(self):  argument
2647         self._RunListCmd(['*boot*'],
2650     def testListCmdWildcardMulti(self):  argument
2652         self._RunListCmd(['*cb*', '*head*'],
2655     def testListCmdEmpty(self):  argument
2657         self._RunListCmd(['nothing'], [])
2659     def testListCmdPath(self):  argument
2661         self._RunListCmd(['section/cbfs'], ['cbfs', 'u-boot', 'u-boot-dtb'])
2663     def _RunExtractCmd(self, entry_name, decomp=True):  argument
2674         self._CheckLz4()
2675         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2679     def testExtractSimple(self):  argument
2681         data = self._RunExtractCmd('u-boot')
2682         self.assertEqual(U_BOOT_DATA, data)
2684     def testExtractSection(self):  argument
2686         data = self._RunExtractCmd('section')
2689         self.assertEqual(['u-boot', 'u-boot-dtb', ''], list(cbfs.files.keys()))
2691         dtb = self._decompress(dtb_data)
2692         self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
2694     def testExtractCompressed(self):  argument
2696         data = self._RunExtractCmd('section/u-boot-dtb')
2697         self.assertEqual(EXTRACT_DTB_SIZE, len(data))
2699     def testExtractRaw(self):  argument
2701         data = self._RunExtractCmd('section/u-boot-dtb', decomp=False)
2702         dtb = self._decompress(data)
2703         self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
2705     def testExtractCbfs(self):  argument
2707         data = self._RunExtractCmd('section/cbfs/u-boot')
2708         self.assertEqual(U_BOOT_DATA, data)
2710     def testExtractCbfsCompressed(self):  argument
2712         data = self._RunExtractCmd('section/cbfs/u-boot-dtb')
2713         self.assertEqual(EXTRACT_DTB_SIZE, len(data))
2715     def testExtractCbfsRaw(self):  argument
2717         data = self._RunExtractCmd('section/cbfs/u-boot-dtb', decomp=False)
2719         self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
2721     def testExtractBadEntry(self):  argument
2723         with self.assertRaises(ValueError) as e:
2724             self._RunExtractCmd('section/does-not-exist')
2725         self.assertIn("Entry 'does-not-exist' not found in '/section'",
2728     def testExtractMissingFile(self):  argument
2730         with self.assertRaises(IOError) as e:
2733     def testExtractBadFile(self):  argument
2735         fname = os.path.join(self._indir, 'badfile')
2737         with self.assertRaises(ValueError) as e:
2740     def testExtractCmd(self):  argument
2742         self._CheckLz4()
2743         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2744         fname = os.path.join(self._indir, 'output.extact')
2746             tmpdir, updated_fname = self._SetupImageInTmpdir()
2748                 self._DoBinman('extract', '-i', updated_fname, 'u-boot',
2753         self.assertEqual(U_BOOT_DATA, data)
2755     def testExtractOneEntry(self):  argument
2757         self._CheckLz4()
2758         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2760         fname = os.path.join(self._indir, 'output.extact')
2763         self.assertEqual(U_BOOT_DATA, data)
2765     def _CheckExtractOutput(self, decomp):  argument
2787                 self.assertEqual(expect_data, data)
2789                 self.assertEqual(expect_size, len(data))
2803         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2805         outdir = os.path.join(self._indir, 'extract')
2812         self.assertEqual(9, len(outfiles))
2813         self.assertEqual(9, len(einfos))
2845         self.assertEqual(0, len(outfiles))
2849         self.assertFalse(os.path.exists(outdir))
2851     def testExtractAllEntries(self):  argument
2853         self._CheckLz4()
2854         self._CheckExtractOutput(decomp=True)
2856     def testExtractAllEntriesRaw(self):  argument
2858         self._CheckLz4()
2859         self._CheckExtractOutput(decomp=False)
2861     def testExtractSelectedEntries(self):  argument
2863         self._CheckLz4()
2864         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2866         outdir = os.path.join(self._indir, 'extract')
2873         self.assertEqual(names,
2876     def testExtractNoEntryPaths(self):  argument
2878         self._CheckLz4()
2879         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2881         with self.assertRaises(ValueError) as e:
2883         self.assertIn('Must specify an entry path to write with -f',
2886     def testExtractTooManyEntryPaths(self):  argument
2888         self._CheckLz4()
2889         self._DoReadFileRealDtb('130_list_fdtmap.dts')
2891         with self.assertRaises(ValueError) as e:
2893         self.assertIn('Must specify exactly one entry path to write with -f',
2896     def testPackAlignSection(self):  argument
2898         self._DoReadFile('131_pack_align_section.dts')
2900         self.assertIn('image', control.images)
2903         self.assertEqual(3, len(entries))
2906         self.assertIn('u-boot', entries)
2908         self.assertEqual(0, entry.offset)
2909         self.assertEqual(0, entry.image_pos)
2910         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
2911         self.assertEqual(len(U_BOOT_DATA), entry.size)
2914         self.assertIn('section0', entries)
2916         self.assertEqual(0x10, section0.offset)
2917         self.assertEqual(0x10, section0.image_pos)
2918         self.assertEqual(len(U_BOOT_DATA), section0.size)
2922         self.assertIn('u-boot', section_entries)
2924         self.assertEqual(0, entry.offset)
2925         self.assertEqual(0x10, entry.image_pos)
2926         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
2927         self.assertEqual(len(U_BOOT_DATA), entry.size)
2930         self.assertIn('section1', entries)
2932         self.assertEqual(0x14, section1.offset)
2933         self.assertEqual(0x14, section1.image_pos)
2934         self.assertEqual(0x20, section1.size)
2938         self.assertIn('u-boot', section_entries)
2940         self.assertEqual(0, entry.offset)
2941         self.assertEqual(0x14, entry.image_pos)
2942         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
2943         self.assertEqual(len(U_BOOT_DATA), entry.size)
2946         self.assertIn('section2', section_entries)
2948         self.assertEqual(0x4, section2.offset)
2949         self.assertEqual(0x18, section2.image_pos)
2950         self.assertEqual(4, section2.size)
2954         self.assertIn('u-boot', section_entries)
2956         self.assertEqual(0, entry.offset)
2957         self.assertEqual(0x18, entry.image_pos)
2958         self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
2959         self.assertEqual(len(U_BOOT_DATA), entry.size)
2961     def _RunReplaceCmd(self, entry_name, data, decomp=True, allow_resize=True,  argument
2982         dtb_data = self._DoReadFileDtb(dts, use_real_dtb=True,
2985         self.assertIn('image', control.images)
3001             self.assertEqual(new_dtb_data, orig_dtb_data)
3003             self.assertEqual(new_fdtmap_data, orig_fdtmap_data)
3007     def testReplaceSimple(self):  argument
3010         data, expected_fdtmap, _ = self._RunReplaceCmd('u-boot', expected,
3012         self.assertEqual(expected, data)
3019         self.assertIsNotNone(path)
3020         self.assertEqual(expected_fdtmap, fdtmap)
3023         self.assertEqual(dtb.GetContents(), fdtmap)
3026         self.assertIsNone(missing_path)
3027         self.assertIsNone(missing_fdtmap)
3030         self.assertIsNone(missing_dtb)
3032         self.assertEqual('/binman', state.fdt_path_prefix)
3034     def testReplaceResizeFail(self):  argument
3037         with self.assertRaises(ValueError) as e:
3038             self._RunReplaceCmd('u-boot', expected, allow_resize=False,
3040         self.assertIn("Node '/u-boot': Entry data size does not match, but resize is disabled",
3043     def testReplaceMulti(self):  argument
3045         data = self._DoReadFileDtb('133_replace_multi.dts', use_real_dtb=True,
3054         self.assertEqual(expected, data)
3057         self.assertEqual('/binman/image', state.fdt_path_prefix)
3067         self.assertEqual(expected, data)
3070         self.assertEqual('/binman/first-image', state.fdt_path_prefix)
3072     def testUpdateFdtAllRepack(self):  argument
3074         data = self._DoReadFileRealDtb('134_fdt_update_all_repack.dts')
3115             props = self._GetPropTree(dtb,
3127             self.assertEqual(expected, props)
3133     def testFdtmapHeaderMiddle(self):  argument
3135         with self.assertRaises(ValueError) as e:
3136             self._DoReadFileRealDtb('135_fdtmap_hdr_middle.dts')
3137 …self.assertIn("Invalid sibling order 'middle' for image-header: Must be at 'end' to match location…
3140     def testFdtmapHeaderStartBad(self):  argument
3142         with self.assertRaises(ValueError) as e:
3143             self._DoReadFileRealDtb('136_fdtmap_hdr_startbad.dts')
3144 …self.assertIn("Invalid sibling order 'end' for image-header: Must be at 'start' to match location",
3147     def testFdtmapHeaderEndBad(self):  argument
3149         with self.assertRaises(ValueError) as e:
3150             self._DoReadFileRealDtb('137_fdtmap_hdr_endbad.dts')
3151 …self.assertIn("Invalid sibling order 'start' for image-header: Must be at 'end' to match location",
3154     def testFdtmapHeaderNoSize(self):  argument
3156         self._DoReadFileRealDtb('138_fdtmap_hdr_nosize.dts')
3158     def testReplaceResize(self):  argument
3161         data, _, image = self._RunReplaceCmd('u-boot', expected,
3163         self.assertEqual(expected, data)
3172         self.assertEqual(len(expected), fdt_util.GetInt(node, 'size'))
3179         self.assertEqual(len(expected), fdt_util.GetInt(fnode, 'size'))
3181     def testReplaceResizeNoRepack(self):  argument
3184         with self.assertRaises(ValueError) as e:
3185             self._RunReplaceCmd('u-boot', expected)
3186 …    self.assertIn('Entry data size does not match, but allow-repack is not present for this image',
3189     def testEntryShrink(self):  argument
3193             data = self._DoReadFileDtb('140_entry_shrink.dts',
3197         self.assertEqual(b'a', data[:1])
3198         self.assertEqual(U_BOOT_DATA, data[1:1 + len(U_BOOT_DATA)])
3199         self.assertEqual(b'a', data[-1:])
3201     def testEntryShrinkFail(self):  argument
3203         data = self._DoReadFileDtb('140_entry_shrink.dts', update_dtb=True)[0]
3208         self.assertEqual(b'a\0', data[:2])
3209         self.assertEqual(U_BOOT_DATA, data[2:2 + len(U_BOOT_DATA)])
3210         self.assertEqual(b'a\0', data[-2:])
3212     def testDescriptorOffset(self):  argument
3214         data = self._DoReadFileDtb('141_descriptor_offset.dts')
3218         self.assertEqual(0xff800000, desc.offset);
3219         self.assertEqual(0xff800000, desc.image_pos);
3221     def testReplaceCbfs(self):  argument
3223         self._CheckLz4()
3225         data = self._DoReadFileRealDtb('142_replace_cbfs.dts')
3232         self.assertEqual(expected, data)
3234     def testReplaceResizeCbfs(self):  argument
3236         self._CheckLz4()
3238         data = self._DoReadFileRealDtb('142_replace_cbfs.dts')
3245         self.assertEqual(expected, data)
3247     def _SetupForReplace(self):  argument
3259         data = self._DoReadFileRealDtb('143_replace_all.dts')
3264         outdir = os.path.join(self._indir, 'extract')
3288     def _CheckReplaceMultiple(self, entry_paths):  argument
3302             self._SetupForReplace())
3309     def testReplaceAll(self):  argument
3312             self._CheckReplaceMultiple([]))
3314         self.assertEqual(expected1, data)
3317         self.assertEqual(expected2, data)
3320         self.assertEqual(expected_text, data)
3327         self.assertEqual('the value', node.props['my-property'].value)
3329     def testReplaceSome(self):  argument
3332             self._CheckReplaceMultiple(['u-boot2', 'text']))
3336         self.assertEqual(U_BOOT_DATA, data)
3339         self.assertEqual(expected2, data)
3342         self.assertEqual(expected_text, data)
3344     def testReplaceCmd(self):  argument
3346         self._DoReadFileRealDtb('143_replace_all.dts')
3349             tmpdir, updated_fname = self._SetupImageInTmpdir()
3355             self._DoBinman('replace', '-i', updated_fname, 'u-boot', '-f', fname)
3357             self.assertEqual(expected, data[:len(expected)])
3359             self.assertFalse(os.path.exists(map_fname))
3363     def testReplaceCmdSome(self):  argument
3366             self._SetupForReplace())
3368         self._DoBinman('replace', '-i', updated_fname, '-I', outdir,
3378         self.assertEqual(U_BOOT_DATA, data)
3381         self.assertEqual(expected2, data)
3384         self.assertEqual(expected_text, data)
3386     def testReplaceMissing(self):  argument
3389             self._SetupForReplace())
3397         self.assertIn("Skipping entry '/u-boot' from missing file",
3400     def testReplaceCmdMap(self):  argument
3402         self._DoReadFileRealDtb('143_replace_all.dts')
3405             tmpdir, updated_fname = self._SetupImageInTmpdir()
3407             fname = os.path.join(self._indir, 'update-u-boot.bin')
3411             self._DoBinman('replace', '-i', updated_fname, 'u-boot',
3414             self.assertTrue(os.path.exists(map_fname))
3418     def testReplaceNoEntryPaths(self):  argument
3420         self._DoReadFileRealDtb('143_replace_all.dts')
3422         with self.assertRaises(ValueError) as e:
3424         self.assertIn('Must specify an entry path to read with -f',
3427     def testReplaceTooManyEntryPaths(self):  argument
3429         self._DoReadFileRealDtb('143_replace_all.dts')
3431         with self.assertRaises(ValueError) as e:
3433         self.assertIn('Must specify exactly one entry path to write with -f',
3436     def testPackReset16(self):  argument
3438         data = self._DoReadFile('144_x86_reset16.dts')
3439         self.assertEqual(X86_RESET16_DATA, data[:len(X86_RESET16_DATA)])
3441     def testPackReset16Spl(self):  argument
3443         data = self._DoReadFile('145_x86_reset16_spl.dts')
3444         self.assertEqual(X86_RESET16_SPL_DATA, data[:len(X86_RESET16_SPL_DATA)])
3446     def testPackReset16Tpl(self):  argument
3448         data = self._DoReadFile('146_x86_reset16_tpl.dts')
3449         self.assertEqual(X86_RESET16_TPL_DATA, data[:len(X86_RESET16_TPL_DATA)])
3451     def testPackIntelFit(self):  argument
3453         data = self._DoReadFile('147_intel_fit.dts')
3454         self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
3456         self.assertEqual(b'_FIT_   \x01\x00\x00\x00\x00\x01\x80}' , fit)
3462         self.assertEqual(expected_ptr, ptr)
3464     def testPackIntelFitMissing(self):  argument
3466         with self.assertRaises(ValueError) as e:
3467             self._DoReadFile('148_intel_fit_missing.dts')
3468         self.assertIn("'intel-fit-ptr' section must have an 'intel-fit' sibling",
3471     def _CheckSymbolsTplSection(self, dts, expected_vals):  argument
3472         data = self._DoReadFile(dts)
3476         self.assertEqual(expected1, data[:upto1])
3480         self.assertEqual(expected2, data[upto1:upto2])
3484         self.assertEqual(expected3, data[upto2:upto3])
3487         self.assertEqual(expected4, data[upto3:upto3 + len(U_BOOT_TPL_DATA)])
3489     def testSymbolsTplSection(self):  argument
3491         self._SetupSplElf('u_boot_binman_syms')
3492         self._SetupTplElf('u_boot_binman_syms')
3493         self._CheckSymbolsTplSection('149_symbols_tpl.dts',
3496     def testSymbolsTplSectionX86(self):  argument
3498         self._SetupSplElf('u_boot_binman_syms_x86')
3499         self._SetupTplElf('u_boot_binman_syms_x86')
3500         self._CheckSymbolsTplSection('155_symbols_tpl_x86.dts',
3504     def testPackX86RomIfwiSectiom(self):  argument
3506         self._SetupIfwi('fitimage.bin')
3507         data = self._DoReadFile('151_x86_rom_ifwi_section.dts')
3508         self._CheckIfwi(data)
3510     def testPackFspM(self):  argument
3512         data = self._DoReadFile('152_intel_fsp_m.dts')
3513         self.assertEqual(FSP_M_DATA, data[:len(FSP_M_DATA)])
3515     def testPackFspS(self):  argument
3517         data = self._DoReadFile('153_intel_fsp_s.dts')
3518         self.assertEqual(FSP_S_DATA, data[:len(FSP_S_DATA)])
3520     def testPackFspT(self):  argument
3522         data = self._DoReadFile('154_intel_fsp_t.dts')
3523         self.assertEqual(FSP_T_DATA, data[:len(FSP_T_DATA)])
3525     def testMkimage(self):  argument
3527         data = self._DoReadFile('156_mkimage.dts')
3530         self.assertIn(U_BOOT_SPL_DATA, data)
3532     def testExtblob(self):  argument
3534         data = self._DoReadFile('157_blob_ext.dts')
3535         self.assertEqual(REFCODE_DATA, data)
3537     def testExtblobMissing(self):  argument
3539         with self.assertRaises(ValueError) as e:
3540             self._DoReadFile('158_blob_ext_missing.dts')
3541         self.assertIn("Filename 'missing-file' not found in input path",
3544     def testExtblobMissingOk(self):  argument
3547             self._DoTestFile('158_blob_ext_missing.dts', allow_missing=True)
3549         self.assertRegex(err, "Image 'main-section'.*missing.*: blob-ext")
3551     def testExtblobMissingOkSect(self):  argument
3554             self._DoTestFile('159_blob_ext_missing_sect.dts',
3557         self.assertRegex(err, "Image 'main-section'.*missing.*: "
3560     def testPackX86RomMeMissingDesc(self):  argument
3563             self._DoTestFile('164_x86_rom_me_missing.dts', allow_missing=True)
3565         self.assertRegex(err,
3568     def testPackX86RomMissingIfwi(self):  argument
3570         self._SetupIfwi('fitimage.bin')
3571         pathname = os.path.join(self._indir, 'fitimage.bin')
3574             self._DoTestFile('111_x86_rom_ifwi.dts', allow_missing=True)
3576         self.assertRegex(err, "Image 'main-section'.*missing.*: intel-ifwi")
3578     def testPackOverlap(self):  argument
3580         self._DoTestFile('160_pack_overlap_zero.dts')
3582     def testSimpleFit(self):  argument
3584         data = self._DoReadFile('161_fit.dts')
3585         self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
3586         self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
3593         self.assertIn('data', fnode.props)
3595         fname = os.path.join(self._indir, 'fit_data.fit')
3613         self.assertEquals('FIT description: test-desc', lines[0])
3614         self.assertIn('Created:', lines[1])
3615         self.assertIn('Image 0 (kernel)', vals)
3616         self.assertIn('Hash value', vals)
3618         self.assertIsNotNone(data_sizes)
3619         self.assertEqual(2, len(data_sizes))
3621         self.assertEqual(len(U_BOOT_DATA), int(data_sizes[0].split()[0]))
3622         self.assertEqual(len(U_BOOT_SPL_DTB_DATA), int(data_sizes[1].split()[0]))
3624     def testFitExternal(self):  argument
3626         data = self._DoReadFile('162_fit_external.dts')
3633         self.assertNotIn('data', fnode.props)
3635     def testSectionIgnoreHashSignature(self):  argument
3637         data = self._DoReadFile('165_section_ignore_hash_signature.dts')
3639         self.assertEqual(expected, data)
3641     def testPadInSections(self):  argument
3643         data, _, _, out_dtb_fname = self._DoReadFileDtb(
3648         self.assertEqual(expected, data)
3652         props = self._GetPropTree(dtb, ['size', 'image-pos', 'offset'])
3674         self.assertEqual(expected, props)
3676     def testFitImageSubentryAlignment(self):  argument
3681         data, _, _, _ = self._DoReadFileDtb('167_fit_image_subentry_alignment.dts',
3691         self.assertEqual(expected, data)
3698         self.assertEqual(expected, data)
3700     def testFitExtblobMissingOk(self):  argument
3703             self._DoTestFile('168_fit_missing_blob.dts',
3706         self.assertRegex(err, "Image 'main-section'.*missing.*: atf-bl31")
3708     def testBlobNamedByArgMissing(self):  argument
3710         with self.assertRaises(ValueError) as e:
3711             self._DoReadFile('068_blob_named_by_arg.dts')
3712         self.assertIn("Missing required properties/entry args: cros-ec-rw-path",
3715     def testPackBl31(self):  argument
3717         data = self._DoReadFile('169_atf_bl31.dts')
3718         self.assertEqual(ATF_BL31_DATA, data[:len(ATF_BL31_DATA)])
3720     def testPackScp(self):  argument
3722         data = self._DoReadFile('172_scp.dts')
3723         self.assertEqual(SCP_DATA, data[:len(SCP_DATA)])
3725     def testFitFdt(self):  argument
3736             self.assertIsNotNone(fnode)
3737             self.assertEqual({'description','type', 'compression', 'data'},
3739             self.assertEqual(expected_data, fnode.props['data'].bytes)
3740             self.assertEqual('fdt-test-fdt%d.dtb' % seq,
3751             self.assertIn('default', cnode.props)
3752             self.assertEqual('config-2', cnode.props['default'].value)
3756             self.assertIsNotNone(fnode)
3757             self.assertEqual({'description','firmware', 'loadables', 'fdt'},
3759             self.assertEqual('conf-test-fdt%d.dtb' % seq,
3761             self.assertEqual('fdt-%d' % seq, fnode.props['fdt'].value)
3767         data = self._DoReadFileDtb(
3770             extra_indirs=[os.path.join(self._indir, TEST_FDT_SUBDIR)])[0]
3771         self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
3777         self.assertIn('data', fnode.props)
3787     def testFitFdtMissingList(self):  argument
3789         with self.assertRaises(ValueError) as e:
3790             self._DoReadFile('172_fit_fdt.dts')
3791         self.assertIn("Generator node requires 'of-list' entry argument",
3794     def testFitFdtEmptyList(self):  argument
3799         data = self._DoReadFileDtb('170_fit_fdt.dts', entry_args=entry_args)[0]
3801     def testFitFdtMissingProp(self):  argument
3803         with self.assertRaises(ValueError) as e:
3804             self._DoReadFile('171_fit_fdt_missing_prop.dts')
3805         self.assertIn("Generator node requires 'fit,fdt-list' property",
3808     def testFitFdtEmptyList(self):  argument
3813         data = self._DoReadFileDtb('172_fit_fdt.dts', entry_args=entry_args)[0]
3815     def testFitFdtMissing(self):  argument
3820         with self.assertRaises(ValueError) as e:
3821             self._DoReadFileDtb(
3824                 extra_indirs=[os.path.join(self._indir, TEST_FDT_SUBDIR)])[0]
3825         self.assertIn("Generated 'default' node requires default-dt entry argument",
3828     def testFitFdtNotInList(self):  argument
3834         with self.assertRaises(ValueError) as e:
3835             self._DoReadFileDtb(
3838                 extra_indirs=[os.path.join(self._indir, TEST_FDT_SUBDIR)])[0]
3839 … self.assertIn("default-dt entry argument 'test-fdt3' not found in fdt list: test-fdt1, test-fdt2",
3842     def testFitExtblobMissingHelp(self):  argument
3848             self._DoTestFile('168_fit_missing_blob.dts',
3854         self.assertIn('You may need to build ARM Trusted', err)
3855         self.assertIn('Wibble test', err)
3856         self.assertIn('Another test', err)
3858     def testMissingBlob(self):  argument
3860         with self.assertRaises(ValueError) as e:
3861             self._DoTestFile('173_missing_blob.dts', allow_missing=True)
3862         self.assertIn("Filename 'missing' not found in input path",
3865     def testEnvironment(self):  argument
3867         data = self._DoReadFile('174_env.dts')
3868         self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
3869         self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
3871         self.assertEqual(b'\x1b\x97\x22\x7c\x01var1=1\0var2="2"\0\0\xff\xff',
3874     def testEnvironmentNoSize(self):  argument
3876         with self.assertRaises(ValueError) as e:
3877             self._DoTestFile('175_env_no_size.dts')
3878         self.assertIn("'u-boot-env' entry must have a size property",
3881     def testEnvironmentTooSmall(self):  argument
3883         with self.assertRaises(ValueError) as e:
3884             self._DoTestFile('176_env_too_small.dts')
3889         self.assertIn("too small to hold data (need %#x more bytes)" % short,
3892     def testSkipAtStart(self):  argument
3894         data = self._DoReadFile('177_skip_at_start.dts')
3895         self.assertEqual(U_BOOT_DATA, data)
3900         self.assertEqual(0, section.offset)
3901         self.assertEqual(len(U_BOOT_DATA), section.size)
3902         self.assertEqual(U_BOOT_DATA, section.GetData())
3905         self.assertEqual(16, entry.offset)
3906         self.assertEqual(len(U_BOOT_DATA), entry.size)
3907         self.assertEqual(U_BOOT_DATA, entry.data)
3909     def testSkipAtStartPad(self):  argument
3911         data = self._DoReadFile('178_skip_at_start_pad.dts')
3915         self.assertEqual(all, data)
3920         self.assertEqual(0, section.offset)
3921         self.assertEqual(len(all), section.size)
3922         self.assertEqual(all, section.GetData())
3925         self.assertEqual(16, entry.offset)
3926         self.assertEqual(len(all), entry.size)
3927         self.assertEqual(U_BOOT_DATA, entry.data)
3929     def testSkipAtStartSectionPad(self):  argument
3931         data = self._DoReadFile('179_skip_at_start_section_pad.dts')
3935         self.assertEqual(all, data)
3940         self.assertEqual(0, section.offset)
3941         self.assertEqual(len(all), section.size)
3942         self.assertEqual(U_BOOT_DATA, section.data)
3943         self.assertEqual(all, section.GetPaddedData())
3946         self.assertEqual(16, entry.offset)
3947         self.assertEqual(len(U_BOOT_DATA), entry.size)
3948         self.assertEqual(U_BOOT_DATA, entry.data)
3950     def testSectionPad(self):  argument
3952         data = self._DoReadFile('180_section_pad.dts')
3958         self.assertEqual(expected, data)
3960     def testSectionAlign(self):  argument
3962         data = self._DoReadFileDtb('181_section_align.dts', map=True)[0]
3970         self.assertEqual(expected, data)
3972     def testCompressImage(self):  argument
3974         self._CheckLz4()
3975         data, _, _, out_dtb_fname = self._DoReadFileDtb(
3979         props = self._GetPropTree(dtb, ['offset', 'image-pos', 'size',
3981         orig = self._decompress(data)
3982         self.assertEquals(COMPRESS_DATA + U_BOOT_DATA, orig)
3987         self.assertEqual(2, len(entries))
3990         self.assertEqual(COMPRESS_DATA, entry.data)
3991         self.assertEqual(len(COMPRESS_DATA), entry.size)
3994         self.assertEqual(U_BOOT_DATA, entry.data)
3995         self.assertEqual(len(U_BOOT_DATA), entry.size)
3997         self.assertEqual(len(data), image.size)
3998         self.assertEqual(COMPRESS_DATA + U_BOOT_DATA, image.uncomp_data)
3999         self.assertEqual(len(COMPRESS_DATA + U_BOOT_DATA), image.uncomp_size)
4000         orig = self._decompress(image.data)
4001         self.assertEqual(orig, image.uncomp_data)
4013         self.assertEqual(expected, props)
4015     def testCompressImageLess(self):  argument
4017         self._CheckLz4()
4018         data, _, _, out_dtb_fname = self._DoReadFileDtb(
4022         props = self._GetPropTree(dtb, ['offset', 'image-pos', 'size',
4024         orig = self._decompress(data)
4026         self.assertEquals(COMPRESS_DATA + COMPRESS_DATA + U_BOOT_DATA, orig)
4031         self.assertEqual(2, len(entries))
4034         self.assertEqual(COMPRESS_DATA_BIG, entry.data)
4035         self.assertEqual(len(COMPRESS_DATA_BIG), entry.size)
4038         self.assertEqual(U_BOOT_DATA, entry.data)
4039         self.assertEqual(len(U_BOOT_DATA), entry.size)
4041         self.assertEqual(len(data), image.size)
4042         self.assertEqual(COMPRESS_DATA_BIG + U_BOOT_DATA, image.uncomp_data)
4043         self.assertEqual(len(COMPRESS_DATA_BIG + U_BOOT_DATA),
4045         orig = self._decompress(image.data)
4046         self.assertEqual(orig, image.uncomp_data)
4058         self.assertEqual(expected, props)
4060     def testCompressSectionSize(self):  argument
4062         self._CheckLz4()
4063         data, _, _, out_dtb_fname = self._DoReadFileDtb(
4067         props = self._GetPropTree(dtb, ['offset', 'image-pos', 'size',
4069         orig = self._decompress(data)
4070         self.assertEquals(COMPRESS_DATA + U_BOOT_DATA, orig)
4084         self.assertEqual(expected, props)
4086     def testCompressSection(self):  argument
4088         self._CheckLz4()
4089         data, _, _, out_dtb_fname = self._DoReadFileDtb(
4093         props = self._GetPropTree(dtb, ['offset', 'image-pos', 'size',
4095         orig = self._decompress(data)
4096         self.assertEquals(COMPRESS_DATA + U_BOOT_DATA, orig)
4110         self.assertEqual(expected, props)
4112     def testCompressExtra(self):  argument
4114         self._CheckLz4()
4115         data, _, _, out_dtb_fname = self._DoReadFileDtb(
4119         props = self._GetPropTree(dtb, ['offset', 'image-pos', 'size',
4123         self.assertEquals(U_BOOT_DATA, base[:len(U_BOOT_DATA)])
4127         section1 = self._decompress(rest)
4129         self.assertEquals(expect1, rest[:len(expect1)])
4130         self.assertEquals(COMPRESS_DATA + U_BOOT_DATA, section1)
4133         section2 = self._decompress(rest1)
4135         self.assertEquals(expect2, rest1[:len(expect2)])
4136         self.assertEquals(COMPRESS_DATA + COMPRESS_DATA, section2)
4145         self.maxDiff = None
4185         self.assertEqual(expected, props)
4187     def testSymbolsSubsection(self):  argument
4189         elf_fname = self.ElfTestFile('u_boot_binman_syms')
4192         self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
4194         self._SetupSplElf('u_boot_binman_syms')
4195         data = self._DoReadFile('187_symbols_sub.dts')
4200         self.assertEqual(expected, data)
4202     def testReadImageEntryArg(self):  argument
4207         data = self.data = self._DoReadFileDtb(
4218         self.assertEqual(orig_image.GetEntries().keys(),
4221     def testFilesAlign(self):  argument
4223         data = self._DoReadFile('190_files_align.dts')
4227         self.assertEqual(expect, data)
4229     def testReadImageSkip(self):  argument
4231         data = self.data = self._DoReadFileRealDtb('191_read_image_skip.dts')
4235         self.assertEqual(orig_image.GetEntries().keys(),
4240         self.assertEqual(orig_entry.offset, entry.offset)
4241         self.assertEqual(orig_entry.size, entry.size)
4242         self.assertEqual(16, entry.image_pos)
4246         self.assertEquals(U_BOOT_DATA, u_boot.ReadData())

Last Index update Sat Jun 03 09:59:21 CST 2023