Lines Matching refs:len
712 init_sz, start_hi, start_lo, dummy = (len(U_BOOT_DATA), 0, TEE_ADDR, 0)
759 tree[prop_path[len(prefix):]] = fdt_util.fdt32_to_cpu(
797 self.assertEqual(len(gothelp), os.path.getsize(help_file))
798 self.assertEqual(0, len(result.stderr))
813 self.assertTrue(len(result.stdout) > 200)
814 self.assertEqual(0, len(result.stderr))
859 self.assertEqual(0, len(result.stderr))
888 self.assertEqual(len(U_BOOT_DATA), image.size)
896 self.assertEqual(3 + len(U_BOOT_DATA) + 5, image.size)
919 self.assertEqual(5, len(entries))
925 self.assertEqual(len(U_BOOT_DATA), entry.size)
931 self.assertEqual(len(U_BOOT_DATA), entry.size)
937 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
944 self.assertEqual(len(U_BOOT_DATA), entry.size)
950 self.assertEqual(len(U_BOOT_DATA), entry.size)
962 self.assertEqual(6, len(entries))
969 self.assertEqual(3 + 5 + len(U_BOOT_DATA), entry.size)
979 self.assertEqual(len(U_BOOT_DATA), entry.size)
990 self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 32 - len(U_BOOT_DATA)),
999 self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
1000 self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 16 - len(U_BOOT_DATA)),
1009 self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
1010 self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 64 - len(U_BOOT_DATA)),
1018 self.assertEqual(U_BOOT_DATA, entry.data[:len(U_BOOT_DATA)])
1019 self.assertEqual(U_BOOT_DATA + tools.get_bytes(0, 32 - len(U_BOOT_DATA)),
1035 'u-boot:size': 3 + 5 + len(U_BOOT_DATA),
1243 self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
1248 self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
1253 self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
1259 self.assertEqual(PPC_MPC85XX_BR_DATA, data[:len(PPC_MPC85XX_BR_DATA)])
1280 ucode_content = data[len(nodtb_data):]
1281 ucode_pos = len(nodtb_data)
1285 dtb_with_ucode = data[len(nodtb_data):]
1288 ucode_pos = len(nodtb_data) + fdt_len
1303 self.assertEqual(ucode_data, ucode_content[:len(ucode_data)])
1308 len(ucode_data))
1309 u_boot = data[:len(nodtb_data)]
1340 second = data[len(U_BOOT_NODTB_DATA):]
1348 ucode_pos = second.find(ucode_data) + len(U_BOOT_NODTB_DATA)
1353 len(ucode_data))
1354 first = data[:len(U_BOOT_NODTB_DATA)]
1421 self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
1422 second = data[len(U_BOOT_NODTB_DATA):]
1427 used_len = len(U_BOOT_NODTB_DATA) + fdt_len
1441 self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
1446 self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
1451 self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
1472 self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
1512 self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
1518 self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)])
1524 self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)])
1564 u_boot_offset + len(U_BOOT_DATA) if u_boot_offset else
1565 len(U_BOOT_SPL_DATA) + 1 + comp_uboot_len,
1580 tools.get_bytes(0xff, 0x38 - len(base_data)) +
1592 blen = len(base_data)
1597 ofs = blen + 1 + len(U_BOOT_DATA)
1692 'section@0/u-boot:size': len(U_BOOT_DATA),
1699 'section@1/u-boot:size': len(U_BOOT_DATA),
1798 tools.get_bytes(0, 8 - len(TEXT_DATA)) +
1807 self.assertTrue(len(stdout.getvalue()) > 0)
2006 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
2008 dtb = data[len(U_BOOT_DATA):-hashlen]
2059 self.assertEqual(X86_START16_TPL_DATA, data[:len(X86_START16_TPL_DATA)])
2176 self.assertEqual(1, len(entries))
2180 self.assertEqual(len(COMPRESS_DATA), entry.uncomp_size)
2187 'blob:uncomp-size': len(COMPRESS_DATA),
2188 'blob:size': len(data),
2189 'size': len(data),
2212 len = entries[key].size
2213 chunk = data[start:start + len]
2405 self.assertEqual(REFCODE_DATA, data[:len(REFCODE_DATA)])
2554 self.assertEqual(U_BOOT_TPL_DATA, tpl_data[:len(U_BOOT_TPL_DATA)])
2611 fdtmap_data = data[len(U_BOOT_DATA):]
2624 'u-boot:size': len(U_BOOT_DATA),
2628 'fdtmap:size': len(fdtmap_data),
2629 'size': len(data),
2650 fdtmap_pos = len(U_BOOT_DATA)
2663 fdtmap_pos = 0x100 + len(U_BOOT_DATA)
2672 fdtmap_pos = 0x100 + len(U_BOOT_DATA)
2696 self.assertEqual(U_BOOT_DATA, data[3:3 + len(U_BOOT_DATA)])
2710 self.assertEqual(U_BOOT_DATA, data[3:3 + len(U_BOOT_DATA)])
2717 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
2718 comp_data = data[len(U_BOOT_DATA):]
2724 'u-boot:size': len(U_BOOT_DATA),
2725 'u-boot-dtb:uncomp-size': len(orig),
2726 'u-boot-dtb:size': len(comp_data),
2727 'size': len(data),
2742 'size': len(data),
2745 'cbfs:size': len(data),
2748 'cbfs/u-boot:uncomp-size': len(U_BOOT_DATA),
2751 'cbfs/u-boot-dtb:size': len(U_BOOT_DATA),
2767 self.assertEqual(7, len(entries))
2773 self.assertEqual(len(data), ent.size)
2782 self.assertEqual(len(U_BOOT_DATA), ent.size)
2809 self.assertEqual(len(U_BOOT_DATA), ent.size)
2818 self.assertGreater(len(COMPRESS_DATA), ent.size)
2820 self.assertEqual(len(COMPRESS_DATA), ent.uncomp_size)
2828 self.assertEqual(len(U_BOOT_DTB_DATA), ent.uncomp_size)
2831 self.assertGreater(dtb_size, len(U_BOOT_DTB_DATA))
2834 self.assertEqual(len(data), 0x100 + section_size)
3029 self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
3034 self.assertEqual(EXTRACT_DTB_SIZE, len(data))
3040 self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
3050 self.assertEqual(EXTRACT_DTB_SIZE, len(data))
3058 self.assertEqual(EXTRACT_DTB_SIZE, len(dtb))
3130 self.assertEqual(expect_size, len(data))
3153 self.assertEqual(9, len(outfiles))
3154 self.assertEqual(9, len(einfos))
3186 self.assertEqual(0, len(outfiles))
3244 self.assertEqual(3, len(entries))
3251 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
3252 self.assertEqual(len(U_BOOT_DATA), entry.size)
3259 self.assertEqual(len(U_BOOT_DATA), section0.size)
3267 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
3268 self.assertEqual(len(U_BOOT_DATA), entry.size)
3283 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
3284 self.assertEqual(len(U_BOOT_DATA), entry.size)
3299 self.assertEqual(len(U_BOOT_DATA), entry.contents_size)
3300 self.assertEqual(len(U_BOOT_DATA), entry.size)
3350 expected = b'x' * len(U_BOOT_DATA)
3388 expected = b'x' * len(U_BOOT_DATA)
3515 self.assertEqual(len(expected), fdt_util.GetInt(node, 'size'))
3522 self.assertEqual(len(expected), fdt_util.GetInt(fnode, 'size'))
3541 self.assertEqual(U_BOOT_DATA, data[1:1 + len(U_BOOT_DATA)])
3552 self.assertEqual(U_BOOT_DATA, data[2:2 + len(U_BOOT_DATA)])
3567 expected = b'x' * len(U_BOOT_DATA)
3695 expected = b'x' * len(U_BOOT_DATA)
3700 self.assertEqual(expected, data[:len(expected)])
3751 expected = b'x' * len(U_BOOT_DATA)
3782 self.assertEqual(X86_RESET16_DATA, data[:len(X86_RESET16_DATA)])
3787 self.assertEqual(X86_RESET16_SPL_DATA, data[:len(X86_RESET16_SPL_DATA)])
3792 self.assertEqual(X86_RESET16_TPL_DATA, data[:len(X86_RESET16_TPL_DATA)])
3797 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
3817 upto1 = 4 + len(U_BOOT_SPL_DATA)
3821 upto2 = upto1 + 1 + len(U_BOOT_SPL_DATA)
3825 upto3 = 0x3c + len(U_BOOT_DATA)
3830 self.assertEqual(expected4, data[upto3:upto3 + len(U_BOOT_TPL_DATA)])
3856 self.assertEqual(FSP_M_DATA, data[:len(FSP_M_DATA)])
3861 self.assertEqual(FSP_S_DATA, data[:len(FSP_S_DATA)])
3866 self.assertEqual(FSP_T_DATA, data[:len(FSP_T_DATA)])
3979 self.assertEqual(2, len(data_sizes))
3981 self.assertEqual(len(kernel_data), int(data_sizes[0].split()[0]))
3982 self.assertEqual(len(fdt1_data), int(data_sizes[1].split()[0]))
3995 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
3996 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
3997 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
4004 self.assertEqual(U_BOOT_EXP_DATA, data[:len(U_BOOT_EXP_DATA)])
4005 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
4006 fit_data = data[len(U_BOOT_EXP_DATA):-len(U_BOOT_NODTB_DATA)]
4064 self.assertEqual(len(expected), size)
4070 fit_data = data[len(U_BOOT_DATA):-2] # _testing is 2 bytes
4073 external_data_size = len(U_BOOT_DATA) + 2
4074 expected_size = (len(U_BOOT_DATA) + 0x400 +
4076 len(U_BOOT_NODTB_DATA))
4083 self.assertEqual(len(U_BOOT_DATA),
4090 self.assertEqual(expected_size, len(data))
4091 actual_pos = len(U_BOOT_DATA) + fit_pos
4148 self.assertEqual(len(expected), size)
4188 'size': 12 + 6 + 3 * len(U_BOOT_DATA),
4192 'section:size': 12 + 6 + 3 * len(U_BOOT_DATA),
4196 'section/before:size': len(U_BOOT_DATA),
4200 'section/u-boot:size': 12 + len(U_BOOT_DATA) + 6,
4204 'section/after:size': len(U_BOOT_DATA),
4221 align_pad = 0x10 - (len(U_BOOT_SPL_DATA) % 0x10)
4251 self.assertEqual(ATF_BL31_DATA, data[:len(ATF_BL31_DATA)])
4256 self.assertEqual(SCP_DATA, data[:len(SCP_DATA)])
4275 'fdt-test-fdt%s.dtb' % val if len(val) == 1 else
4291 'config-2' if len(val) == 1 else
4302 'conf-test-fdt%s.dtb' % val if len(val) == 1 else
4322 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
4323 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
4425 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
4426 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
4427 env = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
4444 need = 4 + 1 + len(ENV_DATA) + 1 + 1
4458 self.assertEqual(len(U_BOOT_DATA), section.size)
4463 self.assertEqual(len(U_BOOT_DATA), entry.size)
4478 self.assertEqual(len(all), section.size)
4483 self.assertEqual(len(all), entry.size)
4498 self.assertEqual(len(all), section.size)
4504 self.assertEqual(len(U_BOOT_DATA), entry.size)
4544 self.assertEqual(2, len(entries))
4548 self.assertEqual(len(COMPRESS_DATA), entry.size)
4552 self.assertEqual(len(U_BOOT_DATA), entry.size)
4554 self.assertEqual(len(data), image.size)
4556 self.assertEqual(len(COMPRESS_DATA + U_BOOT_DATA), image.uncomp_size)
4562 'blob:size': len(COMPRESS_DATA),
4563 'u-boot:offset': len(COMPRESS_DATA),
4564 'u-boot:size': len(U_BOOT_DATA),
4565 'uncomp-size': len(COMPRESS_DATA + U_BOOT_DATA),
4568 'size': len(data),
4588 self.assertEqual(2, len(entries))
4592 self.assertEqual(len(COMPRESS_DATA_BIG), entry.size)
4596 self.assertEqual(len(U_BOOT_DATA), entry.size)
4598 self.assertEqual(len(data), image.size)
4600 self.assertEqual(len(COMPRESS_DATA_BIG + U_BOOT_DATA),
4607 'blob:size': len(COMPRESS_DATA_BIG),
4608 'u-boot:offset': len(COMPRESS_DATA_BIG),
4609 'u-boot:size': len(U_BOOT_DATA),
4610 'uncomp-size': len(COMPRESS_DATA_BIG + U_BOOT_DATA),
4613 'size': len(data),
4632 'section/blob:size': len(COMPRESS_DATA),
4633 'section/u-boot:offset': len(COMPRESS_DATA),
4634 'section/u-boot:size': len(U_BOOT_DATA),
4637 'section:uncomp-size': len(COMPRESS_DATA + U_BOOT_DATA),
4658 'section/blob:size': len(COMPRESS_DATA),
4659 'section/u-boot:offset': len(COMPRESS_DATA),
4660 'section/u-boot:size': len(U_BOOT_DATA),
4663 'section:uncomp-size': len(COMPRESS_DATA + U_BOOT_DATA),
4664 'section:size': len(data),
4667 'size': len(data),
4689 base = data[len(U_BOOT_DATA):]
4690 self.assertEqual(U_BOOT_DATA, base[:len(U_BOOT_DATA)])
4691 rest = base[len(U_BOOT_DATA):]
4696 data1 = rest[:len(expect1)]
4700 rest1 = rest[len(expect1):]
4703 data2 = rest1[:len(expect2)]
4707 rest2 = rest1[len(expect2):]
4709 expect_size = (len(U_BOOT_DATA) + len(U_BOOT_DATA) + len(expect1) +
4710 len(expect2) + len(U_BOOT_DATA))
4719 'u-boot:size': len(U_BOOT_DATA),
4721 'base:offset': len(U_BOOT_DATA),
4722 'base:image-pos': len(U_BOOT_DATA),
4723 'base:size': len(data) - len(U_BOOT_DATA),
4725 'base/u-boot:image-pos': len(U_BOOT_DATA),
4726 'base/u-boot:size': len(U_BOOT_DATA),
4727 'base/u-boot2:offset': len(U_BOOT_DATA) + len(expect1) +
4728 len(expect2),
4729 'base/u-boot2:image-pos': len(U_BOOT_DATA) * 2 + len(expect1) +
4730 len(expect2),
4731 'base/u-boot2:size': len(U_BOOT_DATA),
4733 'base/section:offset': len(U_BOOT_DATA),
4734 'base/section:image-pos': len(U_BOOT_DATA) * 2,
4735 'base/section:size': len(expect1),
4736 'base/section:uncomp-size': len(COMPRESS_DATA + U_BOOT_DATA),
4738 'base/section/blob:size': len(COMPRESS_DATA),
4739 'base/section/u-boot:offset': len(COMPRESS_DATA),
4740 'base/section/u-boot:size': len(U_BOOT_DATA),
4742 'base/section2:offset': len(U_BOOT_DATA) + len(expect1),
4743 'base/section2:image-pos': len(U_BOOT_DATA) * 2 + len(expect1),
4744 'base/section2:size': len(expect2),
4745 'base/section2:uncomp-size': len(COMPRESS_DATA + COMPRESS_DATA),
4747 'base/section2/blob:size': len(COMPRESS_DATA),
4748 'base/section2/blob2:offset': len(COMPRESS_DATA),
4749 'base/section2/blob2:size': len(COMPRESS_DATA),
4753 'size': len(data),
4812 data[:len(U_BOOT_TPL_NODTB_DATA)])
4847 'size': len(data),
4850 'u-boot-spl/u-boot-spl-nodtb:size': len(U_BOOT_SPL_NODTB_DATA),
4852 'u-boot-tpl:size': len(U_BOOT_TPL_DATA),
4854 'u-boot/u-boot-nodtb:size': len(U_BOOT_NODTB_DATA),
4874 self.assertEqual(3, len(entries))
4881 self.assertEqual(2, len(subent))
4890 self.assertEqual(3, len(subent))
4914 self.assertEqual(1, len(entries))
4921 self.assertEqual(3, len(subent))
4947 self.assertEqual(2, len(subent))
4963 self.assertEqual(1, len(entries))
4970 self.assertEqual(2, len(subent))
4994 start = len(U_BOOT_NODTB_DATA)
4998 start += fdt_size + len(U_BOOT_SPL_NODTB_DATA) + pad_len
5002 start += fdt_size + len(U_BOOT_TPL_DATA)
5003 self.assertEqual(len(data), start)
5037 expected = (U_BOOT_DATA + tools.get_bytes(0, 8 - len(U_BOOT_DATA)) +
5040 expected += tools.get_bytes(0, 32 - len(expected))
5044 expected += tools.get_bytes(0, 88 - len(expected)) + U_BOOT_NODTB_DATA
5050 self.assertEqual(OPENSBI_DATA, data[:len(OPENSBI_DATA)])
5106 'section@0/u-boot:size': len(U_BOOT_DATA),
5113 'section@1/u-boot:size': len(U_BOOT_DATA),
5243 self.assertEqual(2, len(fents))
5251 self.assertEqual(len(ATF_BL31_DATA), fent.size)
5262 self.assertEqual(len(ATF_BL31_DATA), fent.size)
5272 self.assertEqual(2, len(fents))
5289 self.assertEqual(2, len(fents))
5350 'fdtmap:size': len(fdtmap_data),
5351 'size': len(data),
5378 self.assertEqual(2, len(fents))
5383 self.assertEqual(len(expected), fent.size)
5397 self.assertEqual(0x100 + len(U_BOOT_DATA), len(data))
5402 self.assertEqual(1, len(fents))
5407 self.assertEqual(len(ATF_BL31_DATA), fent.size)
5411 rest = data[0x60 + len(ATF_BL31_DATA):0x100]
5412 self.assertEqual(tools.get_bytes(0xff, len(rest)), rest)
5434 self.assertEqual(entry1.size - len(U_BOOT_DATA), entry2.size)
5464 self.assertTrue(len(out) >= 2)
5493 self.assertTrue(len(stdout.getvalue()) > 0)
5577 self.assertEqual(TEE_OS_DATA, data[:len(TEE_OS_DATA)])
5582 self.assertEqual(TI_DM_DATA, data[:len(TI_DM_DATA)])
5587 self.assertEqual(ATF_BL1_DATA, data[:len(ATF_BL1_DATA)])
5642 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
5643 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
5654 self.assertEqual(2, len(segments))
5831 self.assertEqual(PRE_LOAD_MAGIC, data[:len(PRE_LOAD_MAGIC)])
5832 self.assertEqual(PRE_LOAD_VERSION, data[4:4 + len(PRE_LOAD_VERSION)])
5833 self.assertEqual(PRE_LOAD_HDR_SIZE, data[8:8 + len(PRE_LOAD_HDR_SIZE)])
5850 self.assertEqual(PRE_LOAD_MAGIC, data[:len(PRE_LOAD_MAGIC)])
5851 self.assertEqual(PRE_LOAD_VERSION, data[4:4 + len(PRE_LOAD_VERSION)])
5852 self.assertEqual(PRE_LOAD_HDR_SIZE, data[8:8 + len(PRE_LOAD_HDR_SIZE)])
5861 self.assertEqual(PRE_LOAD_MAGIC, data[:len(PRE_LOAD_MAGIC)])
5862 self.assertEqual(PRE_LOAD_VERSION, data[4:4 + len(PRE_LOAD_VERSION)])
5863 self.assertEqual(PRE_LOAD_HDR_SIZE, data[8:8 + len(PRE_LOAD_HDR_SIZE)])
5932 self.assertEqual(expected, data[:len(expected)])
5943 self.assertEqual(expected, data[:len(expected)])
5951 self.assertEqual(expected, data[:len(expected)])
5956 tools.write_file(fname, b'x' * len(U_BOOT_DATA))
5961 expected = b'x' * len(U_BOOT_DATA) + b'aa'
5962 self.assertEqual(expected, data[:len(expected)])
5968 expected = b'x' * len(U_BOOT_DATA)
5980 expected = new_data.ljust(len(U_BOOT_DATA), b'\0')
6024 new_data = b'x' * len(U_BOOT_DATA)
6036 new_data = b'ub' * len(U_BOOT_NODTB_DATA)
6050 expected = new_data.ljust(len(U_BOOT_NODTB_DATA), b'\0')
6062 new_data = b'w' * len(COMPRESS_DATA + U_BOOT_DATA)
6070 self.assertEqual(len(new_data), entry.size)
6074 new_data = b'w' * (len(COMPRESS_DATA + U_BOOT_DATA) + 1)
6082 self.assertEqual(len(new_data), entry.size)
6088 new_data = b'w' * (len(COMPRESS_DATA + U_BOOT_DATA) - 1) + b'\0'
6097 self.assertEqual(len(new_data), entry.size)
6101 new_data = b'w' * (len(COMPRESS_DATA + U_BOOT_DATA) - 1)
6186 self.assertEqual(expect, data[:len(expect)])
6211 'u-boot:size': len(U_BOOT_DATA),
6212 'u-boot-dtb:uncomp-size': len(orig),
6215 'size': len(data),
6220 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
6221 rest = data[len(U_BOOT_DATA):]
6274 expect = struct.pack('>I', len(U_BOOT_TPL_DATA))
6275 expect += struct.pack('>I', len(U_BOOT_SPL_DATA))
6280 align_pad = len(U_BOOT_TPL_DATA) % 4
6284 self.assertEqual(expect, data[-len(expect):])
6306 self.assertEqual(len(tpl_expect), lens[0])
6307 self.assertEqual(len(spl_expect), lens[1])
6311 self.assertEqual(tpl_expect, rest[:len(tpl_expect)])
6313 rest = rest[len(tpl_expect):]
6314 align_pad = len(tpl_expect) % 4
6347 data[:len(U_BOOT_VPL_NODTB_DATA)])
6361 self.assertEqual(1, len(entries))
6368 self.assertEqual(3, len(subent))
6609 self.assertEqual(U_BOOT_DATA, data[:len(U_BOOT_DATA)])
6612 fhdr, fentries = fmap_util.DecodeFmap(data[len(U_BOOT_DATA):])
6619 self.assertEqual(len(U_BOOT_DATA), fentry.size)
6625 self.assertEqual(len(U_BOOT_DATA), fentry.size)
6637 self.assertEqual(len(U_BOOT_DATA), fentry.offset)
6672 self.assertEqual(expected, data[:len(expected)])
6705 self.assertEqual(4096, len(data))
6782 expect_data = b'w' * len(U_BOOT_DATA + COMPRESS_DATA)
6794 self.assertEqual(len(expect_data), entry.size)
6799 new_blob_data = data[entry.image_pos:entry.image_pos + len(expect_data)]
6803 data[entry.image_pos + len(expect_data):]
6804 [:len(U_BOOT_DATA)])
6808 expect_data = b'w' * len(U_BOOT_DATA + COMPRESS_DATA)
6825 self.assertEqual(len(expect_data), entry.size)
6830 new_blob_data = data[entry.image_pos:entry.image_pos + len(expect_data)]
6834 data[entry.image_pos + len(expect_data):]
6835 [:len(U_BOOT_DATA)])
6848 expected = b'w' * (len(COMPRESS_DATA + U_BOOT_DATA) + 1)
6853 start = len(U_BOOT_DTB_DATA)
6854 self.assertEqual(expected, data[start:start + len(expected)])
6889 self.assertEqual(ROCKCHIP_TPL_DATA, data[:len(ROCKCHIP_TPL_DATA)])
7019 self.assertEqual(U_BOOT_NODTB_DATA, data[-len(U_BOOT_NODTB_DATA):])
7020 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
7144 self.assertEqual(len(U_BOOT_DATA), vals[4])
7207 self.assertGreater(len(data), len(TI_UNSECURE_DATA))
7219 self.assertGreater(len(data_firewall),len(data_no_firewall))
7258 self.assertGreater(len(data), len(TI_UNSECURE_DATA))
7259 self.assertGreater(len(data_a), len(TI_UNSECURE_DATA))
7260 self.assertGreater(len(data_b), len(TI_UNSECURE_DATA))
7270 self.assertGreater(len(data), len(TI_UNSECURE_DATA))
7465 payload_data_len = len(EFI_CAPSULE_DATA)
7682 self.assertEqual(xpl_data, data[:len(xpl_data)])
7683 rest = data[len(xpl_data):]
7704 self.assertEqual(xpl_data, data[:len(xpl_data)])
7705 rest = data[len(xpl_data):]
7733 self.assertEqual(5, len(node.props.keys()))
7804 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
7836 fit_data = data[len(U_BOOT_DATA):-len(U_BOOT_NODTB_DATA)]
7905 self.assertEqual(len(IMX_LPDDR_IMEM_DATA).to_bytes(4, 'little') +
7906 len(IMX_LPDDR_DMEM_DATA).to_bytes(4, 'little') +
8041 self.assertEqual(data_size_unciphered, len(U_BOOT_NODTB_DATA))
8100 self.assertEqual(len(subnode4.props), 0,