binman: Move to three-digit test-file numbers

We now have 99 tests. Before adding any more, rename everything to three
digits. This helps to preserve the ordering of tests and makes it easier
to find things.

Signed-off-by: Simon Glass <sjg@chromium.org>

101 files changed, 115 insertions, 115 deletions

diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py
index 17ab229014..1f7ff5b4e4 100644
--- a/tools/binman/entry_test.py
+++ b/tools/binman/entry_test.py
@@ -25,7 +25,7 @@ class TestEntry(unittest.TestCase):
     def GetNode(self):
         binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
         fname = fdt_util.EnsureCompiled(
-            os.path.join(binman_dir,('test/05_simple.dts')))
+            os.path.join(binman_dir,('test/005_simple.dts')))
         dtb = fdt.FdtScan(fname)
         return dtb.GetNode('/binman/u-boot')
 
diff --git a/tools/binman/fdt_test.py b/tools/binman/fdt_test.py
index b9167012d2..ac6f910d3c 100644
--- a/tools/binman/fdt_test.py
+++ b/tools/binman/fdt_test.py
@@ -36,12 +36,12 @@ class TestFdt(unittest.TestCase):
         node.DeleteProp('data')
 
     def testFdtNormal(self):
-        fname = self.GetCompiled('34_x86_ucode.dts')
+        fname = self.GetCompiled('034_x86_ucode.dts')
         dt = FdtScan(fname)
         self._DeleteProp(dt)
 
     def testFdtNormalProp(self):
-        fname = self.GetCompiled('45_prop_test.dts')
+        fname = self.GetCompiled('045_prop_test.dts')
         dt = FdtScan(fname)
         node = dt.GetNode('/binman/intel-me')
         self.assertEquals('intel-me', node.name)
diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py
index 9f21027bd4..167f56dd06 100644
--- a/tools/binman/ftest.py
+++ b/tools/binman/ftest.py
@@ -189,7 +189,7 @@ class TestFunctional(unittest.TestCase):
         """Run binman with a given test file
 
         Args:
-            fname: Device-tree source filename to use (e.g. 05_simple.dts)
+            fname: Device-tree source filename to use (e.g. 005_simple.dts)
             debug: True to enable debugging output
             map: True to output map files for the images
             update_dtb: Update the offset and size of each entry in the device
@@ -266,7 +266,7 @@ class TestFunctional(unittest.TestCase):
         Raises an assertion failure if binman returns a non-zero exit code.
 
         Args:
-            fname: Device-tree source filename to use (e.g. 05_simple.dts)
+            fname: Device-tree source filename to use (e.g. 005_simple.dts)
             use_real_dtb: True to use the test file as the contents of
                 the u-boot-dtb entry. Normally this is not needed and the
                 test contents (the U_BOOT_DTB_DATA string) can be used.
@@ -323,7 +323,7 @@ class TestFunctional(unittest.TestCase):
         """Helper function which discards the device-tree binary
 
         Args:
-            fname: Device-tree source filename to use (e.g. 05_simple.dts)
+            fname: Device-tree source filename to use (e.g. 005_simple.dts)
             use_real_dtb: True to use the test file as the contents of
                 the u-boot-dtb entry. Normally this is not needed and the
                 test contents (the U_BOOT_DTB_DATA string) can be used.
@@ -464,7 +464,7 @@ class TestFunctional(unittest.TestCase):
 
     def testBoard(self):
         """Test that we can run it with a specific board"""
-        self._SetupDtb('05_simple.dts', 'sandbox/u-boot.dtb')
+        self._SetupDtb('005_simple.dts', 'sandbox/u-boot.dtb')
         TestFunctional._MakeInputFile('sandbox/u-boot.bin', U_BOOT_DATA)
         result = self._DoBinman('-b', 'sandbox')
         self.assertEqual(0, result)
@@ -491,19 +491,19 @@ class TestFunctional(unittest.TestCase):
         will come from the device-tree compiler (dtc).
         """
         with self.assertRaises(Exception) as e:
-            self._RunBinman('-d', self.TestFile('01_invalid.dts'))
+            self._RunBinman('-d', self.TestFile('001_invalid.dts'))
         self.assertIn("FATAL ERROR: Unable to parse input tree",
                 str(e.exception))
 
     def testMissingNode(self):
         """Test that a device tree without a 'binman' node generates an error"""
         with self.assertRaises(Exception) as e:
-            self._DoBinman('-d', self.TestFile('02_missing_node.dts'))
+            self._DoBinman('-d', self.TestFile('002_missing_node.dts'))
         self.assertIn("does not have a 'binman' node", str(e.exception))
 
     def testEmpty(self):
         """Test that an empty binman node works OK (i.e. does nothing)"""
-        result = self._RunBinman('-d', self.TestFile('03_empty.dts'))
+        result = self._RunBinman('-d', self.TestFile('003_empty.dts'))
         self.assertEqual(0, len(result.stderr))
         self.assertEqual(0, result.return_code)
 
@@ -511,25 +511,25 @@ class TestFunctional(unittest.TestCase):
         """Test that an invalid entry is flagged"""
         with self.assertRaises(Exception) as e:
             result = self._RunBinman('-d',
-                                     self.TestFile('04_invalid_entry.dts'))
+                                     self.TestFile('004_invalid_entry.dts'))
         self.assertIn("Unknown entry type 'not-a-valid-type' in node "
                 "'/binman/not-a-valid-type'", str(e.exception))
 
     def testSimple(self):
         """Test a simple binman with a single file"""
-        data = self._DoReadFile('05_simple.dts')
+        data = self._DoReadFile('005_simple.dts')
         self.assertEqual(U_BOOT_DATA, data)
 
     def testSimpleDebug(self):
         """Test a simple binman run with debugging enabled"""
-        data = self._DoTestFile('05_simple.dts', debug=True)
+        data = self._DoTestFile('005_simple.dts', debug=True)
 
     def testDual(self):
         """Test that we can handle creating two images
 
         This also tests image padding.
         """
-        retcode = self._DoTestFile('06_dual_image.dts')
+        retcode = self._DoTestFile('006_dual_image.dts')
         self.assertEqual(0, retcode)
 
         image = control.images['image1']
@@ -553,13 +553,13 @@ class TestFunctional(unittest.TestCase):
     def testBadAlign(self):
         """Test that an invalid alignment value is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('07_bad_align.dts')
+            self._DoTestFile('007_bad_align.dts')
         self.assertIn("Node '/binman/u-boot': Alignment 23 must be a power "
                       "of two", str(e.exception))
 
     def testPackSimple(self):
         """Test that packing works as expected"""
-        retcode = self._DoTestFile('08_pack.dts')
+        retcode = self._DoTestFile('008_pack.dts')
         self.assertEqual(0, retcode)
         self.assertIn('image', control.images)
         image = control.images['image']
@@ -601,7 +601,7 @@ class TestFunctional(unittest.TestCase):
 
     def testPackExtra(self):
         """Test that extra packing feature works as expected"""
-        retcode = self._DoTestFile('09_pack_extra.dts')
+        retcode = self._DoTestFile('009_pack_extra.dts')
 
         self.assertEqual(0, retcode)
         self.assertIn('image', control.images)
@@ -646,35 +646,35 @@ class TestFunctional(unittest.TestCase):
     def testPackAlignPowerOf2(self):
         """Test that invalid entry alignment is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('10_pack_align_power2.dts')
+            self._DoTestFile('010_pack_align_power2.dts')
         self.assertIn("Node '/binman/u-boot': Alignment 5 must be a power "
                       "of two", str(e.exception))
 
     def testPackAlignSizePowerOf2(self):
         """Test that invalid entry size alignment is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('11_pack_align_size_power2.dts')
+            self._DoTestFile('011_pack_align_size_power2.dts')
         self.assertIn("Node '/binman/u-boot': Alignment size 55 must be a "
                       "power of two", str(e.exception))
 
     def testPackInvalidAlign(self):
         """Test detection of an offset that does not match its alignment"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('12_pack_inv_align.dts')
+            self._DoTestFile('012_pack_inv_align.dts')
         self.assertIn("Node '/binman/u-boot': Offset 0x5 (5) does not match "
                       "align 0x4 (4)", str(e.exception))
 
     def testPackInvalidSizeAlign(self):
         """Test that invalid entry size alignment is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('13_pack_inv_size_align.dts')
+            self._DoTestFile('013_pack_inv_size_align.dts')
         self.assertIn("Node '/binman/u-boot': Size 0x5 (5) does not match "
                       "align-size 0x4 (4)", str(e.exception))
 
     def testPackOverlap(self):
         """Test that overlapping regions are detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('14_pack_overlap.dts')
+            self._DoTestFile('014_pack_overlap.dts')
         self.assertIn("Node '/binman/u-boot-align': Offset 0x3 (3) overlaps "
                       "with previous entry '/binman/u-boot' ending at 0x4 (4)",
                       str(e.exception))
@@ -682,20 +682,20 @@ class TestFunctional(unittest.TestCase):
     def testPackEntryOverflow(self):
         """Test that entries that overflow their size are detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('15_pack_overflow.dts')
