From 741f2d620c3ff2d59d3b25c344ab6b8bec4a4c87 Mon Sep 17 00:00:00 2001
From: Simon Glass <sjg@chromium.org>
Date: Mon, 1 Oct 2018 12:22:30 -0600
Subject: [PATCH] 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>
---
 tools/binman/entry_test.py                         |   2 +-
 tools/binman/fdt_test.py                           |   4 +-
 tools/binman/ftest.py                              | 224 ++++++++++-----------
 .../test/{01_invalid.dts => 001_invalid.dts}       |   0
 .../{02_missing_node.dts => 002_missing_node.dts}  |   0
 tools/binman/test/{03_empty.dts => 003_empty.dts}  |   0
 ...{04_invalid_entry.dts => 004_invalid_entry.dts} |   0
 .../binman/test/{05_simple.dts => 005_simple.dts}  |   0
 .../test/{06_dual_image.dts => 006_dual_image.dts} |   0
 .../test/{07_bad_align.dts => 007_bad_align.dts}   |   0
 tools/binman/test/{08_pack.dts => 008_pack.dts}    |   0
 .../test/{09_pack_extra.dts => 009_pack_extra.dts} |   0
 ..._align_power2.dts => 010_pack_align_power2.dts} |   0
 ...e_power2.dts => 011_pack_align_size_power2.dts} |   0
 ...2_pack_inv_align.dts => 012_pack_inv_align.dts} |   0
 ..._size_align.dts => 013_pack_inv_size_align.dts} |   0
 .../{14_pack_overlap.dts => 014_pack_overlap.dts}  |   0
 ...{15_pack_overflow.dts => 015_pack_overflow.dts} |   0
 ...ge_overflow.dts => 016_pack_image_overflow.dts} |   0
 ...pack_image_size.dts => 017_pack_image_size.dts} |   0
 ...ck_image_align.dts => 018_pack_image_align.dts} |   0
 ...mage_align.dts => 019_pack_inv_image_align.dts} |   0
 ...er2.dts => 020_pack_inv_image_align_power2.dts} |   0
 .../test/{21_image_pad.dts => 021_image_pad.dts}   |   0
 .../test/{22_image_name.dts => 022_image_name.dts} |   0
 tools/binman/test/{23_blob.dts => 023_blob.dts}    |   0
 .../binman/test/{24_sorted.dts => 024_sorted.dts}  |   0
 ...5_pack_zero_size.dts => 025_pack_zero_size.dts} |   0
 ...pack_u_boot_dtb.dts => 026_pack_u_boot_dtb.dts} |   0
 ...ck_4gb_no_size.dts => 027_pack_4gb_no_size.dts} |   0
 ...ck_4gb_outside.dts => 028_pack_4gb_outside.dts} |   0
 .../test/{29_x86-rom.dts => 029_x86-rom.dts}       |   0
 ...m-me-no-desc.dts => 030_x86-rom-me-no-desc.dts} |   0
 .../test/{31_x86-rom-me.dts => 031_x86-rom-me.dts} |   0
 .../test/{32_intel-vga.dts => 032_intel-vga.dts}   |   0
 .../{33_x86-start16.dts => 033_x86-start16.dts}    |   0
 .../test/{34_x86_ucode.dts => 034_x86_ucode.dts}   |   0
 ...6_single_ucode.dts => 035_x86_single_ucode.dts} |   0
 .../test/{36_u_boot_img.dts => 036_u_boot_img.dts} |   0
 .../{37_x86_no_ucode.dts => 037_x86_no_ucode.dts}  |   0
 ...ing_node.dts => 038_x86_ucode_missing_node.dts} |   0
 ...g_node2.dts => 039_x86_ucode_missing_node2.dts} |   0
 ...in_image.dts => 040_x86_ucode_not_in_image.dts} |   0
 ...known_pos_size.dts => 041_unknown_pos_size.dts} |   0
 .../test/{42_intel-fsp.dts => 042_intel-fsp.dts}   |   0
 .../test/{43_intel-cmc.dts => 043_intel-cmc.dts}   |   0
 ...tional_ucode.dts => 044_x86_optional_ucode.dts} |   0
 .../test/{45_prop_test.dts => 045_prop_test.dts}   |   0
 .../test/{46_intel-vbt.dts => 046_intel-vbt.dts}   |   0
 .../{47_spl_bss_pad.dts => 047_spl_bss_pad.dts}    |   0
 ...x86-start16-spl.dts => 048_x86-start16-spl.dts} |   0
 ...{49_x86_ucode_spl.dts => 049_x86_ucode_spl.dts} |   0
 .../test/{50_intel_mrc.dts => 050_intel_mrc.dts}   |   0
 ...1_u_boot_spl_dtb.dts => 051_u_boot_spl_dtb.dts} |   0
 ...boot_spl_nodtb.dts => 052_u_boot_spl_nodtb.dts} |   0
 .../test/{53_symbols.dts => 053_symbols.dts}       |   0
 .../{54_unit_address.dts => 054_unit_address.dts}  |   0
 .../test/{55_sections.dts => 055_sections.dts}     |   0
 .../{56_name_prefix.dts => 056_name_prefix.dts}    |   0
 ...known_contents.dts => 057_unknown_contents.dts} |   0
 ...retry.dts => 058_x86_ucode_spl_needs_retry.dts} |   0
 .../{59_change_size.dts => 059_change_size.dts}    |   0
 .../test/{60_fdt_update.dts => 060_fdt_update.dts} |   0
 ...1_fdt_update_bad.dts => 061_fdt_update_bad.dts} |   0
 .../test/{62_entry_args.dts => 062_entry_args.dts} |   0
 ...args_missing.dts => 063_entry_args_missing.dts} |   0
 ...gs_required.dts => 064_entry_args_required.dts} |   0
 ...ype.dts => 065_entry_args_unknown_datatype.dts} |   0
 tools/binman/test/{66_text.dts => 066_text.dts}    |   0
 tools/binman/test/{67_fmap.dts => 067_fmap.dts}    |   0
 ..._named_by_arg.dts => 068_blob_named_by_arg.dts} |   0
 tools/binman/test/{69_fill.dts => 069_fill.dts}    |   0
 .../{70_fill_no_size.dts => 070_fill_no_size.dts}  |   0
 tools/binman/test/{71_gbb.dts => 071_gbb.dts}      |   0
 ...{72_gbb_too_small.dts => 072_gbb_too_small.dts} |   0
 .../{73_gbb_no_size.dts => 073_gbb_no_size.dts}    |   0
 .../binman/test/{74_vblock.dts => 074_vblock.dts}  |   0
 ...ck_no_content.dts => 075_vblock_no_content.dts} |   0
 ..._bad_phandle.dts => 076_vblock_bad_phandle.dts} |   0
 ...lock_bad_entry.dts => 077_vblock_bad_entry.dts} |   0
 .../test/{78_u_boot_tpl.dts => 078_u_boot_tpl.dts} |   0
 .../test/{79_uses_pos.dts => 079_uses_pos.dts}     |   0
 .../test/{80_fill_empty.dts => 080_fill_empty.dts} |   0
 ...x86-start16-tpl.dts => 081_x86-start16-tpl.dts} |   0
 ...2_fdt_update_all.dts => 082_fdt_update_all.dts} |   0
 .../test/{83_compress.dts => 083_compress.dts}     |   0
 tools/binman/test/{84_files.dts => 084_files.dts}  |   0
 ...5_files_compress.dts => 085_files_compress.dts} |   0
 .../test/{86_files_none.dts => 086_files_none.dts} |   0
 ...les_no_pattern.dts => 087_files_no_pattern.dts} |   0
 .../{88_expand_size.dts => 088_expand_size.dts}    |   0
 ...expand_size_bad.dts => 089_expand_size_bad.dts} |   0
 tools/binman/test/{90_hash.dts => 090_hash.dts}    |   0
 .../{91_hash_no_algo.dts => 091_hash_no_algo.dts}  |   0
 ...{92_hash_bad_algo.dts => 092_hash_bad_algo.dts} |   0
 ...{93_x86_tpl_ucode.dts => 093_x86_tpl_ucode.dts} |   0
 .../test/{94_fmap_x86.dts => 094_fmap_x86.dts}     |   0
 ...ap_x86_section.dts => 095_fmap_x86_section.dts} |   0
 tools/binman/test/{96_elf.dts => 096_elf.dts}      |   0
 .../test/{97_elf_strip.dts => 097_elf_strip.dts}   |   0
 .../{99_hash_section.dts => 099_hash_section.dts}  |   0
 101 files changed, 115 insertions(+), 115 deletions(-)
 rename tools/binman/test/{01_invalid.dts => 001_invalid.dts} (100%)
 rename tools/binman/test/{02_missing_node.dts => 002_missing_node.dts} (100%)
 rename tools/binman/test/{03_empty.dts => 003_empty.dts} (100%)
 rename tools/binman/test/{04_invalid_entry.dts => 004_invalid_entry.dts} (100%)
 rename tools/binman/test/{05_simple.dts => 005_simple.dts} (100%)
 rename tools/binman/test/{06_dual_image.dts => 006_dual_image.dts} (100%)
 rename tools/binman/test/{07_bad_align.dts => 007_bad_align.dts} (100%)
 rename tools/binman/test/{08_pack.dts => 008_pack.dts} (100%)
 rename tools/binman/test/{09_pack_extra.dts => 009_pack_extra.dts} (100%)
 rename tools/binman/test/{10_pack_align_power2.dts => 010_pack_align_power2.dts} (100%)
 rename tools/binman/test/{11_pack_align_size_power2.dts => 011_pack_align_size_power2.dts} (100%)
 rename tools/binman/test/{12_pack_inv_align.dts => 012_pack_inv_align.dts} (100%)
 rename tools/binman/test/{13_pack_inv_size_align.dts => 013_pack_inv_size_align.dts} (100%)
 rename tools/binman/test/{14_pack_overlap.dts => 014_pack_overlap.dts} (100%)
 rename tools/binman/test/{15_pack_overflow.dts => 015_pack_overflow.dts} (100%)
 rename tools/binman/test/{16_pack_image_overflow.dts => 016_pack_image_overflow.dts} (100%)
 rename tools/binman/test/{17_pack_image_size.dts => 017_pack_image_size.dts} (100%)
 rename tools/binman/test/{18_pack_image_align.dts => 018_pack_image_align.dts} (100%)
 rename tools/binman/test/{19_pack_inv_image_align.dts => 019_pack_inv_image_align.dts} (100%)
 rename tools/binman/test/{20_pack_inv_image_align_power2.dts => 020_pack_inv_image_align_power2.dts} (100%)
 rename tools/binman/test/{21_image_pad.dts => 021_image_pad.dts} (100%)
 rename tools/binman/test/{22_image_name.dts => 022_image_name.dts} (100%)
 rename tools/binman/test/{23_blob.dts => 023_blob.dts} (100%)
 rename tools/binman/test/{24_sorted.dts => 024_sorted.dts} (100%)
 rename tools/binman/test/{25_pack_zero_size.dts => 025_pack_zero_size.dts} (100%)
 rename tools/binman/test/{26_pack_u_boot_dtb.dts => 026_pack_u_boot_dtb.dts} (100%)
 rename tools/binman/test/{27_pack_4gb_no_size.dts => 027_pack_4gb_no_size.dts} (100%)
 rename tools/binman/test/{28_pack_4gb_outside.dts => 028_pack_4gb_outside.dts} (100%)
 rename tools/binman/test/{29_x86-rom.dts => 029_x86-rom.dts} (100%)
 rename tools/binman/test/{30_x86-rom-me-no-desc.dts => 030_x86-rom-me-no-desc.dts} (100%)
 rename tools/binman/test/{31_x86-rom-me.dts => 031_x86-rom-me.dts} (100%)
 rename tools/binman/test/{32_intel-vga.dts => 032_intel-vga.dts} (100%)
 rename tools/binman/test/{33_x86-start16.dts => 033_x86-start16.dts} (100%)
 rename tools/binman/test/{34_x86_ucode.dts => 034_x86_ucode.dts} (100%)
 rename tools/binman/test/{35_x86_single_ucode.dts => 035_x86_single_ucode.dts} (100%)
 rename tools/binman/test/{36_u_boot_img.dts => 036_u_boot_img.dts} (100%)
 rename tools/binman/test/{37_x86_no_ucode.dts => 037_x86_no_ucode.dts} (100%)
 rename tools/binman/test/{38_x86_ucode_missing_node.dts => 038_x86_ucode_missing_node.dts} (100%)
 rename tools/binman/test/{39_x86_ucode_missing_node2.dts => 039_x86_ucode_missing_node2.dts} (100%)
 rename tools/binman/test/{40_x86_ucode_not_in_image.dts => 040_x86_ucode_not_in_image.dts} (100%)
 rename tools/binman/test/{41_unknown_pos_size.dts => 041_unknown_pos_size.dts} (100%)
 rename tools/binman/test/{42_intel-fsp.dts => 042_intel-fsp.dts} (100%)
 rename tools/binman/test/{43_intel-cmc.dts => 043_intel-cmc.dts} (100%)
 rename tools/binman/test/{44_x86_optional_ucode.dts => 044_x86_optional_ucode.dts} (100%)
 rename tools/binman/test/{45_prop_test.dts => 045_prop_test.dts} (100%)
 rename tools/binman/test/{46_intel-vbt.dts => 046_intel-vbt.dts} (100%)
 rename tools/binman/test/{47_spl_bss_pad.dts => 047_spl_bss_pad.dts} (100%)
 rename tools/binman/test/{48_x86-start16-spl.dts => 048_x86-start16-spl.dts} (100%)
 rename tools/binman/test/{49_x86_ucode_spl.dts => 049_x86_ucode_spl.dts} (100%)
 rename tools/binman/test/{50_intel_mrc.dts => 050_intel_mrc.dts} (100%)
 rename tools/binman/test/{51_u_boot_spl_dtb.dts => 051_u_boot_spl_dtb.dts} (100%)
 rename tools/binman/test/{52_u_boot_spl_nodtb.dts => 052_u_boot_spl_nodtb.dts} (100%)
 rename tools/binman/test/{53_symbols.dts => 053_symbols.dts} (100%)
 rename tools/binman/test/{54_unit_address.dts => 054_unit_address.dts} (100%)
 rename tools/binman/test/{55_sections.dts => 055_sections.dts} (100%)
 rename tools/binman/test/{56_name_prefix.dts => 056_name_prefix.dts} (100%)
 rename tools/binman/test/{57_unknown_contents.dts => 057_unknown_contents.dts} (100%)
 rename tools/binman/test/{58_x86_ucode_spl_needs_retry.dts => 058_x86_ucode_spl_needs_retry.dts} (100%)
 rename tools/binman/test/{59_change_size.dts => 059_change_size.dts} (100%)
 rename tools/binman/test/{60_fdt_update.dts => 060_fdt_update.dts} (100%)
 rename tools/binman/test/{61_fdt_update_bad.dts => 061_fdt_update_bad.dts} (100%)
 rename tools/binman/test/{62_entry_args.dts => 062_entry_args.dts} (100%)
 rename tools/binman/test/{63_entry_args_missing.dts => 063_entry_args_missing.dts} (100%)
 rename tools/binman/test/{64_entry_args_required.dts => 064_entry_args_required.dts} (100%)
 rename tools/binman/test/{65_entry_args_unknown_datatype.dts => 065_entry_args_unknown_datatype.dts} (100%)
 rename tools/binman/test/{66_text.dts => 066_text.dts} (100%)
 rename tools/binman/test/{67_fmap.dts => 067_fmap.dts} (100%)
 rename tools/binman/test/{68_blob_named_by_arg.dts => 068_blob_named_by_arg.dts} (100%)
 rename tools/binman/test/{69_fill.dts => 069_fill.dts} (100%)
 rename tools/binman/test/{70_fill_no_size.dts => 070_fill_no_size.dts} (100%)
 rename tools/binman/test/{71_gbb.dts => 071_gbb.dts} (100%)
 rename tools/binman/test/{72_gbb_too_small.dts => 072_gbb_too_small.dts} (100%)
 rename tools/binman/test/{73_gbb_no_size.dts => 073_gbb_no_size.dts} (100%)
 rename tools/binman/test/{74_vblock.dts => 074_vblock.dts} (100%)
 rename tools/binman/test/{75_vblock_no_content.dts => 075_vblock_no_content.dts} (100%)
 rename tools/binman/test/{76_vblock_bad_phandle.dts => 076_vblock_bad_phandle.dts} (100%)
 rename tools/binman/test/{77_vblock_bad_entry.dts => 077_vblock_bad_entry.dts} (100%)
 rename tools/binman/test/{78_u_boot_tpl.dts => 078_u_boot_tpl.dts} (100%)
 rename tools/binman/test/{79_uses_pos.dts => 079_uses_pos.dts} (100%)
 rename tools/binman/test/{80_fill_empty.dts => 080_fill_empty.dts} (100%)
 rename tools/binman/test/{81_x86-start16-tpl.dts => 081_x86-start16-tpl.dts} (100%)
 rename tools/binman/test/{82_fdt_update_all.dts => 082_fdt_update_all.dts} (100%)
 rename tools/binman/test/{83_compress.dts => 083_compress.dts} (100%)
 rename tools/binman/test/{84_files.dts => 084_files.dts} (100%)
 rename tools/binman/test/{85_files_compress.dts => 085_files_compress.dts} (100%)
 rename tools/binman/test/{86_files_none.dts => 086_files_none.dts} (100%)
 rename tools/binman/test/{87_files_no_pattern.dts => 087_files_no_pattern.dts} (100%)
 rename tools/binman/test/{88_expand_size.dts => 088_expand_size.dts} (100%)
 rename tools/binman/test/{89_expand_size_bad.dts => 089_expand_size_bad.dts} (100%)
 rename tools/binman/test/{90_hash.dts => 090_hash.dts} (100%)
 rename tools/binman/test/{91_hash_no_algo.dts => 091_hash_no_algo.dts} (100%)
 rename tools/binman/test/{92_hash_bad_algo.dts => 092_hash_bad_algo.dts} (100%)
 rename tools/binman/test/{93_x86_tpl_ucode.dts => 093_x86_tpl_ucode.dts} (100%)
 rename tools/binman/test/{94_fmap_x86.dts => 094_fmap_x86.dts} (100%)
 rename tools/binman/test/{95_fmap_x86_section.dts => 095_fmap_x86_section.dts} (100%)
 rename tools/binman/test/{96_elf.dts => 096_elf.dts} (100%)
 rename tools/binman/test/{97_elf_strip.dts => 097_elf_strip.dts} (100%)
 rename tools/binman/test/{99_hash_section.dts => 099_hash_section.dts} (100%)

diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py
index 17ab229..1f7ff5b 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 b916701..ac6f910 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 9f21027..167f56d 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
similarity index 100%
rename from tools/binman/test/01_invalid.dts
rename to tools/binman/test/001_invalid.dts
diff --git a/tools/binman/test/02_missing_node.dts b/tools/binman/test/002_missing_node.dts
similarity index 100%
rename from tools/binman/test/02_missing_node.dts
rename to tools/binman/test/002_missing_node.dts
diff --git a/tools/binman/test/03_empty.dts b/tools/binman/test/003_empty.dts
similarity index 100%
rename from tools/binman/test/03_empty.dts
rename to tools/binman/test/003_empty.dts
diff --git a/tools/binman/test/04_invalid_entry.dts b/tools/binman/test/004_invalid_entry.dts
similarity index 100%
rename from tools/binman/test/04_invalid_entry.dts
rename to tools/binman/test/004_invalid_entry.dts
diff --git a/tools/binman/test/05_simple.dts b/tools/binman/test/005_simple.dts
similarity index 100%
rename from tools/binman/test/05_simple.dts
rename to tools/binman/test/005_simple.dts
diff --git a/tools/binman/test/06_dual_image.dts b/tools/binman/test/006_dual_image.dts
similarity index 100%
rename from tools/binman/test/06_dual_image.dts
rename to 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
similarity index 100%
rename from tools/binman/test/07_bad_align.dts
rename to tools/binman/test/007_bad_align.dts
diff --git a/tools/binman/test/08_pack.dts b/tools/binman/test/008_pack.dts
similarity index 100%
rename from tools/binman/test/08_pack.dts
rename to tools/binman/test/008_pack.dts
diff --git a/tools/binman/test/09_pack_extra.dts b/tools/binman/test/009_pack_extra.dts
similarity index 100%
rename from tools/binman/test/09_pack_extra.dts
rename to 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
similarity index 100%
rename from tools/binman/test/10_pack_align_power2.dts
rename to 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
similarity index 100%
rename from tools/binman/test/11_pack_align_size_power2.dts
rename to 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
similarity index 100%
rename from tools/binman/test/12_pack_inv_align.dts
rename to 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
similarity index 100%
rename from tools/binman/test/13_pack_inv_size_align.dts
rename to 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
similarity index 100%
rename from tools/binman/test/14_pack_overlap.dts
rename to 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
similarity index 100%
rename from tools/binman/test/15_pack_overflow.dts
rename to 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
similarity index 100%
rename from tools/binman/test/16_pack_image_overflow.dts
rename to 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
similarity index 100%
rename from tools/binman/test/17_pack_image_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/18_pack_image_align.dts
rename to 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
similarity index 100%
rename from tools/binman/test/19_pack_inv_image_align.dts
rename to 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
similarity index 100%
rename from tools/binman/test/20_pack_inv_image_align_power2.dts
rename to 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
similarity index 100%
rename from tools/binman/test/21_image_pad.dts
rename to 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
similarity index 100%
rename from tools/binman/test/22_image_name.dts
rename to tools/binman/test/022_image_name.dts
diff --git a/tools/binman/test/23_blob.dts b/tools/binman/test/023_blob.dts
similarity index 100%
rename from tools/binman/test/23_blob.dts
rename to tools/binman/test/023_blob.dts
diff --git a/tools/binman/test/24_sorted.dts b/tools/binman/test/024_sorted.dts
similarity index 100%
rename from tools/binman/test/24_sorted.dts
rename to 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
similarity index 100%
rename from tools/binman/test/25_pack_zero_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/26_pack_u_boot_dtb.dts
rename to 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
similarity index 100%
rename from tools/binman/test/27_pack_4gb_no_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/28_pack_4gb_outside.dts
rename to 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
similarity index 100%
rename from tools/binman/test/29_x86-rom.dts
rename to 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
similarity index 100%
rename from tools/binman/test/30_x86-rom-me-no-desc.dts
rename to 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
similarity index 100%
rename from tools/binman/test/31_x86-rom-me.dts
rename to 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
similarity index 100%
rename from tools/binman/test/32_intel-vga.dts
rename to 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
similarity index 100%
rename from tools/binman/test/33_x86-start16.dts
rename to 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
similarity index 100%
rename from tools/binman/test/34_x86_ucode.dts
rename to 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
similarity index 100%
rename from tools/binman/test/35_x86_single_ucode.dts
rename to 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
similarity index 100%
rename from tools/binman/test/36_u_boot_img.dts
rename to 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
similarity index 100%
rename from tools/binman/test/37_x86_no_ucode.dts
rename to 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
similarity index 100%
rename from tools/binman/test/38_x86_ucode_missing_node.dts
rename to 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
similarity index 100%
rename from tools/binman/test/39_x86_ucode_missing_node2.dts
rename to 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
similarity index 100%
rename from tools/binman/test/40_x86_ucode_not_in_image.dts
rename to 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
similarity index 100%
rename from tools/binman/test/41_unknown_pos_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/42_intel-fsp.dts
rename to 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
similarity index 100%
rename from tools/binman/test/43_intel-cmc.dts
rename to 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
similarity index 100%
rename from tools/binman/test/44_x86_optional_ucode.dts
rename to 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
similarity index 100%
rename from tools/binman/test/45_prop_test.dts
rename to 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
similarity index 100%
rename from tools/binman/test/46_intel-vbt.dts
rename to 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
similarity index 100%
rename from tools/binman/test/47_spl_bss_pad.dts
rename to 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
similarity index 100%
rename from tools/binman/test/48_x86-start16-spl.dts
rename to 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
similarity index 100%
rename from tools/binman/test/49_x86_ucode_spl.dts
rename to 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
similarity index 100%
rename from tools/binman/test/50_intel_mrc.dts
rename to 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
similarity index 100%
rename from tools/binman/test/51_u_boot_spl_dtb.dts
rename to 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
similarity index 100%
rename from tools/binman/test/52_u_boot_spl_nodtb.dts
rename to 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
similarity index 100%
rename from tools/binman/test/53_symbols.dts
rename to tools/binman/test/053_symbols.dts
diff --git a/tools/binman/test/54_unit_address.dts b/tools/binman/test/054_unit_address.dts
similarity index 100%
rename from tools/binman/test/54_unit_address.dts
rename to tools/binman/test/054_unit_address.dts
diff --git a/tools/binman/test/55_sections.dts b/tools/binman/test/055_sections.dts
similarity index 100%
rename from tools/binman/test/55_sections.dts
rename to tools/binman/test/055_sections.dts
diff --git a/tools/binman/test/56_name_prefix.dts b/tools/binman/test/056_name_prefix.dts
similarity index 100%
rename from tools/binman/test/56_name_prefix.dts
rename to 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
similarity index 100%
rename from tools/binman/test/57_unknown_contents.dts
rename to 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
similarity index 100%
rename from tools/binman/test/58_x86_ucode_spl_needs_retry.dts
rename to 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
similarity index 100%
rename from tools/binman/test/59_change_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/60_fdt_update.dts
rename to 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
similarity index 100%
rename from tools/binman/test/61_fdt_update_bad.dts
rename to 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
similarity index 100%
rename from tools/binman/test/62_entry_args.dts
rename to 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
similarity index 100%
rename from tools/binman/test/63_entry_args_missing.dts
rename to 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
similarity index 100%
rename from tools/binman/test/64_entry_args_required.dts
rename to 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
similarity index 100%
rename from tools/binman/test/65_entry_args_unknown_datatype.dts
rename to 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
similarity index 100%
rename from tools/binman/test/66_text.dts
rename to tools/binman/test/066_text.dts
diff --git a/tools/binman/test/67_fmap.dts b/tools/binman/test/067_fmap.dts
similarity index 100%
rename from tools/binman/test/67_fmap.dts
rename to 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
similarity index 100%
rename from tools/binman/test/68_blob_named_by_arg.dts
rename to 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
similarity index 100%
rename from tools/binman/test/69_fill.dts
rename to 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
similarity index 100%
rename from tools/binman/test/70_fill_no_size.dts
rename to tools/binman/test/070_fill_no_size.dts
diff --git a/tools/binman/test/71_gbb.dts b/tools/binman/test/071_gbb.dts
similarity index 100%
rename from tools/binman/test/71_gbb.dts
rename to 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
similarity index 100%
rename from tools/binman/test/72_gbb_too_small.dts
rename to 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
similarity index 100%
rename from tools/binman/test/73_gbb_no_size.dts
rename to tools/binman/test/073_gbb_no_size.dts
diff --git a/tools/binman/test/74_vblock.dts b/tools/binman/test/074_vblock.dts
similarity index 100%
rename from tools/binman/test/74_vblock.dts
rename to 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
similarity index 100%
rename from tools/binman/test/75_vblock_no_content.dts
rename to 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
similarity index 100%
rename from tools/binman/test/76_vblock_bad_phandle.dts
rename to 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
similarity index 100%
rename from tools/binman/test/77_vblock_bad_entry.dts
rename to 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
similarity index 100%
rename from tools/binman/test/78_u_boot_tpl.dts
rename to 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
similarity index 100%
rename from tools/binman/test/79_uses_pos.dts
rename to 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
similarity index 100%
rename from tools/binman/test/80_fill_empty.dts
rename to 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
similarity index 100%
rename from tools/binman/test/81_x86-start16-tpl.dts
rename to 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
similarity index 100%
rename from tools/binman/test/82_fdt_update_all.dts
rename to tools/binman/test/082_fdt_update_all.dts
diff --git a/tools/binman/test/83_compress.dts b/tools/binman/test/083_compress.dts
similarity index 100%
rename from tools/binman/test/83_compress.dts
rename to tools/binman/test/083_compress.dts
diff --git a/tools/binman/test/84_files.dts b/tools/binman/test/084_files.dts
similarity index 100%
rename from tools/binman/test/84_files.dts
rename to tools/binman/test/084_files.dts
diff --git a/tools/binman/test/85_files_compress.dts b/tools/binman/test/085_files_compress.dts
similarity index 100%
rename from tools/binman/test/85_files_compress.dts
rename to 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
similarity index 100%
rename from tools/binman/test/86_files_none.dts
rename to 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
similarity index 100%
rename from tools/binman/test/87_files_no_pattern.dts
rename to 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
similarity index 100%
rename from tools/binman/test/88_expand_size.dts
rename to 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
similarity index 100%
rename from tools/binman/test/89_expand_size_bad.dts
rename to tools/binman/test/089_expand_size_bad.dts
diff --git a/tools/binman/test/90_hash.dts b/tools/binman/test/090_hash.dts
similarity index 100%
rename from tools/binman/test/90_hash.dts
rename to 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
similarity index 100%
rename from tools/binman/test/91_hash_no_algo.dts
rename to 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
similarity index 100%
rename from tools/binman/test/92_hash_bad_algo.dts
rename to 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
similarity index 100%
rename from tools/binman/test/93_x86_tpl_ucode.dts
rename to 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
similarity index 100%
rename from tools/binman/test/94_fmap_x86.dts
rename to 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
similarity index 100%
rename from tools/binman/test/95_fmap_x86_section.dts
rename to tools/binman/test/095_fmap_x86_section.dts
diff --git a/tools/binman/test/96_elf.dts b/tools/binman/test/096_elf.dts
similarity index 100%
rename from tools/binman/test/96_elf.dts
rename to tools/binman/test/096_elf.dts
diff --git a/tools/binman/test/97_elf_strip.dts b/tools/binman/test/097_elf_strip.dts
similarity index 100%
rename from tools/binman/test/97_elf_strip.dts
rename to 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
similarity index 100%
rename from tools/binman/test/99_hash_section.dts
rename to tools/binman/test/099_hash_section.dts