[v2,07/10] dm: test: Rename test flags to be generic

Message ID 20200608024337.85575-2-sjg@chromium.org
State New
Headers show
Series
  • cmd: Fix 'md' and add a memory-search command
Related show

Commit Message

Simon Glass June 8, 2020, 2:43 a.m.
At present the flags value is common to all tests but only defined by the
driver-model tests. Rename the enum and move it into the generic unit-test
header.

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

(no changes since v1)

 doc/README.commands    |  2 +-
 include/dm/test.h      |  9 ---------
 include/test/test.h    | 10 +++++++++
 test/dm/acpi.c         | 18 ++++++++---------
 test/dm/adc.c          | 16 +++++++--------
 test/dm/audio.c        |  2 +-
 test/dm/axi.c          |  6 +++---
 test/dm/blk.c          | 10 ++++-----
 test/dm/board.c        |  2 +-
 test/dm/bootcount.c    |  2 +-
 test/dm/bus.c          | 26 ++++++++++++------------
 test/dm/cache.c        |  2 +-
 test/dm/clk.c          |  6 +++---
 test/dm/clk_ccf.c      |  2 +-
 test/dm/core.c         | 30 +++++++++++++--------------
 test/dm/cpu.c          |  2 +-
 test/dm/devres.c       | 12 +++++------
 test/dm/dma.c          |  6 +++---
 test/dm/dsi_host.c     |  2 +-
 test/dm/eth.c          | 16 +++++++--------
 test/dm/fdtdec.c       |  2 +-
 test/dm/firmware.c     |  2 +-
 test/dm/gpio.c         | 16 +++++++--------
 test/dm/hwspinlock.c   |  2 +-
 test/dm/i2c.c          | 16 +++++++--------
 test/dm/i2s.c          |  2 +-
 test/dm/irq.c          |  8 ++++----
 test/dm/led.c          | 12 +++++------
 test/dm/mailbox.c      |  2 +-
 test/dm/mdio.c         |  2 +-
 test/dm/mdio_mux.c     |  2 +-
 test/dm/misc.c         |  2 +-
 test/dm/mmc.c          |  4 ++--
 test/dm/nop.c          |  2 +-
 test/dm/ofnode.c       | 12 +++++------
 test/dm/ofread.c       |  2 +-
 test/dm/osd.c          |  4 ++--
 test/dm/p2sb.c         |  2 +-
 test/dm/panel.c        |  2 +-
 test/dm/pch.c          |  4 ++--
 test/dm/pci.c          | 24 +++++++++++-----------
 test/dm/pci_ep.c       |  2 +-
 test/dm/phy.c          |  6 +++---
 test/dm/pmc.c          |  2 +-
 test/dm/pmic.c         | 10 ++++-----
 test/dm/power-domain.c |  2 +-
 test/dm/pwm.c          |  2 +-
 test/dm/ram.c          |  2 +-
 test/dm/regmap.c       | 10 ++++-----
 test/dm/regulator.c    | 20 +++++++++---------
 test/dm/remoteproc.c   |  4 ++--
 test/dm/reset.c        |  6 +++---
 test/dm/rng.c          |  2 +-
 test/dm/rtc.c          |  8 ++++----
 test/dm/serial.c       |  2 +-
 test/dm/sf.c           |  4 ++--
 test/dm/smem.c         |  2 +-
 test/dm/sound.c        |  4 ++--
 test/dm/spi.c          |  4 ++--
 test/dm/spmi.c         |  6 +++---
 test/dm/syscon.c       |  6 +++---
 test/dm/sysreset.c     |  8 ++++----
 test/dm/tee.c          |  2 +-
 test/dm/test-fdt.c     | 46 +++++++++++++++++++++---------------------
 test/dm/test-main.c    | 10 ++++-----
 test/dm/timer.c        |  2 +-
 test/dm/usb.c          | 10 ++++-----
 test/dm/video.c        | 26 ++++++++++++------------
 test/dm/virtio.c       |  8 ++++----
 test/dm/wdt.c          |  2 +-
 test/lib/lmb.c         | 18 ++++++++---------
 71 files changed, 271 insertions(+), 270 deletions(-)

Patch

diff --git a/doc/README.commands b/doc/README.commands
index 229f86d8fb..22ab063fdc 100644
--- a/doc/README.commands
+++ b/doc/README.commands
@@ -183,4 +183,4 @@  static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_cmd_items, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/include/dm/test.h b/include/dm/test.h
index f0f36624ce..3355f1bb68 100644
--- a/include/dm/test.h
+++ b/include/dm/test.h
@@ -147,15 +147,6 @@  struct dm_test_state {
 	struct udevice *removed;
 };
 
-/* Test flags for each test */
-enum {
-	DM_TESTF_SCAN_PDATA	= 1 << 0,	/* test needs platform data */
-	DM_TESTF_PROBE_TEST	= 1 << 1,	/* probe test uclass */
-	DM_TESTF_SCAN_FDT	= 1 << 2,	/* scan device tree */
-	DM_TESTF_FLAT_TREE	= 1 << 3,	/* test needs flat DT */
-	DM_TESTF_LIVE_TREE	= 1 << 4,	/* needs live device tree */
-};
-
 /* Declare a new driver model test */
 #define DM_TEST(_name, _flags)	UNIT_TEST(_name, _flags, dm_test)
 
diff --git a/include/test/test.h b/include/test/test.h
index 029288de88..ff92c39006 100644
--- a/include/test/test.h
+++ b/include/test/test.h
@@ -7,6 +7,7 @@ 
 #define __TEST_TEST_H
 
 #include <malloc.h>
+#include <linux/bitops.h>
 
 /*
  * struct unit_test_state - Entire state of test system
@@ -27,6 +28,15 @@  struct unit_test_state {
 	char actual_str[256];
 };
 
+/* Test flags for each test */
+enum {
+	UT_TESTF_SCAN_PDATA	= BIT(0),	/* test needs platform data */
+	UT_TESTF_PROBE_TEST	= BIT(1),	/* probe test uclass */
+	UT_TESTF_SCAN_FDT	= BIT(2),	/* scan device tree */
+	UT_TESTF_FLAT_TREE	= BIT(3),	/* test needs flat DT */
+	UT_TESTF_LIVE_TREE	= BIT(4),	/* needs live device tree */
+};
+
 /**
  * struct unit_test - Information about a unit test
  *
diff --git a/test/dm/acpi.c b/test/dm/acpi.c
index 4c46dd83a6..f0ec8dcc21 100644
--- a/test/dm/acpi.c
+++ b/test/dm/acpi.c
@@ -77,7 +77,7 @@  static int dm_test_acpi_get_name(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_get_name, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test acpi_get_table_revision() */
 static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
@@ -90,7 +90,7 @@  static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_acpi_get_table_revision,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test acpi_create_dmar() */
 static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
@@ -103,7 +103,7 @@  static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_create_dmar, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test acpi_fill_header() */
 static int dm_test_acpi_fill_header(struct unit_test_state *uts)