+            self._DoTestFile('015_pack_overflow.dts')
         self.assertIn("Node '/binman/u-boot': Entry contents size is 0x4 (4) "
                       "but entry size is 0x3 (3)", str(e.exception))
 
     def testPackImageOverflow(self):
         """Test that entries which overflow the image size are detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('16_pack_image_overflow.dts')
+            self._DoTestFile('016_pack_image_overflow.dts')
         self.assertIn("Section '/binman': contents size 0x4 (4) exceeds section "
                       "size 0x3 (3)", str(e.exception))
 
     def testPackImageSize(self):
         """Test that the image size can be set"""
-        retcode = self._DoTestFile('17_pack_image_size.dts')
+        retcode = self._DoTestFile('017_pack_image_size.dts')
         self.assertEqual(0, retcode)
         self.assertIn('image', control.images)
         image = control.images['image']
@@ -703,7 +703,7 @@ class TestFunctional(unittest.TestCase):
 
     def testPackImageSizeAlign(self):
         """Test that image size alignemnt works as expected"""
-        retcode = self._DoTestFile('18_pack_image_align.dts')
+        retcode = self._DoTestFile('018_pack_image_align.dts')
         self.assertEqual(0, retcode)
         self.assertIn('image', control.images)
         image = control.images['image']
@@ -712,26 +712,26 @@ class TestFunctional(unittest.TestCase):
     def testPackInvalidImageAlign(self):
         """Test that invalid image alignment is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('19_pack_inv_image_align.dts')
+            self._DoTestFile('019_pack_inv_image_align.dts')
         self.assertIn("Section '/binman': Size 0x7 (7) does not match "
                       "align-size 0x8 (8)", str(e.exception))
 
     def testPackAlignPowerOf2(self):
         """Test that invalid image alignment is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('20_pack_inv_image_align_power2.dts')
+            self._DoTestFile('020_pack_inv_image_align_power2.dts')
         self.assertIn("Section '/binman': Alignment size 131 must be a power of "
                       "two", str(e.exception))
 
     def testImagePadByte(self):
         """Test that the image pad byte can be specified"""
         self._SetupSplElf()
-        data = self._DoReadFile('21_image_pad.dts')
+        data = self._DoReadFile('021_image_pad.dts')
         self.assertEqual(U_BOOT_SPL_DATA + (chr(0xff) * 1) + U_BOOT_DATA, data)
 
     def testImageName(self):
         """Test that image files can be named"""
-        retcode = self._DoTestFile('22_image_name.dts')
+        retcode = self._DoTestFile('022_image_name.dts')
         self.assertEqual(0, retcode)
         image = control.images['image1']
         fname = tools.GetOutputFilename('test-name')
@@ -743,33 +743,33 @@ class TestFunctional(unittest.TestCase):
 
     def testBlobFilename(self):
         """Test that generic blobs can be provided by filename"""
-        data = self._DoReadFile('23_blob.dts')
+        data = self._DoReadFile('023_blob.dts')
         self.assertEqual(BLOB_DATA, data)
 
     def testPackSorted(self):
         """Test that entries can be sorted"""
         self._SetupSplElf()
-        data = self._DoReadFile('24_sorted.dts')
+        data = self._DoReadFile('024_sorted.dts')
         self.assertEqual(chr(0) * 1 + U_BOOT_SPL_DATA + chr(0) * 2 +
                          U_BOOT_DATA, data)
 
     def testPackZeroOffset(self):
         """Test that an entry at offset 0 is not given a new offset"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('25_pack_zero_size.dts')
+            self._DoTestFile('025_pack_zero_size.dts')
         self.assertIn("Node '/binman/u-boot-spl': Offset 0x0 (0) overlaps "
                       "with previous entry '/binman/u-boot' ending at 0x4 (4)",
                       str(e.exception))
 
     def testPackUbootDtb(self):
         """Test that a device tree can be added to U-Boot"""
-        data = self._DoReadFile('26_pack_u_boot_dtb.dts')
+        data = self._DoReadFile('026_pack_u_boot_dtb.dts')
         self.assertEqual(U_BOOT_NODTB_DATA + U_BOOT_DTB_DATA, data)
 
     def testPackX86RomNoSize(self):
         """Test that the end-at-4gb property requires a size property"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('27_pack_4gb_no_size.dts')
+            self._DoTestFile('027_pack_4gb_no_size.dts')
         self.assertIn("Section '/binman': Section size must be provided when "
                       "using end-at-4gb", str(e.exception))
 
@@ -784,7 +784,7 @@ class TestFunctional(unittest.TestCase):
     def testPackX86RomOutside(self):
         """Test that the end-at-4gb property checks for offset boundaries"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('28_pack_4gb_outside.dts')
+            self._DoTestFile('028_pack_4gb_outside.dts')
         self.assertIn("Node '/binman/u-boot': Offset 0x0 (0) is outside "
                       "the section starting at 0xffffffe0 (4294967264)",
                       str(e.exception))
@@ -792,7 +792,7 @@ class TestFunctional(unittest.TestCase):
     def testPackX86Rom(self):
         """Test that a basic x86 ROM can be created"""
         self._SetupSplElf()
-        data = self._DoReadFile('29_x86-rom.dts')
+        data = self._DoReadFile('029_x86-rom.dts')
         self.assertEqual(U_BOOT_DATA + chr(0) * 7 + U_BOOT_SPL_DATA +
                          chr(0) * 2, data)
 
@@ -800,31 +800,31 @@ class TestFunctional(unittest.TestCase):
         """Test that an invalid Intel descriptor entry is detected"""
         TestFunctional._MakeInputFile('descriptor.bin', '')
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('31_x86-rom-me.dts')
+            self._DoTestFile('031_x86-rom-me.dts')
         self.assertIn("Node '/binman/intel-descriptor': Cannot find FD "
                       "signature", str(e.exception))
 
     def testPackX86RomBadDesc(self):
         """Test that the Intel requires a descriptor entry"""
         with self.assertRaises(ValueError) as e:
-            self._DoTestFile('30_x86-rom-me-no-desc.dts')
+            self._DoTestFile('030_x86-rom-me-no-desc.dts')
         self.assertIn("Node '/binman/intel-me': No offset set with "
                       "offset-unset: should another entry provide this correct "
                       "offset?", str(e.exception))
 
     def testPackX86RomMe(self):
         """Test that an x86 ROM with an ME region can be created"""
-        data = self._DoReadFile('31_x86-rom-me.dts')
+        data = self._DoReadFile('031_x86-rom-me.dts')
         self.assertEqual(ME_DATA, data[0x1000:0x1000 + len(ME_DATA)])
 
     def testPackVga(self):
         """Test that an image with a VGA binary can be created"""
-        data = self._DoReadFile('32_intel-vga.dts')
+        data = self._DoReadFile('032_intel-vga.dts')
         self.assertEqual(VGA_DATA, data[:len(VGA_DATA)])
 
     def testPackStart16(self):
         """Test that an image with an x86 start16 region can be created"""
-        data = self._DoReadFile('33_x86-start16.dts')
+        data = self._DoReadFile('033_x86-start16.dts')
         self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])
 
     def testPackPowerpcMpc85xxBootpgResetvec(self):
@@ -893,7 +893,7 @@ class TestFunctional(unittest.TestCase):
             u-boot.dtb with the microcode removed
             the microcode
         """
-        first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts',
+        first, pos_and_size = self._RunMicrocodeTest('034_x86_ucode.dts',
                                                      U_BOOT_NODTB_DATA)
         self.assertEqual('nodtb with microcode' + pos_and_size +
                          ' somewhere in here', first)
@@ -910,7 +910,7 @@ class TestFunctional(unittest.TestCase):
         # We need the libfdt library to run this test since only that allows
         # finding the offset of a property. This is required by
         # Entry_u_boot_dtb_with_ucode.ObtainContents().
-        data = self._DoReadFile('35_x86_single_ucode.dts', True)
+        data = self._DoReadFile('035_x86_single_ucode.dts', True)
 
         second = data[len(U_BOOT_NODTB_DATA):]
 
@@ -937,27 +937,27 @@ class TestFunctional(unittest.TestCase):
 
     def testUBootImg(self):
         """Test that u-boot.img can be put in a file"""
-        data = self._DoReadFile('36_u_boot_img.dts')
+        data = self._DoReadFile('036_u_boot_img.dts')
         self.assertEqual(U_BOOT_IMG_DATA, data)
 
     def testNoMicrocode(self):
         """Test that a missing microcode region is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('37_x86_no_ucode.dts', True)
+            self._DoReadFile('037_x86_no_ucode.dts', True)
         self.assertIn("Node '/binman/u-boot-dtb-with-ucode': No /microcode "
                       "node found in ", str(e.exception))
 
     def testMicrocodeWithoutNode(self):
         """Test that a missing u-boot-dtb-with-ucode node is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('38_x86_ucode_missing_node.dts', True)
+            self._DoReadFile('038_x86_ucode_missing_node.dts', True)
         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
                 "microcode region u-boot-dtb-with-ucode", str(e.exception))
 
     def testMicrocodeWithoutNode2(self):
         """Test that a missing u-boot-ucode node is detected"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('39_x86_ucode_missing_node2.dts', True)
+            self._DoReadFile('039_x86_ucode_missing_node2.dts', True)
         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Cannot find "
             "microcode region u-boot-ucode", str(e.exception))
 
@@ -981,7 +981,7 @@ class TestFunctional(unittest.TestCase):
     def testMicrocodeNotInImage(self):
         """Test that microcode must be placed within the image"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('40_x86_ucode_not_in_image.dts', True)
+            self._DoReadFile('040_x86_ucode_not_in_image.dts', True)
         self.assertIn("Node '/binman/u-boot-with-ucode-ptr': Microcode "
                 "pointer _dt_ucode_base_size at fffffe14 is outside the "
                 "section ranging from 00000000 to 0000002e", str(e.exception))
@@ -990,7 +990,7 @@ class TestFunctional(unittest.TestCase):
         """Test that we can cope with an image without microcode (e.g. qemu)"""
         with open(self.TestFile('u_boot_no_ucode_ptr')) as fd:
             TestFunctional._MakeInputFile('u-boot', fd.read())
-        data, dtb, _, _ = self._DoReadFileDtb('44_x86_optional_ucode.dts', True)
+        data, dtb, _, _ = self._DoReadFileDtb('044_x86_optional_ucode.dts', True)
 
         # Now check the device tree has no microcode
         self.assertEqual(U_BOOT_NODTB_DATA, data[:len(U_BOOT_NODTB_DATA)])
@@ -1006,43 +1006,43 @@ class TestFunctional(unittest.TestCase):
     def testUnknownPosSize(self):
         """Test that microcode must be placed within the image"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('41_unknown_pos_size.dts', True)
+            self._DoReadFile('041_unknown_pos_size.dts', True)
         self.assertIn("Section '/binman': Unable to set offset/size for unknown "
                 "entry 'invalid-entry'", str(e.exception))
 
     def testPackFsp(self):
         """Test that an image with a FSP binary can be created"""
-        data = self._DoReadFile('42_intel-fsp.dts')
+        data = self._DoReadFile('042_intel-fsp.dts')
         self.assertEqual(FSP_DATA, data[:len(FSP_DATA)])
 
     def testPackCmc(self):
         """Test that an image with a CMC binary can be created"""
-        data = self._DoReadFile('43_intel-cmc.dts')
+        data = self._DoReadFile('043_intel-cmc.dts')
         self.assertEqual(CMC_DATA, data[:len(CMC_DATA)])
 
     def testPackVbt(self):
         """Test that an image with a VBT binary can be created"""
-        data = self._DoReadFile('46_intel-vbt.dts')
+        data = self._DoReadFile('046_intel-vbt.dts')
         self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])
 
     def testSplBssPad(self):
         """Test that we can pad SPL's BSS with zeros"""
         # ELF file with a '__bss_size' symbol
         self._SetupSplElf()
-        data = self._DoReadFile('47_spl_bss_pad.dts')
+        data = self._DoReadFile('047_spl_bss_pad.dts')
         self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)
 
     def testSplBssPadMissing(self):
         """Test that a missing symbol is detected"""
         self._SetupSplElf('u_boot_ucode_ptr')
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('47_spl_bss_pad.dts')
+            self._DoReadFile('047_spl_bss_pad.dts')
         self.assertIn('Expected __bss_size symbol in spl/u-boot-spl',
                       str(e.exception))
 
     def testPackStart16Spl(self):
         """Test that an image with an x86 start16 SPL region can be created"""
-        data = self._DoReadFile('48_x86-start16-spl.dts')
+        data = self._DoReadFile('048_x86-start16-spl.dts')
         self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])
 
     def _PackUbootSplMicrocode(self, dts, ucode_second=False):
@@ -1067,7 +1067,7 @@ class TestFunctional(unittest.TestCase):
 
     def testPackUbootSplMicrocode(self):
         """Test that x86 microcode can be handled correctly in SPL"""
-        self._PackUbootSplMicrocode('49_x86_ucode_spl.dts')
+        self._PackUbootSplMicrocode('049_x86_ucode_spl.dts')
 
     def testPackUbootSplMicrocodeReorder(self):
         """Test that order doesn't matter for microcode entries
@@ -1076,22 +1076,22 @@ class TestFunctional(unittest.TestCase):
         u-boot-ucode entry we have not yet seen the u-boot-dtb-with-ucode
         entry, so we reply on binman to try later.
         """