@@ -130,7 +130,7 @@  static int dm_test_acpi_fill_header(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test ACPI write_tables() */
 static int dm_test_acpi_write_tables(struct unit_test_state *uts)
@@ -168,7 +168,7 @@  static int dm_test_acpi_write_tables(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test basic ACPI functions */
 static int dm_test_acpi_basic(struct unit_test_state *uts)
@@ -196,7 +196,7 @@  static int dm_test_acpi_basic(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test acpi_setup_base_tables */
 static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
@@ -244,7 +244,7 @@  static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_acpi_setup_base_tables,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test 'acpi list' command */
 static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
@@ -283,7 +283,7 @@  static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_cmd_list, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test 'acpi dump' command */
 static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
@@ -314,4 +314,4 @@  static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_acpi_cmd_dump, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/adc.c b/test/dm/adc.c
index da7bd4bf1f..e7221a4159 100644
--- a/test/dm/adc.c
+++ b/test/dm/adc.c
@@ -32,7 +32,7 @@  static int dm_test_adc_bind(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_bind, UT_TESTF_SCAN_FDT);
 
 static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
 {
@@ -43,7 +43,7 @@  static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_wrong_channel_selection, UT_TESTF_SCAN_FDT);
 
 static int dm_test_adc_supply(struct unit_test_state *uts)
 {
@@ -79,7 +79,7 @@  static int dm_test_adc_supply(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_supply, UT_TESTF_SCAN_FDT);
 
 struct adc_channel adc_channel_test_data[] = {
 	{ 0, SANDBOX_ADC_CHANNEL0_DATA },
@@ -104,7 +104,7 @@  static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_single_channel_conversion, UT_TESTF_SCAN_FDT);
 
 static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
 {
@@ -127,7 +127,7 @@  static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_multi_channel_conversion, UT_TESTF_SCAN_FDT);
 
 static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
 {
@@ -143,7 +143,7 @@  static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_single_channel_shot, UT_TESTF_SCAN_FDT);
 
 static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
 {
@@ -163,7 +163,7 @@  static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_multi_channel_shot, UT_TESTF_SCAN_FDT);
 
 static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
 	((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
@@ -194,4 +194,4 @@  static int dm_test_adc_raw_to_uV(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_adc_raw_to_uV, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/audio.c b/test/dm/audio.c
index 77c3a3625b..1b192cb22e 100644
--- a/test/dm/audio.c
+++ b/test/dm/audio.c
@@ -31,4 +31,4 @@  static int dm_test_audio(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_audio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_audio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/axi.c b/test/dm/axi.c
index e1155a51dd..367620c0aa 100644
--- a/test/dm/axi.c
+++ b/test/dm/axi.c
@@ -22,7 +22,7 @@  static int dm_test_axi_base(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_axi_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_axi_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that sandbox PCI bus numbering works correctly */
 static int dm_test_axi_busnum(struct unit_test_state *uts)
@@ -34,7 +34,7 @@  static int dm_test_axi_busnum(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_axi_busnum, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_axi_busnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can use the store device correctly */
 static int dm_test_axi_store(struct unit_test_state *uts)
@@ -75,4 +75,4 @@  static int dm_test_axi_store(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_axi_store, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_axi_store, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/blk.c b/test/dm/blk.c
index 94b2855b8e..91473470be 100644
--- a/test/dm/blk.c
+++ b/test/dm/blk.c
@@ -42,7 +42,7 @@  static int dm_test_blk_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_blk_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_blk_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int count_blk_devices(void)
 {
@@ -88,7 +88,7 @@  static int dm_test_blk_usb(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_blk_usb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_blk_usb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can find block devices without probing them */
 static int dm_test_blk_find(struct unit_test_state *uts)
@@ -109,7 +109,7 @@  static int dm_test_blk_find(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_blk_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_blk_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that block device numbering works as expected */
 static int dm_test_blk_devnum(struct unit_test_state *uts)
@@ -144,7 +144,7 @@  static int dm_test_blk_devnum(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_blk_devnum, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_blk_devnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can get a block from its parent */
 static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
@@ -162,4 +162,4 @@  static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_blk_get_from_parent, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_blk_get_from_parent, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/board.c b/test/dm/board.c
index 5472c65fad..6925a671b6 100644
--- a/test/dm/board.c
+++ b/test/dm/board.c
@@ -55,4 +55,4 @@  static int dm_test_board(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_board, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_board, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/bootcount.c b/test/dm/bootcount.c
index be0c278907..57e98a46ca 100644
--- a/test/dm/bootcount.c
+++ b/test/dm/bootcount.c
@@ -27,5 +27,5 @@  static int dm_test_bootcount(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_bootcount, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bootcount, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
diff --git a/test/dm/bus.c b/test/dm/bus.c
index 73eb3aede3..73d3515f04 100644
--- a/test/dm/bus.c
+++ b/test/dm/bus.c
@@ -137,7 +137,7 @@  static int dm_test_bus_children(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_children, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test our functions for accessing children */
 static int dm_test_bus_children_funcs(struct unit_test_state *uts)
@@ -176,7 +176,7 @@  static int dm_test_bus_children_funcs(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_children_funcs, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
 {
@@ -200,7 +200,7 @@  static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_children_of_offset,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
 
 /* Test that we can iterate through children */
 static int dm_test_bus_children_iterators(struct unit_test_state *uts)
@@ -231,7 +231,7 @@  static int dm_test_bus_children_iterators(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_children_iterators,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that the bus can store data about each child */
 static int test_bus_parent_data(struct unit_test_state *uts)
@@ -298,7 +298,7 @@  static int dm_test_bus_parent_data(struct unit_test_state *uts)
 {
 	return test_bus_parent_data(uts);
 }
-DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_parent_data, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* As above but the size is controlled by the uclass */
 static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
@@ -328,7 +328,7 @@  static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_parent_data_uclass,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that the bus ops are called when a child is probed/removed */
 static int dm_test_bus_parent_ops(struct unit_test_state *uts)
@@ -367,7 +367,7 @@  static int dm_test_bus_parent_ops(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_parent_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int test_bus_parent_platdata(struct unit_test_state *uts)
 {
@@ -442,7 +442,7 @@  static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
 {
 	return test_bus_parent_platdata(uts);
 }
-DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_parent_platdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* As above but the size is controlled by the uclass */
 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
@@ -471,7 +471,7 @@  static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_parent_platdata_uclass,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that the child post_bind method is called */
 static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
@@ -492,7 +492,7 @@  static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_bus_child_post_bind, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that the child post_bind method is called */
 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
@@ -514,7 +514,7 @@  static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_child_post_bind_uclass,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /*
  * Test that the bus' uclass' child_pre_probe() is called before the
@@ -548,7 +548,7 @@  static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_child_pre_probe_uclass,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /*
  * Test that the bus' uclass' child_post_probe() is called after the
@@ -581,4 +581,4 @@  static int dm_test_bus_child_post_probe_uclass(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_bus_child_post_probe_uclass,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/cache.c b/test/dm/cache.c
index 2e244b109f..bbd8f98d00 100644
--- a/test/dm/cache.c
+++ b/test/dm/cache.c
@@ -19,4 +19,4 @@  static int dm_test_reset(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_reset, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/clk.c b/test/dm/clk.c
index 48fc3dd714..6fee770e93 100644
--- a/test/dm/clk.c
+++ b/test/dm/clk.c
@@ -33,7 +33,7 @@  static int dm_test_clk_base(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_clk_base, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_clk_base, UT_TESTF_SCAN_FDT);
 
 static int dm_test_clk(struct unit_test_state *uts)
 {
@@ -160,7 +160,7 @@  static int dm_test_clk(struct unit_test_state *uts)
 						   SANDBOX_CLK_ID_UART1));
 	return 0;
 }
-DM_TEST(dm_test_clk, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_clk, UT_TESTF_SCAN_FDT);
 
 static int dm_test_clk_bulk(struct unit_test_state *uts)
 {
@@ -198,4 +198,4 @@  static int dm_test_clk_bulk(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_clk_bulk, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_clk_bulk, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/clk_ccf.c b/test/dm/clk_ccf.c
index ae3a4d8a76..f822761f7a 100644
--- a/test/dm/clk_ccf.c
+++ b/test/dm/clk_ccf.c
@@ -95,4 +95,4 @@  static int dm_test_clk_ccf(struct unit_test_state *uts)
 	return 1;
 }
 
-DM_TEST(dm_test_clk_ccf, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_clk_ccf, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/core.c b/test/dm/core.c
index 6a930ae31a..a496dcd149 100644
--- a/test/dm/core.c
+++ b/test/dm/core.c
@@ -166,7 +166,7 @@  static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_autobind_uclass_pdata_alloc, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA);
 
 /* Test that binding with uclass platdata setting occurs correctly */
 static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
@@ -192,7 +192,7 @@  static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_autobind_uclass_pdata_valid, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_autobind_uclass_pdata_valid, UT_TESTF_SCAN_PDATA);
 
 /* Test that autoprobe finds all the expected devices */
 static int dm_test_autoprobe(struct unit_test_state *uts)
@@ -260,7 +260,7 @@  static int dm_test_autoprobe(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_autoprobe, UT_TESTF_SCAN_PDATA);
 
 /* Check that we see the correct platdata in each device */
 static int dm_test_platdata(struct unit_test_state *uts)
@@ -278,7 +278,7 @@  static int dm_test_platdata(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_platdata, UT_TESTF_SCAN_PDATA);
 
 /* Test that we can bind, probe, remove, unbind a driver */
 static int dm_test_lifecycle(struct unit_test_state *uts)
@@ -334,7 +334,7 @@  static int dm_test_lifecycle(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
+DM_TEST(dm_test_lifecycle, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
 
 /* Test that we can bind/unbind and the lists update correctly */
 static int dm_test_ordering(struct unit_test_state *uts)
@@ -390,7 +390,7 @@  static int dm_test_ordering(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_ordering, UT_TESTF_SCAN_PDATA);
 
 /* Check that we can perform operations on a device (do a ping) */
 int dm_check_operations(struct unit_test_state *uts, struct udevice *dev,
@@ -448,7 +448,7 @@  static int dm_test_operations(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_operations, UT_TESTF_SCAN_PDATA);
 
 /* Remove all drivers and check that things work */
 static int dm_test_remove(struct unit_test_state *uts)
@@ -470,7 +470,7 @@  static int dm_test_remove(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
+DM_TEST(dm_test_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
 
 /* Remove and recreate everything, check for memory leaks */
 static int dm_test_leak(struct unit_test_state *uts)
@@ -755,7 +755,7 @@  static int dm_test_uclass_devices_find(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_devices_find, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_uclass_devices_find, UT_TESTF_SCAN_PDATA);
 
 static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
 {
@@ -792,7 +792,7 @@  static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_devices_find_by_name, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_uclass_devices_find_by_name, UT_TESTF_SCAN_FDT);
 
 static int dm_test_uclass_devices_get(struct unit_test_state *uts)
 {
@@ -809,7 +809,7 @@  static int dm_test_uclass_devices_get(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_devices_get, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_uclass_devices_get, UT_TESTF_SCAN_PDATA);
 
 static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
 {
@@ -853,7 +853,7 @@  static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_devices_get_by_name, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_uclass_devices_get_by_name, UT_TESTF_SCAN_FDT);
 
 static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
 {
@@ -864,7 +864,7 @@  static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_device_get_uclass_id, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_device_get_uclass_id, UT_TESTF_SCAN_PDATA);
 
 static int dm_test_uclass_names(struct unit_test_state *uts)
 {
@@ -873,7 +873,7 @@  static int dm_test_uclass_names(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_names, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_uclass_names, UT_TESTF_SCAN_PDATA);
 
 static int dm_test_inactive_child(struct unit_test_state *uts)
 {
@@ -904,4 +904,4 @@  static int dm_test_inactive_child(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_inactive_child, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_inactive_child, UT_TESTF_SCAN_PDATA);
diff --git a/test/dm/cpu.c b/test/dm/cpu.c
index 46683d884a..bda5b71b6d 100644
--- a/test/dm/cpu.c
+++ b/test/dm/cpu.c
@@ -46,4 +46,4 @@  static int dm_test_cpu(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_cpu, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_cpu, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/devres.c b/test/dm/devres.c
index b5de0cb191..9eb9a67d5a 100644
--- a/test/dm/devres.c
+++ b/test/dm/devres.c
@@ -40,7 +40,7 @@  static int dm_test_devres_alloc(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_alloc, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_devres_alloc, UT_TESTF_SCAN_PDATA);
 
 /* Test devm_kfree() can be used to free memory too */
 static int dm_test_devres_free(struct unit_test_state *uts)
@@ -68,7 +68,7 @@  static int dm_test_devres_free(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_free, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_devres_free, UT_TESTF_SCAN_PDATA);
 
 
 /* Test that kzalloc() returns memory that is zeroed */
@@ -88,7 +88,7 @@  static int dm_test_devres_kzalloc(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_kzalloc, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_devres_kzalloc, UT_TESTF_SCAN_PDATA);
 
 /* Test that devm_kmalloc_array() allocates an array that can be set */
 static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
@@ -111,7 +111,7 @@  static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_kmalloc_array, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_devres_kmalloc_array, UT_TESTF_SCAN_PDATA);
 
 /* Test that devm_kcalloc() allocates a zeroed array */
 static int dm_test_devres_kcalloc(struct unit_test_state *uts)
@@ -140,7 +140,7 @@  static int dm_test_devres_kcalloc(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_kcalloc, DM_TESTF_SCAN_PDATA);
+DM_TEST(dm_test_devres_kcalloc, UT_TESTF_SCAN_PDATA);
 
 /* Test devres releases resources automatically as expected */
 static int dm_test_devres_phase(struct unit_test_state *uts)
@@ -185,4 +185,4 @@  static int dm_test_devres_phase(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_devres_phase, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_devres_phase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/dma.c b/test/dm/dma.c
index 317ed4fe8c..51987a2f0b 100644
--- a/test/dm/dma.c
+++ b/test/dm/dma.c
@@ -34,7 +34,7 @@  static int dm_test_dma_m2m(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_dma_m2m, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_dma_m2m, UT_TESTF_SCAN_FDT);
 
 static int dm_test_dma(struct unit_test_state *uts)
 {
@@ -76,7 +76,7 @@  static int dm_test_dma(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_dma, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_dma, UT_TESTF_SCAN_FDT);
 
 static int dm_test_dma_rx(struct unit_test_state *uts)
 {
@@ -121,4 +121,4 @@  static int dm_test_dma_rx(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_dma_rx, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_dma_rx, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/dsi_host.c b/test/dm/dsi_host.c
index 59fcd5558f..05c5275dcb 100644
--- a/test/dm/dsi_host.c
+++ b/test/dm/dsi_host.c
@@ -55,4 +55,4 @@  static int dm_test_dsi_host(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_dsi_host, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_dsi_host, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/eth.c b/test/dm/eth.c
index 1fddcaabb0..c29a1febd6 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -39,7 +39,7 @@  static int dm_test_eth(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth, UT_TESTF_SCAN_FDT);
 
 static int dm_test_eth_alias(struct unit_test_state *uts)
 {
@@ -63,7 +63,7 @@  static int dm_test_eth_alias(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_alias, UT_TESTF_SCAN_FDT);
 
 static int dm_test_eth_prime(struct unit_test_state *uts)
 {
@@ -83,7 +83,7 @@  static int dm_test_eth_prime(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_prime, UT_TESTF_SCAN_FDT);
 
 /**
  * This test case is trying to test the following scenario:
@@ -144,7 +144,7 @@  static int dm_test_eth_act(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_act, UT_TESTF_SCAN_FDT);
 
 /* The asserts include a return on fail; cleanup in the caller */
 static int _dm_test_eth_rotate1(struct unit_test_state *uts)
@@ -216,7 +216,7 @@  static int dm_test_eth_rotate(struct unit_test_state *uts)
 
 	return retval;
 }
-DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_rotate, UT_TESTF_SCAN_FDT);
 
 /* The asserts include a return on fail; cleanup in the caller */
 static int _dm_test_net_retry(struct unit_test_state *uts)
@@ -259,7 +259,7 @@  static int dm_test_net_retry(struct unit_test_state *uts)
 
 	return retval;
 }
-DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_net_retry, UT_TESTF_SCAN_FDT);
 
 static int sb_check_arp_reply(struct udevice *dev, void *packet,
 			      unsigned int len)
@@ -344,7 +344,7 @@  static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_eth_async_arp_reply, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_async_arp_reply, UT_TESTF_SCAN_FDT);
 
 static int sb_check_ping_reply(struct udevice *dev, void *packet,
 			       unsigned int len)
@@ -429,4 +429,4 @@  static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_eth_async_ping_reply, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_eth_async_ping_reply, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/fdtdec.c b/test/dm/fdtdec.c
index b2f75b5843..79dda43ba0 100644
--- a/test/dm/fdtdec.c
+++ b/test/dm/fdtdec.c
@@ -56,4 +56,4 @@  static int dm_test_fdtdec_set_carveout(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdtdec_set_carveout,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
diff --git a/test/dm/firmware.c b/test/dm/firmware.c
index 60fdcbb33f..9a5b288833 100644
--- a/test/dm/firmware.c
+++ b/test/dm/firmware.c
@@ -19,4 +19,4 @@  static int dm_test_firmware_probe(struct unit_test_state *uts)
 					      "sandbox-firmware", &dev));
 	return 0;
 }
-DM_TEST(dm_test_firmware_probe, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_firmware_probe, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/gpio.c b/test/dm/gpio.c
index b5ee4e4f87..11f81944ed 100644
--- a/test/dm/gpio.c
+++ b/test/dm/gpio.c
@@ -111,7 +111,7 @@  static int dm_test_gpio(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that GPIO open-drain/open-source emulation works correctly */
 static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
@@ -200,7 +200,7 @@  static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_gpio_opendrain_opensource,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that sandbox anonymous GPIOs work correctly */
 static int dm_test_gpio_anon(struct unit_test_state *uts)
@@ -222,7 +222,7 @@  static int dm_test_gpio_anon(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_anon, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_anon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that gpio_requestf() works as expected */
 static int dm_test_gpio_requestf(struct unit_test_state *uts)
@@ -240,7 +240,7 @@  static int dm_test_gpio_requestf(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_requestf, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_requestf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that gpio_request() copies its string */
 static int dm_test_gpio_copy(struct unit_test_state *uts)
@@ -262,7 +262,7 @@  static int dm_test_gpio_copy(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_copy, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we don't leak memory with GPIOs */
 static int dm_test_gpio_leak(struct unit_test_state *uts)
@@ -274,7 +274,7 @@  static int dm_test_gpio_leak(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_leak, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_leak, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can find GPIOs using phandles */
 static int dm_test_gpio_phandles(struct unit_test_state *uts)
@@ -348,7 +348,7 @@  static int dm_test_gpio_phandles(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_phandles, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_phandles, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Check the gpio pin configuration get from device tree information */
 static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
@@ -384,4 +384,4 @@  static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_gpio_get_dir_flags, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_gpio_get_dir_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/hwspinlock.c b/test/dm/hwspinlock.c
index 09ec38b4f3..9c1bdf4c34 100644
--- a/test/dm/hwspinlock.c
+++ b/test/dm/hwspinlock.c
@@ -37,4 +37,4 @@  static int dm_test_hwspinlock_base(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_hwspinlock_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_hwspinlock_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/i2c.c b/test/dm/i2c.c
index 2025c4216d..16890a7da5 100644
--- a/test/dm/i2c.c
+++ b/test/dm/i2c.c
@@ -41,7 +41,7 @@  static int dm_test_i2c_find(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_read_write(struct unit_test_state *uts)
 {
@@ -58,7 +58,7 @@  static int dm_test_i2c_read_write(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_read_write, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_speed(struct unit_test_state *uts)
 {
@@ -80,7 +80,7 @@  static int dm_test_i2c_speed(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_speed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_speed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_offset_len(struct unit_test_state *uts)
 {
@@ -97,7 +97,7 @@  static int dm_test_i2c_offset_len(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_offset_len, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_offset_len, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
 {
@@ -112,7 +112,7 @@  static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_probe_empty, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_probe_empty, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_bytewise(struct unit_test_state *uts)
 {
@@ -167,7 +167,7 @@  static int dm_test_i2c_bytewise(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_bytewise, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_bytewise, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_offset(struct unit_test_state *uts)
 {
@@ -240,7 +240,7 @@  static int dm_test_i2c_offset(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2c_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
 {
@@ -305,4 +305,4 @@  static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_i2c_addr_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2c_addr_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/i2s.c b/test/dm/i2s.c
index 49ebc3523c..87c301becb 100644
--- a/test/dm/i2s.c
+++ b/test/dm/i2s.c
@@ -29,4 +29,4 @@  static int dm_test_i2s(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_i2s, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_i2s, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/irq.c b/test/dm/irq.c
index 192d80d7e1..f6d6f7617a 100644
--- a/test/dm/irq.c
+++ b/test/dm/irq.c
@@ -30,7 +30,7 @@  static int dm_test_irq_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_irq_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_irq_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of irq_first_device_type() */
 static int dm_test_irq_type(struct unit_test_state *uts)
@@ -42,7 +42,7 @@  static int dm_test_irq_type(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_irq_type, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_irq_type, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of irq_read_and_clear() */
 static int dm_test_read_and_clear(struct unit_test_state *uts)
@@ -59,7 +59,7 @@  static int dm_test_read_and_clear(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_read_and_clear, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_read_and_clear, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of irq_request() */
 static int dm_test_request(struct unit_test_state *uts)
@@ -74,4 +74,4 @@  static int dm_test_request(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_request, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_request, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/led.c b/test/dm/led.c
index 00de7b3997..d00b1685a0 100644
--- a/test/dm/led.c
+++ b/test/dm/led.c
@@ -25,7 +25,7 @@  static int dm_test_led_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of the LED 'default-state' device tree property */
 static int dm_test_led_default_state(struct unit_test_state *uts)
@@ -44,7 +44,7 @@  static int dm_test_led_default_state(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_default_state, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_default_state, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of the led uclass using the led_gpio driver */
 static int dm_test_led_gpio(struct unit_test_state *uts)
@@ -69,7 +69,7 @@  static int dm_test_led_gpio(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can toggle LEDs */
 static int dm_test_led_toggle(struct unit_test_state *uts)
@@ -94,7 +94,7 @@  static int dm_test_led_toggle(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_toggle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_toggle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test obtaining an LED by label */
 static int dm_test_led_label(struct unit_test_state *uts)
@@ -115,7 +115,7 @@  static int dm_test_led_label(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_label, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_label, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test LED blinking */
 #ifdef CONFIG_LED_BLINK
@@ -138,5 +138,5 @@  static int dm_test_led_blink(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_led_blink, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_led_blink, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 #endif
diff --git a/test/dm/mailbox.c b/test/dm/mailbox.c
index e6c521b8b5..03b50449eb 100644
--- a/test/dm/mailbox.c
+++ b/test/dm/mailbox.c
@@ -28,4 +28,4 @@  static int dm_test_mailbox(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_mailbox, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_mailbox, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/mdio.c b/test/dm/mdio.c
index ba1b54f27e..067ec65acc 100644
--- a/test/dm/mdio.c
+++ b/test/dm/mdio.c
@@ -54,4 +54,4 @@  static int dm_test_mdio(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_mdio, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_mdio, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/mdio_mux.c b/test/dm/mdio_mux.c
index f962e09dbc..dc954a0fd5 100644
--- a/test/dm/mdio_mux.c
+++ b/test/dm/mdio_mux.c
@@ -77,4 +77,4 @@  static int dm_test_mdio_mux(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_mdio_mux, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_mdio_mux, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/misc.c b/test/dm/misc.c
index 26fd6acecb..c1ed68d407 100644
--- a/test/dm/misc.c
+++ b/test/dm/misc.c
@@ -80,4 +80,4 @@  static int dm_test_misc(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_misc, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_misc, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/mmc.c b/test/dm/mmc.c
index 49402b9c90..b789c6b225 100644
--- a/test/dm/mmc.c
+++ b/test/dm/mmc.c
@@ -22,7 +22,7 @@  static int dm_test_mmc_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_mmc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_mmc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_mmc_blk(struct unit_test_state *uts)
 {
@@ -41,4 +41,4 @@  static int dm_test_mmc_blk(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_mmc_blk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_mmc_blk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/nop.c b/test/dm/nop.c
index 2df29f3d15..7da951a42a 100644
--- a/test/dm/nop.c
+++ b/test/dm/nop.c
@@ -70,4 +70,4 @@  static int dm_test_nop(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_nop, DM_TESTF_FLAT_TREE | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_nop, UT_TESTF_FLAT_TREE | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/ofnode.c b/test/dm/ofnode.c
index 1114f34cbf..953919fe66 100644
--- a/test/dm/ofnode.c
+++ b/test/dm/ofnode.c
@@ -16,7 +16,7 @@  static int dm_test_ofnode_compatible(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofnode_compatible, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofnode_compatible, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
 {
@@ -43,7 +43,7 @@  static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofnode_by_prop_value, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofnode_by_prop_value, UT_TESTF_SCAN_FDT);
 
 static int dm_test_ofnode_fmap(struct unit_test_state *uts)
 {
@@ -58,7 +58,7 @@  static int dm_test_ofnode_fmap(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofnode_fmap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofnode_fmap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_ofnode_read(struct unit_test_state *uts)
 {
@@ -84,7 +84,7 @@  static int dm_test_ofnode_read(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofnode_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofnode_read, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
 {
@@ -113,7 +113,7 @@  static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofnode_read_chosen, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofnode_read_chosen, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
 {
@@ -134,4 +134,4 @@  static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_ofnode_get_child_count,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/ofread.c b/test/dm/ofread.c
index f2a1382259..9064426e21 100644
--- a/test/dm/ofread.c
+++ b/test/dm/ofread.c
@@ -47,4 +47,4 @@  static int dm_test_ofnode_get_property_by_prop(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_ofnode_get_property_by_prop,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/osd.c b/test/dm/osd.c
index 5739dfa0b8..afe6ea15c0 100644
--- a/test/dm/osd.c
+++ b/test/dm/osd.c
@@ -131,7 +131,7 @@  static int dm_test_osd_basics(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_osd_basics, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_osd_basics, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_osd_extended(struct unit_test_state *uts)
 {
@@ -215,4 +215,4 @@  static int dm_test_osd_extended(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_osd_extended, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_osd_extended, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/p2sb.c b/test/dm/p2sb.c
index ccb75cf375..df24709141 100644
--- a/test/dm/p2sb.c
+++ b/test/dm/p2sb.c
@@ -25,4 +25,4 @@  static int dm_test_p2sb_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_p2sb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_p2sb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/panel.c b/test/dm/panel.c
index 7e4ebd6d81..8226cc43c8 100644
--- a/test/dm/panel.c
+++ b/test/dm/panel.c
@@ -76,4 +76,4 @@  static int dm_test_panel(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_panel, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_panel, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/pch.c b/test/dm/pch.c
index 54e33d187b..afe75e7251 100644
--- a/test/dm/pch.c
+++ b/test/dm/pch.c
@@ -33,7 +33,7 @@  static int dm_test_pch_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pch_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pch_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test sandbox PCH ioctl */
 static int dm_test_pch_ioctl(struct unit_test_state *uts)
@@ -52,4 +52,4 @@  static int dm_test_pch_ioctl(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pch_ioctl, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pch_ioctl, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/pci.c b/test/dm/pci.c
index fb93e4c78a..222e8a23ee 100644
--- a/test/dm/pci.c
+++ b/test/dm/pci.c
@@ -19,7 +19,7 @@  static int dm_test_pci_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that sandbox PCI bus numbering and device works correctly */
 static int dm_test_pci_busdev(struct unit_test_state *uts)
@@ -54,7 +54,7 @@  static int dm_test_pci_busdev(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_busdev, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_busdev, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can use the swapcase device correctly */
 static int dm_test_pci_swapcase(struct unit_test_state *uts)
@@ -107,7 +107,7 @@  static int dm_test_pci_swapcase(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_swapcase, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_swapcase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can dynamically bind the device driver correctly */
 static int dm_test_pci_drvdata(struct unit_test_state *uts)
@@ -129,7 +129,7 @@  static int dm_test_pci_drvdata(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that devices on PCI bus#2 can be accessed correctly */
 static int dm_test_pci_mixed(struct unit_test_state *uts)
@@ -192,7 +192,7 @@  static int dm_test_pci_mixed(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_mixed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_mixed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test looking up PCI capability and extended capability */
 static int dm_test_pci_cap(struct unit_test_state *uts)
@@ -244,7 +244,7 @@  static int dm_test_pci_cap(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_cap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test looking up BARs in EA capability structure */
 static int dm_test_pci_ea(struct unit_test_state *uts)
@@ -293,7 +293,7 @@  static int dm_test_pci_ea(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_ea, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_ea, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test the dev_read_addr_pci() function */
 static int dm_test_pci_addr_flat(struct unit_test_state *uts)
@@ -315,14 +315,14 @@  static int dm_test_pci_addr_flat(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_addr_flat, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT |
-		DM_TESTF_FLAT_TREE);
+DM_TEST(dm_test_pci_addr_flat, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
+		UT_TESTF_FLAT_TREE);
 
 /*
  * Test the dev_read_addr_pci() function with livetree. That function is
  * not currently fully implemented, in that it fails to return the BAR address.
  * Once that is implemented this test can be removed and dm_test_pci_addr_flat()
- * can be used for both flattree and livetree by removing the DM_TESTF_FLAT_TREE
+ * can be used for both flattree and livetree by removing the UT_TESTF_FLAT_TREE
  * flag above.
  */
 static int dm_test_pci_addr_live(struct unit_test_state *uts)
@@ -337,5 +337,5 @@  static int dm_test_pci_addr_live(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pci_addr_live, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT |
-		DM_TESTF_LIVE_TREE);
+DM_TEST(dm_test_pci_addr_live, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
+		UT_TESTF_LIVE_TREE);
diff --git a/test/dm/pci_ep.c b/test/dm/pci_ep.c
index 101f861751..663766d9c6 100644
--- a/test/dm/pci_ep.c
+++ b/test/dm/pci_ep.c
@@ -60,5 +60,5 @@  static int dm_test_pci_ep_base(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_pci_ep_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pci_ep_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
diff --git a/test/dm/phy.c b/test/dm/phy.c
index 99f0119557..5f1fae5237 100644
--- a/test/dm/phy.c
+++ b/test/dm/phy.c
@@ -52,7 +52,7 @@  static int dm_test_phy_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_phy_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_phy_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of the phy uclass using the sandbox phy driver operations */
 static int dm_test_phy_ops(struct unit_test_state *uts)
@@ -110,7 +110,7 @@  static int dm_test_phy_ops(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_phy_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_phy_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_phy_bulk(struct unit_test_state *uts)
 {
@@ -143,4 +143,4 @@  static int dm_test_phy_bulk(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_phy_bulk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_phy_bulk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/pmc.c b/test/dm/pmc.c
index 1a222838ab..e70227e780 100644
--- a/test/dm/pmc.c
+++ b/test/dm/pmc.c
@@ -30,4 +30,4 @@  static int dm_test_pmc_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pmc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pmc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/pmic.c b/test/dm/pmic.c
index b582329a9c..c9719d8c3a 100644
--- a/test/dm/pmic.c
+++ b/test/dm/pmic.c
@@ -43,7 +43,7 @@  static int dm_test_power_pmic_get(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_pmic_get, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_pmic_get, UT_TESTF_SCAN_FDT);
 
 /* PMIC get method - MC34708 - for 3 bytes transmission */
 static int dm_test_power_pmic_mc34708_get(struct unit_test_state *uts)
@@ -53,7 +53,7 @@  static int dm_test_power_pmic_mc34708_get(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_power_pmic_mc34708_get, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_pmic_mc34708_get, UT_TESTF_SCAN_FDT);
 
 /* Test PMIC I/O */
 static int dm_test_power_pmic_io(struct unit_test_state *uts)
@@ -82,7 +82,7 @@  static int dm_test_power_pmic_io(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_pmic_io, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_pmic_io, UT_TESTF_SCAN_FDT);
 
 #define MC34708_PMIC_REG_COUNT 64
 #define MC34708_PMIC_TEST_VAL 0x125534
@@ -100,7 +100,7 @@  static int dm_test_power_pmic_mc34708_regs_check(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_power_pmic_mc34708_regs_check, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_pmic_mc34708_regs_check, UT_TESTF_SCAN_FDT);
 
 static int dm_test_power_pmic_mc34708_rw_val(struct unit_test_state *uts)
 {
@@ -127,4 +127,4 @@  static int dm_test_power_pmic_mc34708_rw_val(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_power_pmic_mc34708_rw_val, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_pmic_mc34708_rw_val, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/power-domain.c b/test/dm/power-domain.c
index 8baf5d09d1..2dc9143096 100644
--- a/test/dm/power-domain.c
+++ b/test/dm/power-domain.c
@@ -45,4 +45,4 @@  static int dm_test_power_domain(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_domain, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_domain, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/pwm.c b/test/dm/pwm.c
index b52ee21a69..99dd9e68f2 100644
--- a/test/dm/pwm.c
+++ b/test/dm/pwm.c
@@ -28,4 +28,4 @@  static int dm_test_pwm_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_pwm_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_pwm_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/ram.c b/test/dm/ram.c
index 3efdb6b80b..ff17a03e68 100644
--- a/test/dm/ram.c
+++ b/test/dm/ram.c
@@ -24,4 +24,4 @@  static int dm_test_ram_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ram_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ram_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/regmap.c b/test/dm/regmap.c
index 809494d585..0586cae700 100644
--- a/test/dm/regmap.c
+++ b/test/dm/regmap.c
@@ -66,7 +66,7 @@  static int dm_test_regmap_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_regmap_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_regmap_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test we can access a regmap through syscon */
 static int dm_test_regmap_syscon(struct unit_test_state *uts)
@@ -92,7 +92,7 @@  static int dm_test_regmap_syscon(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_regmap_syscon, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_regmap_syscon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Read/Write/Modify test */
 static int dm_test_regmap_rw(struct unit_test_state *uts)
@@ -126,7 +126,7 @@  static int dm_test_regmap_rw(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_regmap_rw, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_regmap_rw, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Get/Set test */
 static int dm_test_regmap_getset(struct unit_test_state *uts)
@@ -157,7 +157,7 @@  static int dm_test_regmap_getset(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_regmap_getset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_regmap_getset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Read polling test */
 static int dm_test_regmap_poll(struct unit_test_state *uts)
@@ -185,4 +185,4 @@  static int dm_test_regmap_poll(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_regmap_poll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_regmap_poll, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/regulator.c b/test/dm/regulator.c
index ca916eeebb..cc2aa09382 100644
--- a/test/dm/regulator.c
+++ b/test/dm/regulator.c
@@ -89,7 +89,7 @@  static int dm_test_power_regulator_get(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_get, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_get, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get Voltage method */
 static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
@@ -116,7 +116,7 @@  static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_voltage, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_voltage, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get Current method */
 static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
@@ -155,7 +155,7 @@  static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_current, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_current, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get Enable method */
 static int dm_test_power_regulator_set_get_enable(struct unit_test_state *uts)
@@ -174,7 +174,7 @@  static int dm_test_power_regulator_set_get_enable(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_enable, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_enable, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get enable if allowed method */
 static
@@ -195,7 +195,7 @@  int dm_test_power_regulator_set_enable_if_allowed(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_enable_if_allowed, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_enable_if_allowed, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get mode method */
 static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
@@ -214,7 +214,7 @@  static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_mode, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_mode, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get suspend Voltage method */
 static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_state *uts)
@@ -244,7 +244,7 @@  static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_stat
 	}
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_suspend_voltage, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_suspend_voltage, UT_TESTF_SCAN_FDT);
 
 /* Test regulator set and get suspend Enable method */
 static int dm_test_power_regulator_set_get_suspend_enable(struct unit_test_state *uts)
@@ -271,7 +271,7 @@  static int dm_test_power_regulator_set_get_suspend_enable(struct unit_test_state
 	}
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_set_get_suspend_enable, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_set_get_suspend_enable, UT_TESTF_SCAN_FDT);
 
 /* Test regulator autoset method */
 static int dm_test_power_regulator_autoset(struct unit_test_state *uts)
@@ -304,7 +304,7 @@  static int dm_test_power_regulator_autoset(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_autoset, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_autoset, UT_TESTF_SCAN_FDT);
 
 /*
  * Struct setting: to keep the expected output settings.
@@ -400,4 +400,4 @@  static int dm_test_power_regulator_autoset_list(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_power_regulator_autoset_list, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_power_regulator_autoset_list, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/remoteproc.c b/test/dm/remoteproc.c
index 9511c7dd6f..0c3b960dd7 100644
--- a/test/dm/remoteproc.c
+++ b/test/dm/remoteproc.c
@@ -66,7 +66,7 @@  static int dm_test_remoteproc_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_remoteproc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_remoteproc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 #define DEVICE_TO_PHYSICAL_OFFSET	0x1000
 /**
@@ -254,4 +254,4 @@  static int dm_test_remoteproc_elf(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_remoteproc_elf, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_remoteproc_elf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/reset.c b/test/dm/reset.c
index 871d6400a0..42bffc26d2 100644
--- a/test/dm/reset.c
+++ b/test/dm/reset.c
@@ -38,7 +38,7 @@  static int dm_test_reset_base(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_reset_base, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_reset_base, UT_TESTF_SCAN_FDT);
 
 static int dm_test_reset(struct unit_test_state *uts)
 {
@@ -63,7 +63,7 @@  static int dm_test_reset(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_reset, UT_TESTF_SCAN_FDT);
 
 static int dm_test_reset_bulk(struct unit_test_state *uts)
 {
@@ -93,4 +93,4 @@  static int dm_test_reset_bulk(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_reset_bulk, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_reset_bulk, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/rng.c b/test/dm/rng.c
index 583ce9eddf..5b34c93ed6 100644
--- a/test/dm/rng.c
+++ b/test/dm/rng.c
@@ -24,4 +24,4 @@  static int dm_test_rng_read(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_rng_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_rng_read, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/rtc.c b/test/dm/rtc.c
index 88f86581cc..f7ddcdc068 100644
--- a/test/dm/rtc.c
+++ b/test/dm/rtc.c
@@ -25,7 +25,7 @@  static int dm_test_rtc_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_rtc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_rtc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static void show_time(const char *msg, struct rtc_time *time)
 {
@@ -115,7 +115,7 @@  static int dm_test_rtc_set_get(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_rtc_set_get, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_rtc_set_get, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Reset the time */
 static int dm_test_rtc_reset(struct unit_test_state *uts)
@@ -141,7 +141,7 @@  static int dm_test_rtc_reset(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_rtc_reset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_rtc_reset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Check that two RTC devices can be used independently */
 static int dm_test_rtc_dual(struct unit_test_state *uts)
@@ -173,4 +173,4 @@  static int dm_test_rtc_dual(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_rtc_dual, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_rtc_dual, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/serial.c b/test/dm/serial.c
index 6237693cb8..407bf3b63f 100644
--- a/test/dm/serial.c
+++ b/test/dm/serial.c
@@ -68,4 +68,4 @@  static int dm_test_serial(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(dm_test_serial, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_serial, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/sf.c b/test/dm/sf.c
index 9e7dead684..4d09993ed7 100644
--- a/test/dm/sf.c
+++ b/test/dm/sf.c
@@ -64,7 +64,7 @@  static int dm_test_spi_flash(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spi_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spi_flash, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Functional test that sandbox SPI flash works correctly */
 static int dm_test_spi_flash_func(struct unit_test_state *uts)
@@ -92,4 +92,4 @@  static int dm_test_spi_flash_func(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spi_flash_func, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spi_flash_func, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/smem.c b/test/dm/smem.c
index 4099a5f66c..e7387a2432 100644
--- a/test/dm/smem.c
+++ b/test/dm/smem.c
@@ -23,5 +23,5 @@  static int dm_test_smem_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_smem_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_smem_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
diff --git a/test/dm/sound.c b/test/dm/sound.c
index aa5368f05b..6af1f3a559 100644
--- a/test/dm/sound.c
+++ b/test/dm/sound.c
@@ -32,7 +32,7 @@  static int dm_test_sound(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sound, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sound, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of the 'start beep' operations */
 static int dm_test_sound_beep(struct unit_test_state *uts)
@@ -53,4 +53,4 @@  static int dm_test_sound_beep(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sound_beep, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sound_beep, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/spi.c b/test/dm/spi.c
index 8e417acc5f..b415f084f0 100644
--- a/test/dm/spi.c
+++ b/test/dm/spi.c
@@ -91,7 +91,7 @@  static int dm_test_spi_find(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spi_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spi_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that sandbox SPI works correctly */
 static int dm_test_spi_xfer(struct unit_test_state *uts)
@@ -123,4 +123,4 @@  static int dm_test_spi_xfer(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spi_xfer, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spi_xfer, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/spmi.c b/test/dm/spmi.c
index 668b7e133f..53a6bd2fd8 100644
--- a/test/dm/spmi.c
+++ b/test/dm/spmi.c
@@ -43,7 +43,7 @@  static int dm_test_spmi_probe(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spmi_probe, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spmi_probe, UT_TESTF_SCAN_FDT);
 
 /* Test if it's possible to read bus directly and indirectly */
 static int dm_test_spmi_access(struct unit_test_state *uts)
@@ -68,7 +68,7 @@  static int dm_test_spmi_access(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spmi_access, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spmi_access, UT_TESTF_SCAN_FDT);
 
 
 /* Test if it's possible to access GPIO that should be in pmic */
@@ -109,4 +109,4 @@  static int dm_test_spmi_access_peripheral(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_spmi_access_peripheral, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_spmi_access_peripheral, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/syscon.c b/test/dm/syscon.c
index 06a1c69ac5..dbc45ebfa1 100644
--- a/test/dm/syscon.c
+++ b/test/dm/syscon.c
@@ -28,7 +28,7 @@  static int dm_test_syscon_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_syscon_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_syscon_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test system controller finding */
 static int dm_test_syscon_by_driver_data(struct unit_test_state *uts)
@@ -45,7 +45,7 @@  static int dm_test_syscon_by_driver_data(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_syscon_by_driver_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_syscon_by_driver_data, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test system controller by phandle */
 static int dm_test_syscon_by_phandle(struct unit_test_state *uts)
@@ -80,4 +80,4 @@  static int dm_test_syscon_by_phandle(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_syscon_by_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_syscon_by_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/sysreset.c b/test/dm/sysreset.c
index 5b2358ef67..a230cd8dc4 100644
--- a/test/dm/sysreset.c
+++ b/test/dm/sysreset.c
@@ -43,7 +43,7 @@  static int dm_test_sysreset_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sysreset_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sysreset_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_sysreset_get_status(struct unit_test_state *uts)
 {
@@ -62,7 +62,7 @@  static int dm_test_sysreset_get_status(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sysreset_get_status, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sysreset_get_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can walk through the sysreset devices */
 static int dm_test_sysreset_walk(struct unit_test_state *uts)
@@ -90,7 +90,7 @@  static int dm_test_sysreset_walk(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sysreset_walk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sysreset_walk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_sysreset_get_last(struct unit_test_state *uts)
 {
@@ -109,4 +109,4 @@  static int dm_test_sysreset_get_last(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_sysreset_get_last, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_sysreset_get_last, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/tee.c b/test/dm/tee.c
index 632e9960b0..618f3e3efe 100644
--- a/test/dm/tee.c
+++ b/test/dm/tee.c
@@ -114,4 +114,4 @@  static int dm_test_tee(struct unit_test_state *uts)
 	return rc;
 }
 
-DM_TEST(dm_test_tee, DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_tee, UT_TESTF_SCAN_FDT);
diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index 4fcae03dc5..70c198ac7c 100644
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -377,7 +377,7 @@  static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_fdt_uclass_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that we can find a device by device tree offset */
 static int dm_test_fdt_offset(struct unit_test_state *uts)
@@ -407,7 +407,7 @@  static int dm_test_fdt_offset(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_offset,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
 
 /**
  * Test various error conditions with uclass_first_device() and
@@ -448,7 +448,7 @@  static int dm_test_first_next_device(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_first_next_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_first_next_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test iteration through devices in a uclass */
 static int dm_test_uclass_foreach(struct unit_test_state *uts)
@@ -469,7 +469,7 @@  static int dm_test_uclass_foreach(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_foreach, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_uclass_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /**
  * check_devices() - Check return values and pointers
@@ -549,7 +549,7 @@  static int dm_test_first_next_ok_device(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_first_next_ok_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_first_next_ok_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static const struct udevice_id fdt_dummy_ids[] = {
 	{ .compatible = "denx,u-boot-fdt-dummy", },
@@ -604,7 +604,7 @@  static int dm_test_fdt_translation(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_fdt_translation, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 {
@@ -624,7 +624,7 @@  static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_flat,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
 
 static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
 {
@@ -646,7 +646,7 @@  static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_index_flat,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
 
 static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
 {
@@ -668,7 +668,7 @@  static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_name_flat,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
 
 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 {
@@ -688,7 +688,7 @@  static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_live,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
 {
@@ -710,7 +710,7 @@  static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_index_live,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
 {
@@ -732,7 +732,7 @@  static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
 	return 0;
 }
 DM_TEST(dm_test_fdt_remap_addr_name_live,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
 {
@@ -784,7 +784,7 @@  static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_fdt_livetree_writing, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_fdt_livetree_writing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
 {
@@ -811,8 +811,8 @@  static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
-					    DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_fdt_disable_enable_by_path, UT_TESTF_SCAN_PDATA |
+					    UT_TESTF_SCAN_FDT);
 
 /* Test a few uclass phandle functions */
 static int dm_test_fdt_phandle(struct unit_test_state *uts)
@@ -832,7 +832,7 @@  static int dm_test_fdt_phandle(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_fdt_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test device_find_first_child_by_uclass() */
 static int dm_test_first_child(struct unit_test_state *uts)
@@ -859,7 +859,7 @@  static int dm_test_first_child(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_first_child, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test integer functions in dm_read_...() */
 static int dm_test_read_int(struct unit_test_state *uts)
@@ -904,7 +904,7 @@  static int dm_test_read_int(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_read_int, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int dm_test_read_int_index(struct unit_test_state *uts)
 {
@@ -933,7 +933,7 @@  static int dm_test_read_int_index(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_read_int_index, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_read_int_index, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test iteration through devices by drvdata */
 static int dm_test_uclass_drvdata(struct unit_test_state *uts)
@@ -954,7 +954,7 @@  static int dm_test_uclass_drvdata(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_uclass_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_uclass_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test device_first_child_ofdata_err(), etc. */
 static int dm_test_child_ofdata(struct unit_test_state *uts)
@@ -973,7 +973,7 @@  static int dm_test_child_ofdata(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_child_ofdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_child_ofdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test device_first_child_err(), etc. */
 static int dm_test_first_child_probe(struct unit_test_state *uts)
@@ -992,7 +992,7 @@  static int dm_test_first_child_probe(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_first_child_probe, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_first_child_probe, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test that ofdata is read for parents before children */
 static int dm_test_ofdata_order(struct unit_test_state *uts)
@@ -1017,4 +1017,4 @@  static int dm_test_ofdata_order(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_ofdata_order, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/test-main.c b/test/dm/test-main.c
index 53e5ca321f..b5f2e0d57e 100644
--- a/test/dm/test-main.c
+++ b/test/dm/test-main.c
@@ -87,11 +87,11 @@  static int dm_do_test(struct unit_test_state *uts, struct unit_test *test,
 	ut_assertok(dm_test_init(uts, of_live));
 
 	uts->start = mallinfo();
-	if (test->flags & DM_TESTF_SCAN_PDATA)
+	if (test->flags & UT_TESTF_SCAN_PDATA)
 		ut_assertok(dm_scan_platdata(false));
-	if (test->flags & DM_TESTF_PROBE_TEST)
+	if (test->flags & UT_TESTF_PROBE_TEST)
 		ut_assertok(do_autoprobe(uts));
-	if (test->flags & DM_TESTF_SCAN_FDT)
+	if (test->flags & UT_TESTF_SCAN_FDT)
 		ut_assertok(dm_extended_scan_fdt(gd->fdt_blob, false));
 
 	/*
@@ -166,7 +166,7 @@  static int dm_test_main(const char *test_name)
 		/* Run with the live tree if possible */
 		runs = 0;
 		if (IS_ENABLED(CONFIG_OF_LIVE)) {
-			if (!(test->flags & DM_TESTF_FLAT_TREE)) {
+			if (!(test->flags & UT_TESTF_FLAT_TREE)) {
 				ut_assertok(dm_do_test(uts, test, true));
 				runs++;
 			}
@@ -176,7 +176,7 @@  static int dm_test_main(const char *test_name)
 		 * Run with the flat tree if we couldn't run it with live tree,
 		 * or it is a core test.
 		 */
-		if (!(test->flags & DM_TESTF_LIVE_TREE) &&
+		if (!(test->flags & UT_TESTF_LIVE_TREE) &&
 		    (!runs || dm_test_run_on_flattree(test))) {
 			ut_assertok(dm_do_test(uts, test, false));
 			runs++;
diff --git a/test/dm/timer.c b/test/dm/timer.c
index 9367dab5d5..d7fcd68fb8 100644
--- a/test/dm/timer.c
+++ b/test/dm/timer.c
@@ -21,4 +21,4 @@  static int dm_test_timer_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_timer_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_timer_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/usb.c b/test/dm/usb.c
index a25c2c1482..b7f5b0a4c8 100644
--- a/test/dm/usb.c
+++ b/test/dm/usb.c
@@ -33,7 +33,7 @@  static int dm_test_usb_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_usb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_usb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /*
  * Test that we can use the flash stick. This is more of a functional test. It
@@ -60,7 +60,7 @@  static int dm_test_usb_flash(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_usb_flash, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* test that we can handle multiple storage devices */
 static int dm_test_usb_multi(struct unit_test_state *uts)
@@ -76,7 +76,7 @@  static int dm_test_usb_multi(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_usb_multi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_usb_multi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int count_usb_devices(void)
 {
@@ -120,7 +120,7 @@  static int dm_test_usb_stop(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_usb_stop, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_usb_stop, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /**
  * dm_test_usb_keyb() - test USB keyboard driver
@@ -412,4 +412,4 @@  static int dm_test_usb_keyb(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_usb_keyb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/video.c b/test/dm/video.c
index 0664e3f22b..f4fc40c9c8 100644
--- a/test/dm/video.c
+++ b/test/dm/video.c
@@ -39,7 +39,7 @@  static int dm_test_video_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /**
  * compress_frame_buffer() - Compress the frame buffer and return its size
@@ -132,7 +132,7 @@  static int dm_test_video_text(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_text, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_text, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test handling of special characters in the console */
 static int dm_test_video_chars(struct unit_test_state *uts)
@@ -148,7 +148,7 @@  static int dm_test_video_chars(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_chars, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_chars, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 #ifdef CONFIG_VIDEO_ANSI
 #define ANSI_ESC "\x1b"
@@ -181,7 +181,7 @@  static int dm_test_video_ansi(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_ansi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_ansi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 #endif
 
 /**
@@ -237,7 +237,7 @@  static int dm_test_video_context(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_context, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test rotated text output through the console uclass */
 static int dm_test_video_rotation1(struct unit_test_state *uts)
@@ -246,7 +246,7 @@  static int dm_test_video_rotation1(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_rotation1, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_rotation1, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test rotated text output through the console uclass */
 static int dm_test_video_rotation2(struct unit_test_state *uts)
@@ -255,7 +255,7 @@  static int dm_test_video_rotation2(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_rotation2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_rotation2, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test rotated text output through the console uclass */
 static int dm_test_video_rotation3(struct unit_test_state *uts)
@@ -264,7 +264,7 @@  static int dm_test_video_rotation3(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_rotation3, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_rotation3, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Read a file into memory and return a pointer to it */
 static int read_file(struct unit_test_state *uts, const char *fname,
@@ -302,7 +302,7 @@  static int dm_test_video_bmp(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_bmp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_bmp, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test drawing a compressed bitmap file */
 static int dm_test_video_bmp_comp(struct unit_test_state *uts)
@@ -318,7 +318,7 @@  static int dm_test_video_bmp_comp(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_bmp_comp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_bmp_comp, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test TrueType console */
 static int dm_test_video_truetype(struct unit_test_state *uts)
@@ -333,7 +333,7 @@  static int dm_test_video_truetype(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_truetype, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_truetype, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test scrolling TrueType console */
 static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
@@ -354,7 +354,7 @@  static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_truetype_scroll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_truetype_scroll, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test TrueType backspace, within and across lines */
 static int dm_test_video_truetype_bs(struct unit_test_state *uts)
@@ -375,4 +375,4 @@  static int dm_test_video_truetype_bs(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_video_truetype_bs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_video_truetype_bs, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/virtio.c b/test/dm/virtio.c
index 4b317d2ec3..d87d11cd06 100644
--- a/test/dm/virtio.c
+++ b/test/dm/virtio.c
@@ -33,7 +33,7 @@  static int dm_test_virtio_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_virtio_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_virtio_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test all of the virtio uclass ops */
 static int dm_test_virtio_all_ops(struct unit_test_state *uts)
@@ -79,7 +79,7 @@  static int dm_test_virtio_all_ops(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_virtio_all_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_virtio_all_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test of the virtio driver that does not have required driver ops */
 static int dm_test_virtio_missing_ops(struct unit_test_state *uts)
@@ -97,7 +97,7 @@  static int dm_test_virtio_missing_ops(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_virtio_missing_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_virtio_missing_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Test removal of virtio device driver */
 static int dm_test_virtio_remove(struct unit_test_state *uts)
@@ -119,4 +119,4 @@  static int dm_test_virtio_remove(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_virtio_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_virtio_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/dm/wdt.c b/test/dm/wdt.c
index 1d31ec55c6..d49e572ad5 100644
--- a/test/dm/wdt.c
+++ b/test/dm/wdt.c
@@ -37,4 +37,4 @@  static int dm_test_wdt_base(struct unit_test_state *uts)
 
 	return 0;
 }
-DM_TEST(dm_test_wdt_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(dm_test_wdt_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
diff --git a/test/lib/lmb.c b/test/lib/lmb.c
index a0fe0f6b33..3d3a61db10 100644
--- a/test/lib/lmb.c
+++ b/test/lib/lmb.c
@@ -199,7 +199,7 @@  static int lib_test_lmb_simple(struct unit_test_state *uts)
 	return test_multi_alloc_512mb(uts, 0xE0000000);
 }
 
-DM_TEST(lib_test_lmb_simple, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_simple, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Create two memory regions with one reserved region and allocate */
 static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
@@ -215,7 +215,7 @@  static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
 	return test_multi_alloc_512mb_x2(uts, 0xE0000000, 0x40000000);
 }
 
-DM_TEST(lib_test_lmb_simple_x2,  DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_simple_x2,  UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Simulate 512 MiB RAM, allocate some blocks that fit/don't fit */
 static int test_bigblock(struct unit_test_state *uts, const phys_addr_t ram)
@@ -282,7 +282,7 @@  static int lib_test_lmb_big(struct unit_test_state *uts)
 	return test_bigblock(uts, 0xE0000000);
 }
 
-DM_TEST(lib_test_lmb_big, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_big, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Simulate 512 MiB RAM, allocate a block without previous reservation */
 static int test_noreserved(struct unit_test_state *uts, const phys_addr_t ram,
@@ -357,7 +357,7 @@  static int lib_test_lmb_noreserved(struct unit_test_state *uts)
 	return test_noreserved(uts, 0xE0000000, 4, 1);
 }
 
-DM_TEST(lib_test_lmb_noreserved, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_noreserved, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
 {
@@ -372,7 +372,7 @@  static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
 	return test_noreserved(uts, 0xE0000000, 5, 8);
 }
 
-DM_TEST(lib_test_lmb_unaligned_size, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_unaligned_size, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 /*
  * Simulate a RAM that starts at 0 and allocate down to address 0, which must
  * fail as '0' means failure for the lmb_alloc functions.
@@ -415,7 +415,7 @@  static int lib_test_lmb_at_0(struct unit_test_state *uts)
 	return 0;
 }
 
-DM_TEST(lib_test_lmb_at_0, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_at_0, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Check that calling lmb_reserve with overlapping regions fails. */
 static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
@@ -454,7 +454,7 @@  static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
 }
 
 DM_TEST(lib_test_lmb_overlapping_reserve,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /*
  * Simulate 512 MiB RAM, reserve 3 blocks, allocate addresses in between.
@@ -584,7 +584,7 @@  static int lib_test_lmb_alloc_addr(struct unit_test_state *uts)
 	return test_alloc_addr(uts, 0xE0000000);
 }
 
-DM_TEST(lib_test_lmb_alloc_addr, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+DM_TEST(lib_test_lmb_alloc_addr, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 
 /* Simulate 512 MiB RAM, reserve 3 blocks, check addresses in between */
 static int test_get_unreserved_size(struct unit_test_state *uts,
@@ -656,4 +656,4 @@  static int lib_test_lmb_get_free_size(struct unit_test_state *uts)
 }
 
 DM_TEST(lib_test_lmb_get_free_size,
-	DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);