-        self._PackUbootSplMicrocode('58_x86_ucode_spl_needs_retry.dts',
+        self._PackUbootSplMicrocode('058_x86_ucode_spl_needs_retry.dts',
                                     ucode_second=True)
 
     def testPackMrc(self):
         """Test that an image with an MRC binary can be created"""
-        data = self._DoReadFile('50_intel_mrc.dts')
+        data = self._DoReadFile('050_intel_mrc.dts')
         self.assertEqual(MRC_DATA, data[:len(MRC_DATA)])
 
     def testSplDtb(self):
         """Test that an image with spl/u-boot-spl.dtb can be created"""
-        data = self._DoReadFile('51_u_boot_spl_dtb.dts')
+        data = self._DoReadFile('051_u_boot_spl_dtb.dts')
         self.assertEqual(U_BOOT_SPL_DTB_DATA, data[:len(U_BOOT_SPL_DTB_DATA)])
 
     def testSplNoDtb(self):
         """Test that an image with spl/u-boot-spl-nodtb.bin can be created"""
-        data = self._DoReadFile('52_u_boot_spl_nodtb.dts')
+        data = self._DoReadFile('052_u_boot_spl_nodtb.dts')
         self.assertEqual(U_BOOT_SPL_NODTB_DATA, data[:len(U_BOOT_SPL_NODTB_DATA)])
 
     def testSymbols(self):
@@ -1102,7 +1102,7 @@ class TestFunctional(unittest.TestCase):
         self.assertEqual(syms['_binman_u_boot_spl_prop_offset'].address, addr)
 
         self._SetupSplElf('u_boot_binman_syms')
-        data = self._DoReadFile('53_symbols.dts')
+        data = self._DoReadFile('053_symbols.dts')
         sym_values = struct.pack('<LQL', 0x24 + 0, 0x24 + 24, 0x24 + 20)
         expected = (sym_values + U_BOOT_SPL_DATA[16:] + chr(0xff) +
                     U_BOOT_DATA +
@@ -1111,19 +1111,19 @@ class TestFunctional(unittest.TestCase):
 
     def testPackUnitAddress(self):
         """Test that we support multiple binaries with the same name"""
-        data = self._DoReadFile('54_unit_address.dts')
+        data = self._DoReadFile('054_unit_address.dts')
         self.assertEqual(U_BOOT_DATA + U_BOOT_DATA, data)
 
     def testSections(self):
         """Basic test of sections"""
-        data = self._DoReadFile('55_sections.dts')
+        data = self._DoReadFile('055_sections.dts')
         expected = (U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 +
                     U_BOOT_DATA + '&' * 4)
         self.assertEqual(expected, data)
 
     def testMap(self):
         """Tests outputting a map of the images"""
-        _, _, map_data, _ = self._DoReadFileDtb('55_sections.dts', map=True)
+        _, _, map_data, _ = self._DoReadFileDtb('055_sections.dts', map=True)
         self.assertEqual('''ImagePos    Offset      Size  Name
 00000000  00000000  00000028  main-section
 00000000   00000000  00000010  section@0
@@ -1136,7 +1136,7 @@ class TestFunctional(unittest.TestCase):
 
     def testNamePrefix(self):
         """Tests that name prefixes are used"""
-        _, _, map_data, _ = self._DoReadFileDtb('56_name_prefix.dts', map=True)
+        _, _, map_data, _ = self._DoReadFileDtb('056_name_prefix.dts', map=True)
         self.assertEqual('''ImagePos    Offset      Size  Name
 00000000  00000000  00000028  main-section
 00000000   00000000  00000010  section@0
@@ -1148,7 +1148,7 @@ class TestFunctional(unittest.TestCase):
     def testUnknownContents(self):
         """Test that obtaining the contents works as expected"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('57_unknown_contents.dts', True)
+            self._DoReadFile('057_unknown_contents.dts', True)
         self.assertIn("Section '/binman': Internal error: Could not complete "
                 "processing of contents: remaining [<_testing.Entry__testing ",
                 str(e.exception))
@@ -1156,13 +1156,13 @@ class TestFunctional(unittest.TestCase):
     def testBadChangeSize(self):
         """Test that trying to change the size of an entry fails"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('59_change_size.dts', True)
+            self._DoReadFile('059_change_size.dts', True)
         self.assertIn("Node '/binman/_testing': Cannot update entry size from "
                       '2 to 1', str(e.exception))
 
     def testUpdateFdt(self):
         """Test that we can update the device tree with offset/size info"""
-        _, _, _, out_dtb_fname = self._DoReadFileDtb('60_fdt_update.dts',
+        _, _, _, out_dtb_fname = self._DoReadFileDtb('060_fdt_update.dts',
                                                      update_dtb=True)
         dtb = fdt.Fdt(out_dtb_fname)
         dtb.Scan()
@@ -1192,7 +1192,7 @@ class TestFunctional(unittest.TestCase):
     def testUpdateFdtBad(self):
         """Test that we detect when ProcessFdt never completes"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('61_fdt_update_bad.dts', update_dtb=True)
+            self._DoReadFileDtb('061_fdt_update_bad.dts', update_dtb=True)
         self.assertIn('Could not complete processing of Fdt: remaining '
                       '[<_testing.Entry__testing', str(e.exception))
 
@@ -1202,7 +1202,7 @@ class TestFunctional(unittest.TestCase):
             'test-str-arg': 'test1',
             'test-int-arg': '456',
         }
-        self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
+        self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args)
         self.assertIn('image', control.images)
         entry = control.images['image'].GetEntries()['_testing']
         self.assertEqual('test0', entry.test_str_fdt)
@@ -1215,7 +1215,7 @@ class TestFunctional(unittest.TestCase):
         entry_args = {
             'test-int-arg': '456',
         }
-        self._DoReadFileDtb('63_entry_args_missing.dts', entry_args=entry_args)
+        self._DoReadFileDtb('063_entry_args_missing.dts', entry_args=entry_args)
         entry = control.images['image'].GetEntries()['_testing']
         self.assertEqual('test0', entry.test_str_fdt)
         self.assertEqual(None, entry.test_str_arg)
@@ -1228,14 +1228,14 @@ class TestFunctional(unittest.TestCase):
             'test-int-arg': '456',
         }
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('64_entry_args_required.dts')
+            self._DoReadFileDtb('064_entry_args_required.dts')
         self.assertIn("Node '/binman/_testing': Missing required "
             'properties/entry args: test-str-arg, test-int-fdt, test-int-arg',
             str(e.exception))
 
     def testEntryArgsInvalidFormat(self):
         """Test that an invalid entry-argument format is detected"""
-        args = ['-d', self.TestFile('64_entry_args_required.dts'), '-ano-value']
+        args = ['-d', self.TestFile('064_entry_args_required.dts'), '-ano-value']
         with self.assertRaises(ValueError) as e:
             self._DoBinman(*args)
         self.assertIn("Invalid entry arguemnt 'no-value'", str(e.exception))
@@ -1246,7 +1246,7 @@ class TestFunctional(unittest.TestCase):
             'test-int-arg': 'abc',
         }
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('62_entry_args.dts', entry_args=entry_args)
+            self._DoReadFileDtb('062_entry_args.dts', entry_args=entry_args)
         self.assertIn("Node '/binman/_testing': Cannot convert entry arg "
                       "'test-int-arg' (value 'abc') to integer",
             str(e.exception))
@@ -1262,7 +1262,7 @@ class TestFunctional(unittest.TestCase):
             'test-bad-datatype-arg': '12',
         }
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('65_entry_args_unknown_datatype.dts',
+            self._DoReadFileDtb('065_entry_args_unknown_datatype.dts',
                                 entry_args=entry_args)
         self.assertIn('GetArg() internal error: Unknown data type ',
                       str(e.exception))
@@ -1274,7 +1274,7 @@ class TestFunctional(unittest.TestCase):
             'test-id2': TEXT_DATA2,
             'test-id3': TEXT_DATA3,
         }
-        data, _, _, _ = self._DoReadFileDtb('66_text.dts',
+        data, _, _, _ = self._DoReadFileDtb('066_text.dts',
                                             entry_args=entry_args)
         expected = (TEXT_DATA + chr(0) * (8 - len(TEXT_DATA)) + TEXT_DATA2 +
                     TEXT_DATA3 + 'some text')
@@ -1296,7 +1296,7 @@ class TestFunctional(unittest.TestCase):
 
     def testFmap(self):
         """Basic test of generation of a flashrom fmap"""
-        data = self._DoReadFile('67_fmap.dts')
+        data = self._DoReadFile('067_fmap.dts')
         fhdr, fentries = fmap_util.DecodeFmap(data[32:])
         expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12
         self.assertEqual(expected, data[:32])
@@ -1330,19 +1330,19 @@ class TestFunctional(unittest.TestCase):
         entry_args = {
             'cros-ec-rw-path': 'ecrw.bin',
         }
-        data, _, _, _ = self._DoReadFileDtb('68_blob_named_by_arg.dts',
+        data, _, _, _ = self._DoReadFileDtb('068_blob_named_by_arg.dts',
                                             entry_args=entry_args)
 
     def testFill(self):
         """Test for an fill entry type"""
-        data = self._DoReadFile('69_fill.dts')
+        data = self._DoReadFile('069_fill.dts')
         expected = 8 * chr(0xff) + 8 * chr(0)
         self.assertEqual(expected, data)
 
     def testFillNoSize(self):
         """Test for an fill entry type with no size"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('70_fill_no_size.dts')
+            self._DoReadFile('070_fill_no_size.dts')
         self.assertIn("'fill' entry must have a size property",
                       str(e.exception))
 
@@ -1363,7 +1363,7 @@ class TestFunctional(unittest.TestCase):
             'keydir': 'devkeys',
             'bmpblk': 'bmpblk.bin',
         }
-        data, _, _, _ = self._DoReadFileDtb('71_gbb.dts', entry_args=entry_args)
+        data, _, _, _ = self._DoReadFileDtb('071_gbb.dts', entry_args=entry_args)
 
         # Since futility
         expected = GBB_DATA + GBB_DATA + 8 * chr(0) + (0x2180 - 16) * chr(0)
@@ -1372,14 +1372,14 @@ class TestFunctional(unittest.TestCase):
     def testGbbTooSmall(self):
         """Test for the Chromium OS Google Binary Block being large enough"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('72_gbb_too_small.dts')
+            self._DoReadFileDtb('072_gbb_too_small.dts')
         self.assertIn("Node '/binman/gbb': GBB is too small",
                       str(e.exception))
 
     def testGbbNoSize(self):
         """Test for the Chromium OS Google Binary Block having a size"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('73_gbb_no_size.dts')
+            self._DoReadFileDtb('073_gbb_no_size.dts')
         self.assertIn("Node '/binman/gbb': GBB must have a fixed size",
                       str(e.exception))
 
@@ -1397,7 +1397,7 @@ class TestFunctional(unittest.TestCase):
         entry_args = {
             'keydir': 'devkeys',
         }
-        data, _, _, _ = self._DoReadFileDtb('74_vblock.dts',
+        data, _, _, _ = self._DoReadFileDtb('074_vblock.dts',
                                             entry_args=entry_args)
         expected = U_BOOT_DATA + VBLOCK_DATA + U_BOOT_DTB_DATA
         self.assertEqual(expected, data)
@@ -1405,21 +1405,21 @@ class TestFunctional(unittest.TestCase):
     def testVblockNoContent(self):
         """Test we detect a vblock which has no content to sign"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('75_vblock_no_content.dts')
+            self._DoReadFile('075_vblock_no_content.dts')
         self.assertIn("Node '/binman/vblock': Vblock must have a 'content' "
                       'property', str(e.exception))
 
     def testVblockBadPhandle(self):
         """Test that we detect a vblock with an invalid phandle in contents"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('76_vblock_bad_phandle.dts')
+            self._DoReadFile('076_vblock_bad_phandle.dts')
         self.assertIn("Node '/binman/vblock': Cannot find node for phandle "
                       '1000', str(e.exception))
 
     def testVblockBadEntry(self):
         """Test that we detect an entry that points to a non-entry"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFile('77_vblock_bad_entry.dts')
+            self._DoReadFile('077_vblock_bad_entry.dts')
         self.assertIn("Node '/binman/vblock': Cannot find entry for node "
                       "'other'", str(e.exception))
 
@@ -1428,37 +1428,37 @@ class TestFunctional(unittest.TestCase):
         # ELF file with a '__bss_size' symbol
         with open(self.TestFile('bss_data')) as fd:
             TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
-        data = self._DoReadFile('78_u_boot_tpl.dts')
+        data = self._DoReadFile('078_u_boot_tpl.dts')
         self.assertEqual(U_BOOT_TPL_DATA + U_BOOT_TPL_DTB_DATA, data)
 
     def testUsesPos(self):
         """Test that the 'pos' property cannot be used anymore"""
         with self.assertRaises(ValueError) as e:
-           data = self._DoReadFile('79_uses_pos.dts')
+           data = self._DoReadFile('079_uses_pos.dts')
         self.assertIn("Node '/binman/u-boot': Please use 'offset' instead of "
                       "'pos'", str(e.exception))
 
     def testFillZero(self):
         """Test for an fill entry type with a size of 0"""
-        data = self._DoReadFile('80_fill_empty.dts')
+        data = self._DoReadFile('080_fill_empty.dts')
         self.assertEqual(chr(0) * 16, data)
 
     def testTextMissing(self):
         """Test for a text entry type where there is no text"""
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('66_text.dts',)
+            self._DoReadFileDtb('066_text.dts',)
         self.assertIn("Node '/binman/text': No value provided for text label "
                       "'test-id'", str(e.exception))
 
     def testPackStart16Tpl(self):
         """Test that an image with an x86 start16 TPL region can be created"""
-        data = self._DoReadFile('81_x86-start16-tpl.dts')
+        data = self._DoReadFile('081_x86-start16-tpl.dts')
         self.assertEqual(X86_START16_TPL_DATA, data[:len(X86_START16_TPL_DATA)])
 
     def testSelectImage(self):
         """Test that we can select which images to build"""
         with test_util.capture_sys_output() as (stdout, stderr):
-            retcode = self._DoTestFile('06_dual_image.dts', images=['image2'])
+            retcode = self._DoTestFile('006_dual_image.dts', images=['image2'])
         self.assertEqual(0, retcode)
         self.assertIn('Skipping images: image1', stdout.getvalue())
 
@@ -1467,7 +1467,7 @@ class TestFunctional(unittest.TestCase):
 
     def testUpdateFdtAll(self):
         """Test that all device trees are updated with offset/size info"""
-        data, _, _, _ = self._DoReadFileDtb('82_fdt_update_all.dts',
+        data, _, _, _ = self._DoReadFileDtb('082_fdt_update_all.dts',
                                             use_real_dtb=True, update_dtb=True)
 
         base_expected = {
@@ -1507,12 +1507,12 @@ class TestFunctional(unittest.TestCase):
     def testUpdateFdtOutput(self):
         """Test that output DTB files are updated"""
         try:
-            data, dtb_data, _, _ = self._DoReadFileDtb('82_fdt_update_all.dts',
+            data, dtb_data, _, _ = self._DoReadFileDtb('082_fdt_update_all.dts',
                     use_real_dtb=True, update_dtb=True, reset_dtbs=False)
 
             # Unfortunately, compiling a source file always results in a file
             # called source.dtb (see fdt_util.EnsureCompiled()). The test
-            # source file (e.g. test/75_fdt_update_all.dts) thus does not enter
+            # source file (e.g. test/075_fdt_update_all.dts) thus does not enter
             # binman as a file called u-boot.dtb. To fix this, copy the file
             # over to the expected place.
             #tools.WriteFile(os.path.join(self._indir, 'u-boot.dtb'),
@@ -1553,7 +1553,7 @@ class TestFunctional(unittest.TestCase):
 
     def testCompress(self):
         """Test compression of blobs"""
-        data, _, _, out_dtb_fname = self._DoReadFileDtb('83_compress.dts',
+        data, _, _, out_dtb_fname = self._DoReadFileDtb('083_compress.dts',
                                             use_real_dtb=True, update_dtb=True)
         dtb = fdt.Fdt(out_dtb_fname)
         dtb.Scan()
@@ -1569,12 +1569,12 @@ class TestFunctional(unittest.TestCase):
 
     def testFiles(self):
         """Test bringing in multiple files"""
-        data = self._DoReadFile('84_files.dts')
+        data = self._DoReadFile('084_files.dts')
         self.assertEqual(FILES_DATA, data)
 
     def testFilesCompress(self):
         """Test bringing in multiple files and compressing them"""
-        data = self._DoReadFile('85_files_compress.dts')
+        data = self._DoReadFile('085_files_compress.dts')
 
         image = control.images['image']
         entries = image.GetEntries()
@@ -1594,20 +1594,20 @@ class TestFunctional(unittest.TestCase):
     def testFilesMissing(self):
         """Test missing files"""
         with self.assertRaises(ValueError) as e:
-            data = self._DoReadFile('86_files_none.dts')
+            data = self._DoReadFile('086_files_none.dts')
         self.assertIn("Node '/binman/files': Pattern \'files/*.none\' matched "
                       'no files', str(e.exception))
 
     def testFilesNoPattern(self):
         """Test missing files"""
         with self.assertRaises(ValueError) as e:
-            data = self._DoReadFile('87_files_no_pattern.dts')
+            data = self._DoReadFile('087_files_no_pattern.dts')
         self.assertIn("Node '/binman/files': Missing 'pattern' property",
                       str(e.exception))
 
     def testExpandSize(self):
         """Test an expanding entry"""
-        data, _, map_data, _ = self._DoReadFileDtb('88_expand_size.dts',
+        data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts',
                                                    map=True)
         expect = ('a' * 8 + U_BOOT_DATA +
                   MRC_DATA + 'b' * 1 + U_BOOT_DATA +
@@ -1631,13 +1631,13 @@ class TestFunctional(unittest.TestCase):
         """Test an expanding entry which fails to provide contents"""
         with test_util.capture_sys_output() as (stdout, stderr):
             with self.assertRaises(ValueError) as e:
-                self._DoReadFileDtb('89_expand_size_bad.dts', map=True)
+                self._DoReadFileDtb('089_expand_size_bad.dts', map=True)
         self.assertIn("Node '/binman/_testing': Cannot obtain contents when "
                       'expanding entry', str(e.exception))
 
     def testHash(self):
         """Test hashing of the contents of an entry"""
-        _, _, _, out_dtb_fname = self._DoReadFileDtb('90_hash.dts',
+        _, _, _, out_dtb_fname = self._DoReadFileDtb('090_hash.dts',
                 use_real_dtb=True, update_dtb=True)
         dtb = fdt.Fdt(out_dtb_fname)
         dtb.Scan()
@@ -1648,19 +1648,19 @@ class TestFunctional(unittest.TestCase):
 
     def testHashNoAlgo(self):
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('91_hash_no_algo.dts', update_dtb=True)
+            self._DoReadFileDtb('091_hash_no_algo.dts', update_dtb=True)
         self.assertIn("Node \'/binman/u-boot\': Missing \'algo\' property for "
                       'hash node', str(e.exception))
 
     def testHashBadAlgo(self):
         with self.assertRaises(ValueError) as e:
-            self._DoReadFileDtb('92_hash_bad_algo.dts', update_dtb=True)
+            self._DoReadFileDtb('092_hash_bad_algo.dts', update_dtb=True)
         self.assertIn("Node '/binman/u-boot': Unknown hash algorithm",
                       str(e.exception))
 
     def testHashSection(self):
         """Test hashing of the contents of an entry"""
-        _, _, _, out_dtb_fname = self._DoReadFileDtb('99_hash_section.dts',
+        _, _, _, out_dtb_fname = self._DoReadFileDtb('099_hash_section.dts',
                 use_real_dtb=True, update_dtb=True)
         dtb = fdt.Fdt(out_dtb_fname)
         dtb.Scan()
@@ -1681,14 +1681,14 @@ class TestFunctional(unittest.TestCase):
         """
         with open(self.TestFile('u_boot_ucode_ptr')) as fd:
             TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
-        first, pos_and_size = self._RunMicrocodeTest('93_x86_tpl_ucode.dts',
+        first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts',
                                                      U_BOOT_TPL_NODTB_DATA)
         self.assertEqual('tplnodtb with microc' + pos_and_size +
                          'ter somewhere in here', first)
 
     def testFmapX86(self):
         """Basic test of generation of a flashrom fmap"""
-        data = self._DoReadFile('94_fmap_x86.dts')
+        data = self._DoReadFile('094_fmap_x86.dts')
         fhdr, fentries = fmap_util.DecodeFmap(data[32:])
         expected = U_BOOT_DATA + MRC_DATA + 'a' * (32 - 7)
         self.assertEqual(expected, data[:32])
@@ -1711,7 +1711,7 @@ class TestFunctional(unittest.TestCase):
 
     def testFmapX86Section(self):
         """Basic test of generation of a flashrom fmap"""
-        data = self._DoReadFile('95_fmap_x86_section.dts')
+        data = self._DoReadFile('095_fmap_x86_section.dts')
         expected = U_BOOT_DATA + MRC_DATA + 'b' * (32 - 7)
         self.assertEqual(expected, data[:32])
         fhdr, fentries = fmap_util.DecodeFmap(data[36:])
@@ -1736,20 +1736,20 @@ class TestFunctional(unittest.TestCase):
         self._SetupSplElf()
         with open(self.TestFile('bss_data')) as fd:
             TestFunctional._MakeInputFile('-boot', fd.read())
-        data = self._DoReadFile('96_elf.dts')
+        data = self._DoReadFile('096_elf.dts')
 
     def testElfStripg(self):
         """Basic test of ELF entries"""
         self._SetupSplElf()
         with open(self.TestFile('bss_data')) as fd:
             TestFunctional._MakeInputFile('-boot', fd.read())
-        data = self._DoReadFile('97_elf_strip.dts')
+        data = self._DoReadFile('097_elf_strip.dts')
 
     def testPackOverlapMap(self):
         """Test that overlapping regions are detected"""
         with test_util.capture_sys_output() as (stdout, stderr):
             with self.assertRaises(ValueError) as e:
-                self._DoTestFile('14_pack_overlap.dts', map=True)
+                self._DoTestFile('014_pack_overlap.dts', map=True)
         map_fname = tools.GetOutputFilename('image.map')
         self.assertEqual("Wrote map file '%s' to show errors\n" % map_fname,
                          stdout.getvalue())
diff --git a/tools/binman/test/01_invalid.dts b/tools/binman/test/001_invalid.dts
index 7d00455d7c..7d00455d7c 100644
--- a/tools/binman/test/01_invalid.dts
+++ b/tools/binman/test/001_invalid.dts
diff --git a/tools/binman/test/02_missing_node.dts b/tools/binman/test/002_missing_node.dts
index 3a51ec2be5..3a51ec2be5 100644
--- a/tools/binman/test/02_missing_node.dts
+++ b/tools/binman/test/002_missing_node.dts
diff --git a/tools/binman/test/03_empty.dts b/tools/binman/test/003_empty.dts
index 493c9a04c9..493c9a04c9 100644
--- a/tools/binman/test/03_empty.dts
+++ b/tools/binman/test/003_empty.dts
diff --git a/tools/binman/test/04_invalid_entry.dts b/tools/binman/test/004_invalid_entry.dts
index b043455bb5..b043455bb5 100644
--- a/tools/binman/test/04_invalid_entry.dts
+++ b/tools/binman/test/004_invalid_entry.dts
diff --git a/tools/binman/test/05_simple.dts b/tools/binman/test/005_simple.dts
index 3771aa2261..3771aa2261 100644
--- a/tools/binman/test/05_simple.dts
+++ b/tools/binman/test/005_simple.dts
diff --git a/tools/binman/test/06_dual_image.dts b/tools/binman/test/006_dual_image.dts
index 78be16f164..78be16f164 100644
--- a/tools/binman/test/06_dual_image.dts
+++ b/tools/binman/test/006_dual_image.dts
diff --git a/tools/binman/test/07_bad_align.dts b/tools/binman/test/007_bad_align.dts
index 123bb13558..123bb13558 100644
--- a/tools/binman/test/07_bad_align.dts
+++ b/tools/binman/test/007_bad_align.dts
diff --git a/tools/binman/test/08_pack.dts b/tools/binman/test/008_pack.dts
index a88785d835..a88785d835 100644
--- a/tools/binman/test/08_pack.dts
+++ b/tools/binman/test/008_pack.dts
diff --git a/tools/binman/test/09_pack_extra.dts b/tools/binman/test/009_pack_extra.dts
index 0765707dea..0765707dea 100644
--- a/tools/binman/test/09_pack_extra.dts
+++ b/tools/binman/test/009_pack_extra.dts
diff --git a/tools/binman/test/10_pack_align_power2.dts b/tools/binman/test/010_pack_align_power2.dts
index 8f6253a3d0..8f6253a3d0 100644
--- a/tools/binman/test/10_pack_align_power2.dts
+++ b/tools/binman/test/010_pack_align_power2.dts
diff --git a/tools/binman/test/11_pack_align_size_power2.dts b/tools/binman/test/011_pack_align_size_power2.dts
index 04f7672ea4..04f7672ea4 100644
--- a/tools/binman/test/11_pack_align_size_power2.dts
+++ b/tools/binman/test/011_pack_align_size_power2.dts
diff --git a/tools/binman/test/12_pack_inv_align.dts b/tools/binman/test/012_pack_inv_align.dts
index d8dd600edb..d8dd600edb 100644
--- a/tools/binman/test/12_pack_inv_align.dts
+++ b/tools/binman/test/012_pack_inv_align.dts
diff --git a/tools/binman/test/13_pack_inv_size_align.dts b/tools/binman/test/013_pack_inv_size_align.dts
index dfafa134d7..dfafa134d7 100644
--- a/tools/binman/test/13_pack_inv_size_align.dts
+++ b/tools/binman/test/013_pack_inv_size_align.dts
diff --git a/tools/binman/test/14_pack_overlap.dts b/tools/binman/test/014_pack_overlap.dts
index 3895cba3bd..3895cba3bd 100644
--- a/tools/binman/test/14_pack_overlap.dts
+++ b/tools/binman/test/014_pack_overlap.dts
diff --git a/tools/binman/test/15_pack_overflow.dts b/tools/binman/test/015_pack_overflow.dts
index 6f654330af..6f654330af 100644
--- a/tools/binman/test/15_pack_overflow.dts
+++ b/tools/binman/test/015_pack_overflow.dts
diff --git a/tools/binman/test/16_pack_image_overflow.dts b/tools/binman/test/016_pack_image_overflow.dts
index 6ae66f3ac9..6ae66f3ac9 100644
--- a/tools/binman/test/16_pack_image_overflow.dts
+++ b/tools/binman/test/016_pack_image_overflow.dts
diff --git a/tools/binman/test/17_pack_image_size.dts b/tools/binman/test/017_pack_image_size.dts
index 2360eb5d19..2360eb5d19 100644
--- a/tools/binman/test/17_pack_image_size.dts
+++ b/tools/binman/test/017_pack_image_size.dts
diff --git a/tools/binman/test/18_pack_image_align.dts b/tools/binman/test/018_pack_image_align.dts
index 16cd2a422e..16cd2a422e 100644
--- a/tools/binman/test/18_pack_image_align.dts
+++ b/tools/binman/test/018_pack_image_align.dts
diff --git a/tools/binman/test/19_pack_inv_image_align.dts b/tools/binman/test/019_pack_inv_image_align.dts
index e5ee87b88f..e5ee87b88f 100644
--- a/tools/binman/test/19_pack_inv_image_align.dts
+++ b/tools/binman/test/019_pack_inv_image_align.dts
diff --git a/tools/binman/test/20_pack_inv_image_align_power2.dts b/tools/binman/test/020_pack_inv_image_align_power2.dts
index a428c4be52..a428c4be52 100644
--- a/tools/binman/test/20_pack_inv_image_align_power2.dts
+++ b/tools/binman/test/020_pack_inv_image_align_power2.dts
diff --git a/tools/binman/test/21_image_pad.dts b/tools/binman/test/021_image_pad.dts
index c6516689d9..c6516689d9 100644
--- a/tools/binman/test/21_image_pad.dts
+++ b/tools/binman/test/021_image_pad.dts
diff --git a/tools/binman/test/22_image_name.dts b/tools/binman/test/022_image_name.dts
index 94fc069c17..94fc069c17 100644
--- a/tools/binman/test/22_image_name.dts
+++ b/tools/binman/test/022_image_name.dts
diff --git a/tools/binman/test/23_blob.dts b/tools/binman/test/023_blob.dts
index 7dcff69666..7dcff69666 100644
--- a/tools/binman/test/23_blob.dts
+++ b/tools/binman/test/023_blob.dts
diff --git a/tools/binman/test/24_sorted.dts b/tools/binman/test/024_sorted.dts
index d35d39f077..d35d39f077 100644
--- a/tools/binman/test/24_sorted.dts
+++ b/tools/binman/test/024_sorted.dts
diff --git a/tools/binman/test/25_pack_zero_size.dts b/tools/binman/test/025_pack_zero_size.dts
index e863c44e3f..e863c44e3f 100644
--- a/tools/binman/test/25_pack_zero_size.dts
+++ b/tools/binman/test/025_pack_zero_size.dts
diff --git a/tools/binman/test/26_pack_u_boot_dtb.dts b/tools/binman/test/026_pack_u_boot_dtb.dts
index 2707a7347a..2707a7347a 100644
--- a/tools/binman/test/26_pack_u_boot_dtb.dts
+++ b/tools/binman/test/026_pack_u_boot_dtb.dts
diff --git a/tools/binman/test/27_pack_4gb_no_size.dts b/tools/binman/test/027_pack_4gb_no_size.dts
index 371cca10d5..371cca10d5 100644
--- a/tools/binman/test/27_pack_4gb_no_size.dts
+++ b/tools/binman/test/027_pack_4gb_no_size.dts
diff --git a/tools/binman/test/28_pack_4gb_outside.dts b/tools/binman/test/028_pack_4gb_outside.dts
index 2216abfb70..2216abfb70 100644
--- a/tools/binman/test/28_pack_4gb_outside.dts
+++ b/tools/binman/test/028_pack_4gb_outside.dts
diff --git a/tools/binman/test/29_x86-rom.dts b/tools/binman/test/029_x86-rom.dts
index d5c69f9d4a..d5c69f9d4a 100644
--- a/tools/binman/test/29_x86-rom.dts
+++ b/tools/binman/test/029_x86-rom.dts
diff --git a/tools/binman/test/30_x86-rom-me-no-desc.dts b/tools/binman/test/030_x86-rom-me-no-desc.dts
index 796cb87afc..796cb87afc 100644
--- a/tools/binman/test/30_x86-rom-me-no-desc.dts
+++ b/tools/binman/test/030_x86-rom-me-no-desc.dts
diff --git a/tools/binman/test/31_x86-rom-me.dts b/tools/binman/test/031_x86-rom-me.dts
index b8b0a5a74b..b8b0a5a74b 100644
--- a/tools/binman/test/31_x86-rom-me.dts
+++ b/tools/binman/test/031_x86-rom-me.dts
diff --git a/tools/binman/test/32_intel-vga.dts b/tools/binman/test/032_intel-vga.dts
index 9c532d03d3..9c532d03d3 100644
--- a/tools/binman/test/32_intel-vga.dts
+++ b/tools/binman/test/032_intel-vga.dts
diff --git a/tools/binman/test/33_x86-start16.dts b/tools/binman/test/033_x86-start16.dts
index 2e279dee9d..2e279dee9d 100644
--- a/tools/binman/test/33_x86-start16.dts
+++ b/tools/binman/test/033_x86-start16.dts
diff --git a/tools/binman/test/34_x86_ucode.dts b/tools/binman/test/034_x86_ucode.dts
index 40725731cd..40725731cd 100644
--- a/tools/binman/test/34_x86_ucode.dts
+++ b/tools/binman/test/034_x86_ucode.dts
diff --git a/tools/binman/test/35_x86_single_ucode.dts b/tools/binman/test/035_x86_single_ucode.dts
index 2b1f086a41..2b1f086a41 100644
--- a/tools/binman/test/35_x86_single_ucode.dts
+++ b/tools/binman/test/035_x86_single_ucode.dts
diff --git a/tools/binman/test/36_u_boot_img.dts b/tools/binman/test/036_u_boot_img.dts
index aa5a3fe481..aa5a3fe481 100644
--- a/tools/binman/test/36_u_boot_img.dts
+++ b/tools/binman/test/036_u_boot_img.dts
diff --git a/tools/binman/test/37_x86_no_ucode.dts b/tools/binman/test/037_x86_no_ucode.dts
index 6da49c3da6..6da49c3da6 100644
--- a/tools/binman/test/37_x86_no_ucode.dts
+++ b/tools/binman/test/037_x86_no_ucode.dts
diff --git a/tools/binman/test/38_x86_ucode_missing_node.dts b/tools/binman/test/038_x86_ucode_missing_node.dts
index 720677c9c1..720677c9c1 100644
--- a/tools/binman/test/38_x86_ucode_missing_node.dts
+++ b/tools/binman/test/038_x86_ucode_missing_node.dts
diff --git a/tools/binman/test/39_x86_ucode_missing_node2.dts b/tools/binman/test/039_x86_ucode_missing_node2.dts
index 10ac086d54..10ac086d54 100644
--- a/tools/binman/test/39_x86_ucode_missing_node2.dts
+++ b/tools/binman/test/039_x86_ucode_missing_node2.dts
diff --git a/tools/binman/test/40_x86_ucode_not_in_image.dts b/tools/binman/test/040_x86_ucode_not_in_image.dts
index 609725824a..609725824a 100644
--- a/tools/binman/test/40_x86_ucode_not_in_image.dts
+++ b/tools/binman/test/040_x86_ucode_not_in_image.dts
diff --git a/tools/binman/test/41_unknown_pos_size.dts b/tools/binman/test/041_unknown_pos_size.dts
index 94fe821c47..94fe821c47 100644
--- a/tools/binman/test/41_unknown_pos_size.dts
+++ b/tools/binman/test/041_unknown_pos_size.dts
diff --git a/tools/binman/test/42_intel-fsp.dts b/tools/binman/test/042_intel-fsp.dts
index 8a7c889251..8a7c889251 100644
--- a/tools/binman/test/42_intel-fsp.dts
+++ b/tools/binman/test/042_intel-fsp.dts
diff --git a/tools/binman/test/43_intel-cmc.dts b/tools/binman/test/043_intel-cmc.dts
index 5a56c7d881..5a56c7d881 100644
--- a/tools/binman/test/43_intel-cmc.dts
+++ b/tools/binman/test/043_intel-cmc.dts
diff --git a/tools/binman/test/44_x86_optional_ucode.dts b/tools/binman/test/044_x86_optional_ucode.dts
index 24a7040d31..24a7040d31 100644
--- a/tools/binman/test/44_x86_optional_ucode.dts
+++ b/tools/binman/test/044_x86_optional_ucode.dts
diff --git a/tools/binman/test/45_prop_test.dts b/tools/binman/test/045_prop_test.dts
index 064de2b316..064de2b316 100644
--- a/tools/binman/test/45_prop_test.dts
+++ b/tools/binman/test/045_prop_test.dts
diff --git a/tools/binman/test/46_intel-vbt.dts b/tools/binman/test/046_intel-vbt.dts
index 733f5751d5..733f5751d5 100644
--- a/tools/binman/test/46_intel-vbt.dts
+++ b/tools/binman/test/046_intel-vbt.dts
diff --git a/tools/binman/test/47_spl_bss_pad.dts b/tools/binman/test/047_spl_bss_pad.dts
index 6bd88b83f9..6bd88b83f9 100644
--- a/tools/binman/test/47_spl_bss_pad.dts
+++ b/tools/binman/test/047_spl_bss_pad.dts
diff --git a/tools/binman/test/48_x86-start16-spl.dts b/tools/binman/test/048_x86-start16-spl.dts
index e2009f15f0..e2009f15f0 100644
--- a/tools/binman/test/48_x86-start16-spl.dts
+++ b/tools/binman/test/048_x86-start16-spl.dts
diff --git a/tools/binman/test/49_x86_ucode_spl.dts b/tools/binman/test/049_x86_ucode_spl.dts
index 350d2c4730..350d2c4730 100644
--- a/tools/binman/test/49_x86_ucode_spl.dts
+++ b/tools/binman/test/049_x86_ucode_spl.dts
diff --git a/tools/binman/test/50_intel_mrc.dts b/tools/binman/test/050_intel_mrc.dts
index 54cd52a2b7..54cd52a2b7 100644
--- a/tools/binman/test/50_intel_mrc.dts
+++ b/tools/binman/test/050_intel_mrc.dts
diff --git a/tools/binman/test/51_u_boot_spl_dtb.dts b/tools/binman/test/051_u_boot_spl_dtb.dts
index 3912f86b4c..3912f86b4c 100644
--- a/tools/binman/test/51_u_boot_spl_dtb.dts
+++ b/tools/binman/test/051_u_boot_spl_dtb.dts
diff --git a/tools/binman/test/52_u_boot_spl_nodtb.dts b/tools/binman/test/052_u_boot_spl_nodtb.dts
index 7f4e27780f..7f4e27780f 100644
--- a/tools/binman/test/52_u_boot_spl_nodtb.dts
+++ b/tools/binman/test/052_u_boot_spl_nodtb.dts
diff --git a/tools/binman/test/53_symbols.dts b/tools/binman/test/053_symbols.dts
index 9f135676cb..9f135676cb 100644
--- a/tools/binman/test/53_symbols.dts
+++ b/tools/binman/test/053_symbols.dts
diff --git a/tools/binman/test/54_unit_address.dts b/tools/binman/test/054_unit_address.dts
index 3216dbbcc1..3216dbbcc1 100644
--- a/tools/binman/test/54_unit_address.dts
+++ b/tools/binman/test/054_unit_address.dts
diff --git a/tools/binman/test/55_sections.dts b/tools/binman/test/055_sections.dts
index 6b306aeda4..6b306aeda4 100644
--- a/tools/binman/test/55_sections.dts
+++ b/tools/binman/test/055_sections.dts
diff --git a/tools/binman/test/56_name_prefix.dts b/tools/binman/test/056_name_prefix.dts
index f38c80eb18..f38c80eb18 100644
--- a/tools/binman/test/56_name_prefix.dts
+++ b/tools/binman/test/056_name_prefix.dts
diff --git a/tools/binman/test/57_unknown_contents.dts b/tools/binman/test/057_unknown_contents.dts
index 6ea98d7cab..6ea98d7cab 100644
--- a/tools/binman/test/57_unknown_contents.dts
+++ b/tools/binman/test/057_unknown_contents.dts
diff --git a/tools/binman/test/58_x86_ucode_spl_needs_retry.dts b/tools/binman/test/058_x86_ucode_spl_needs_retry.dts
index a04adaaf7b..a04adaaf7b 100644
--- a/tools/binman/test/58_x86_ucode_spl_needs_retry.dts
+++ b/tools/binman/test/058_x86_ucode_spl_needs_retry.dts
diff --git a/tools/binman/test/59_change_size.dts b/tools/binman/test/059_change_size.dts
index 1a69026a64..1a69026a64 100644
--- a/tools/binman/test/59_change_size.dts
+++ b/tools/binman/test/059_change_size.dts
diff --git a/tools/binman/test/60_fdt_update.dts b/tools/binman/test/060_fdt_update.dts
index f53c8a5053..f53c8a5053 100644
--- a/tools/binman/test/60_fdt_update.dts
+++ b/tools/binman/test/060_fdt_update.dts
diff --git a/tools/binman/test/61_fdt_update_bad.dts b/tools/binman/test/061_fdt_update_bad.dts
index e5abf31699..e5abf31699 100644
--- a/tools/binman/test/61_fdt_update_bad.dts
+++ b/tools/binman/test/061_fdt_update_bad.dts
diff --git a/tools/binman/test/62_entry_args.dts b/tools/binman/test/062_entry_args.dts
index 4d4f102d60..4d4f102d60 100644
--- a/tools/binman/test/62_entry_args.dts
+++ b/tools/binman/test/062_entry_args.dts
diff --git a/tools/binman/test/63_entry_args_missing.dts b/tools/binman/test/063_entry_args_missing.dts
index 1644e2fef3..1644e2fef3 100644
--- a/tools/binman/test/63_entry_args_missing.dts
+++ b/tools/binman/test/063_entry_args_missing.dts
diff --git a/tools/binman/test/64_entry_args_required.dts b/tools/binman/test/064_entry_args_required.dts
index 705be10069..705be10069 100644
--- a/tools/binman/test/64_entry_args_required.dts
+++ b/tools/binman/test/064_entry_args_required.dts
diff --git a/tools/binman/test/65_entry_args_unknown_datatype.dts b/tools/binman/test/065_entry_args_unknown_datatype.dts
index 3e4838f4ff..3e4838f4ff 100644
--- a/tools/binman/test/65_entry_args_unknown_datatype.dts
+++ b/tools/binman/test/065_entry_args_unknown_datatype.dts
diff --git a/tools/binman/test/66_text.dts b/tools/binman/test/066_text.dts
index 59b1fed0ef..59b1fed0ef 100644
--- a/tools/binman/test/66_text.dts
+++ b/tools/binman/test/066_text.dts
diff --git a/tools/binman/test/67_fmap.dts b/tools/binman/test/067_fmap.dts
index 9c0e293ac8..9c0e293ac8 100644
--- a/tools/binman/test/67_fmap.dts
+++ b/tools/binman/test/067_fmap.dts
diff --git a/tools/binman/test/68_blob_named_by_arg.dts b/tools/binman/test/068_blob_named_by_arg.dts
index e129f843cd..e129f843cd 100644
--- a/tools/binman/test/68_blob_named_by_arg.dts
+++ b/tools/binman/test/068_blob_named_by_arg.dts
diff --git a/tools/binman/test/69_fill.dts b/tools/binman/test/069_fill.dts
index e372ea37aa..e372ea37aa 100644
--- a/tools/binman/test/69_fill.dts
+++ b/tools/binman/test/069_fill.dts
diff --git a/tools/binman/test/70_fill_no_size.dts b/tools/binman/test/070_fill_no_size.dts
index 7b1fcf1b68..7b1fcf1b68 100644
--- a/tools/binman/test/70_fill_no_size.dts
+++ b/tools/binman/test/070_fill_no_size.dts
diff --git a/tools/binman/test/71_gbb.dts b/tools/binman/test/071_gbb.dts
index 551756372a..551756372a 100644
--- a/tools/binman/test/71_gbb.dts
+++ b/tools/binman/test/071_gbb.dts
diff --git a/tools/binman/test/72_gbb_too_small.dts b/tools/binman/test/072_gbb_too_small.dts
index c088f36a1d..c088f36a1d 100644
--- a/tools/binman/test/72_gbb_too_small.dts
+++ b/tools/binman/test/072_gbb_too_small.dts
diff --git a/tools/binman/test/73_gbb_no_size.dts b/tools/binman/test/073_gbb_no_size.dts
index 83be403785..83be403785 100644
--- a/tools/binman/test/73_gbb_no_size.dts
+++ b/tools/binman/test/073_gbb_no_size.dts
diff --git a/tools/binman/test/74_vblock.dts b/tools/binman/test/074_vblock.dts
index f0c21bfe9f..f0c21bfe9f 100644
--- a/tools/binman/test/74_vblock.dts
+++ b/tools/binman/test/074_vblock.dts
diff --git a/tools/binman/test/75_vblock_no_content.dts b/tools/binman/test/075_vblock_no_content.dts
index 676d9474b3..676d9474b3 100644
--- a/tools/binman/test/75_vblock_no_content.dts
+++ b/tools/binman/test/075_vblock_no_content.dts
diff --git a/tools/binman/test/76_vblock_bad_phandle.dts b/tools/binman/test/076_vblock_bad_phandle.dts
index ffbd0c335c..ffbd0c335c 100644
--- a/tools/binman/test/76_vblock_bad_phandle.dts
+++ b/tools/binman/test/076_vblock_bad_phandle.dts
diff --git a/tools/binman/test/77_vblock_bad_entry.dts b/tools/binman/test/077_vblock_bad_entry.dts
index 764c42a56e..764c42a56e 100644
--- a/tools/binman/test/77_vblock_bad_entry.dts
+++ b/tools/binman/test/077_vblock_bad_entry.dts
diff --git a/tools/binman/test/78_u_boot_tpl.dts b/tools/binman/test/078_u_boot_tpl.dts
index 6c60b4c46f..6c60b4c46f 100644
--- a/tools/binman/test/78_u_boot_tpl.dts
+++ b/tools/binman/test/078_u_boot_tpl.dts
diff --git a/tools/binman/test/79_uses_pos.dts b/tools/binman/test/079_uses_pos.dts
index 7638b9b5e0..7638b9b5e0 100644
--- a/tools/binman/test/79_uses_pos.dts
+++ b/tools/binman/test/079_uses_pos.dts
diff --git a/tools/binman/test/80_fill_empty.dts b/tools/binman/test/080_fill_empty.dts
index 2b78d3ae88..2b78d3ae88 100644
--- a/tools/binman/test/80_fill_empty.dts
+++ b/tools/binman/test/080_fill_empty.dts
diff --git a/tools/binman/test/81_x86-start16-tpl.dts b/tools/binman/test/081_x86-start16-tpl.dts
index 68e6bbd68f..68e6bbd68f 100644
--- a/tools/binman/test/81_x86-start16-tpl.dts
+++ b/tools/binman/test/081_x86-start16-tpl.dts
diff --git a/tools/binman/test/82_fdt_update_all.dts b/tools/binman/test/082_fdt_update_all.dts
index 284975cc28..284975cc28 100644
--- a/tools/binman/test/82_fdt_update_all.dts
+++ b/tools/binman/test/082_fdt_update_all.dts
diff --git a/tools/binman/test/83_compress.dts b/tools/binman/test/083_compress.dts
index 07813bdeaa..07813bdeaa 100644
--- a/tools/binman/test/83_compress.dts
+++ b/tools/binman/test/083_compress.dts
diff --git a/tools/binman/test/84_files.dts b/tools/binman/test/084_files.dts
index 83ddb78f8e..83ddb78f8e 100644
--- a/tools/binman/test/84_files.dts
+++ b/tools/binman/test/084_files.dts
diff --git a/tools/binman/test/85_files_compress.dts b/tools/binman/test/085_files_compress.dts
index 847b398bf2..847b398bf2 100644
--- a/tools/binman/test/85_files_compress.dts
+++ b/tools/binman/test/085_files_compress.dts
diff --git a/tools/binman/test/86_files_none.dts b/tools/binman/test/086_files_none.dts
index 34bd92f224..34bd92f224 100644
--- a/tools/binman/test/86_files_none.dts
+++ b/tools/binman/test/086_files_none.dts
diff --git a/tools/binman/test/87_files_no_pattern.dts b/tools/binman/test/087_files_no_pattern.dts
index 0cb5b469cb..0cb5b469cb 100644
--- a/tools/binman/test/87_files_no_pattern.dts
+++ b/tools/binman/test/087_files_no_pattern.dts
diff --git a/tools/binman/test/88_expand_size.dts b/tools/binman/test/088_expand_size.dts
index c8a01308ec..c8a01308ec 100644
--- a/tools/binman/test/88_expand_size.dts
+++ b/tools/binman/test/088_expand_size.dts
diff --git a/tools/binman/test/89_expand_size_bad.dts b/tools/binman/test/089_expand_size_bad.dts
index edc0e5cf68..edc0e5cf68 100644
--- a/tools/binman/test/89_expand_size_bad.dts
+++ b/tools/binman/test/089_expand_size_bad.dts
diff --git a/tools/binman/test/90_hash.dts b/tools/binman/test/090_hash.dts
index 200304599d..200304599d 100644
--- a/tools/binman/test/90_hash.dts
+++ b/tools/binman/test/090_hash.dts
diff --git a/tools/binman/test/91_hash_no_algo.dts b/tools/binman/test/091_hash_no_algo.dts
index b64df20511..b64df20511 100644
--- a/tools/binman/test/91_hash_no_algo.dts
+++ b/tools/binman/test/091_hash_no_algo.dts
diff --git a/tools/binman/test/92_hash_bad_algo.dts b/tools/binman/test/092_hash_bad_algo.dts
index d2402000db..d2402000db 100644
--- a/tools/binman/test/92_hash_bad_algo.dts
+++ b/tools/binman/test/092_hash_bad_algo.dts
diff --git a/tools/binman/test/93_x86_tpl_ucode.dts b/tools/binman/test/093_x86_tpl_ucode.dts
index d7ed9fc66b..d7ed9fc66b 100644
--- a/tools/binman/test/93_x86_tpl_ucode.dts
+++ b/tools/binman/test/093_x86_tpl_ucode.dts
diff --git a/tools/binman/test/94_fmap_x86.dts b/tools/binman/test/094_fmap_x86.dts
index 613c5dab42..613c5dab42 100644
--- a/tools/binman/test/94_fmap_x86.dts
+++ b/tools/binman/test/094_fmap_x86.dts
diff --git a/tools/binman/test/95_fmap_x86_section.dts b/tools/binman/test/095_fmap_x86_section.dts
index 4cfce45670..4cfce45670 100644
--- a/tools/binman/test/95_fmap_x86_section.dts
+++ b/tools/binman/test/095_fmap_x86_section.dts
diff --git a/tools/binman/test/96_elf.dts b/tools/binman/test/096_elf.dts
index df3440c319..df3440c319 100644
--- a/tools/binman/test/96_elf.dts
+++ b/tools/binman/test/096_elf.dts
diff --git a/tools/binman/test/97_elf_strip.dts b/tools/binman/test/097_elf_strip.dts
index 6f3c66fd70..6f3c66fd70 100644
--- a/tools/binman/test/97_elf_strip.dts
+++ b/tools/binman/test/097_elf_strip.dts
diff --git a/tools/binman/test/99_hash_section.dts b/tools/binman/test/099_hash_section.dts
index dcd8683d64..dcd8683d64 100644
--- a/tools/binman/test/99_hash_section.dts
+++ b/tools/binman/test/099_hash_section.dts